c_shm_merge.cpp

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

	temp.seq = field_seq;
	temp.pos = pos;
	temp.size = p_field_info[field_seq].field_size;
	temp.type = p_field_info[field_seq].field_type;
	g_main_key.push_back(temp);

	main_key_size += p_field_info[field_seq].field_size;
	return 0;
}

int c_shm_merge::setItemKey( const int field_seq )
{
	v_item_key.push_back( field_seq );
	return 0;
}

int c_shm_merge::setItem( const int field_seq )
{
	v_item_seq.push_back( field_seq );
	return 0;
}

int c_shm_merge::getMergeItemSeq( const void * p_main )
{
	long* p_long = (long*)p_main;
	if( p_long == NULL )
	{
		return 0;
	}
	else
	{
		return (*p_long % 100) / 10;
	}
	/*char* p_temp = (char*) p_main;
	int len = strlen(p_temp);
	int tmp;
	if( len <= 0 )
	{
		tmp = 0;
	}
	else if( len == 1 )
		tmp = p_temp[0] - '0';
	else
	{
		tmp = p_temp[len-2] - '0';
	}

	if( tmp >= MAX_ITEM_COUNT )
	{
		return tmp % MAX_ITEM_COUNT;
	}
	else if( tmp < 0 )
	{
		return 0;
	}
	else
	{
		return tmp;
	}*/	
}

void c_shm_merge::displayElement( const void * p_main )
{
	//确定是在哪一个小块中
	int mem_seq = getMergeItemSeq( p_main );
	SHM_MERGE_LIST* p_find = p_merge_item[mem_seq]->find( p_main );
	////////////////只用1块
	//SHM_MERGE_LIST* p_find = p_merge_item[0]->find( p_main );

	SHM_MERGE_LIST_ITEM* p_list;
	if( p_find == NULL )
	{
		//printf("Cannot find %s\n", (char*)p_main);
	}
	else
	{
		//printf("find!%d\n", p_find->item_pos);
		p_list = &(p_merge_addition->p_merge_list_item[p_find->item_pos]);
		int i;
		while( p_list->next_pos != -1 )
		{
			for( i = 0 ; i < MAX_LIST_COUNT ; i ++ )
			{
				printf("key:%d, fee:%d\n", p_list->acctFee[i].key, p_list->acctFee[i].fee);
			}
			printf("nextpos:%d\n", p_list->next_pos);
			p_list = &(p_merge_addition->p_merge_list_item[p_list->next_pos]);
		}
		if(p_list!=NULL)
		{
			for( i = 0 ; i < MAX_LIST_COUNT ; i ++ )
			{
				printf("key:%d, fee:%d\n", p_list->acctFee[i].key, p_list->acctFee[i].fee);
			}
			printf("nextpos:%d\n", p_list->next_pos);
		}
	}
}

int c_shm_merge::getMainElement( const void * p_main )
{
	int mem_seq = getMergeItemSeq( p_main );
	SHM_MERGE_LIST* p_find = p_merge_item[mem_seq]->find( p_main );
	if( p_find == NULL )
	{
		get_next_pos = -1;
		return -1;
	}
	else
	{
		get_next_pos = p_find->item_pos;
	}	
	return 0;
}

int c_shm_merge::setBillingCycelID( const int billing_cycle_id )
{
	p_serial_list[1] = billing_cycle_id;
	p_serial_list[0] = 0;
	p_serial_list[2] = 0;
	memset( &(p_serial_list[3]), 0, sizeof(int)*(MAX_SERIAL_COUNT-3) );
	return 0;
}

int c_shm_merge::addSerial( const int serial_no, const int billing_cycle_id )
{
	if( p_serial_list[1] != billing_cycle_id )
	{
		//帐期不符
		return -2;
	}
	append_key_mutex.enterMutex();
	/*cout<<p_serial_list[0]<<"|"<<p_serial_list[2]<<":::";
	for( int i = 0; i< p_serial_list[0]; i++)
		cout<<p_serial_list[i+3]<<" ";
	cout<<"::::";
	for( i=0; i<p_serial_list[2]; i++ )
		cout<<p_serial_list[i+UNSORT_SERIAL_POS]<<" ";
	cout<<endl;
	*/
	//查找
	int* p_find = (int*)bsearch( &serial_no, &(p_serial_list[3]), p_serial_list[0], sizeof(int), serialComp );
	if( p_find == NULL )
	{
		if( p_serial_list[2] == 0 )
		{
			//初始化			
			p_serial_list[UNSORT_SERIAL_POS] = serial_no;
			p_serial_list[2] ++;
			append_key_mutex.leaveMutex();
			return 0;
		}
		else
		{
			//插入
			p_find = (int*)bsearch( &serial_no, &(p_serial_list[UNSORT_SERIAL_POS]), p_serial_list[2], sizeof(int), serialComp );
			if( p_find == NULL )
			{
				p_serial_list[UNSORT_SERIAL_POS+p_serial_list[2]] = serial_no;
				p_serial_list[2] ++;				
				if( p_serial_list[2] >= MAX_UNSORT_SERIAL_COUNT )
				{
					memcpy( &(p_serial_list[p_serial_list[0]+3]), &(p_serial_list[UNSORT_SERIAL_POS]), sizeof(int)*p_serial_list[2] );
					p_serial_list[0] += p_serial_list[2];
					qsort(&(p_serial_list[3]), p_serial_list[0], sizeof(int), serialComp);
					memset( &(p_serial_list[UNSORT_SERIAL_POS]), 0, sizeof(int)*p_serial_list[2] );
					p_serial_list[2] = 0;
				}
				else
				{
					qsort( &(p_serial_list[UNSORT_SERIAL_POS]), p_serial_list[2], sizeof(int), serialComp);
				}
				append_key_mutex.leaveMutex();
				return 0;
			}
			else
			{
				append_key_mutex.leaveMutex();
				return -1;
			}
		}
	}
	else
	{
		append_key_mutex.leaveMutex();
		return -1;
	}
	/*
	if( p_serial_list[1] != billing_cycle_id )
	{
		return -2;
	}

	//cout<<"add serial:"<<p_serial_list[0]<<"|"<<serial_no<<endl;
	if( p_serial_list[0] == 0 )
	{
		p_serial_list[0] ++;
		p_serial_list[p_serial_list[0]+1] = serial_no;
		return 0;
	}
	
	int* p_find = (int*)bsearch( &serial_no, &(p_serial_list[2]), p_serial_list[0], sizeof(int), serialComp );
	if( p_find == NULL )
	{
		p_serial_list[0] ++;
		p_serial_list[p_serial_list[0]+1] = serial_no;
		qsort(&(p_serial_list[2]), p_serial_list[0], sizeof(int), serialComp);
		return 0;
	}
	else
	{
		return -1;
	}
	*/
}


void c_shm_merge::showLastSerial()
{
	int last_serial;
	append_key_mutex.enterMutex();
	
	if( p_serial_list[2] == 0 )
	{
		if( p_serial_list[0] == 0 )
		{
			last_serial = -1;
		}
		else
		{
			last_serial = p_serial_list[ p_serial_list[0]+3 ];
		}
	}
	else
	{
		last_serial = p_serial_list[UNSORT_SERIAL_POS+p_serial_list[2]-1];
	}
	append_key_mutex.leaveMutex();
	cout<<"最后处理的文件系列ID是:"<<last_serial<<endl;
	return ;
}

void c_shm_merge::showAllSerial()
{
	append_key_mutex.enterMutex();
	append_key_mutex.leaveMutex();
}

int c_shm_merge::backupShm()
{	
	int backup_num = 0;
	try
	{
		g_statement.setSQLString("select BACKUP_NUM from shm_backup_info where backup_date = (select max(backup_date) from shm_backup_info)");
		g_statement.execute();
		while(g_statement>>backup_num)
			;
	}
	catch(Exception& ex )
	{
		cout<<"错误:select BACKUP_NUM from shm_backup_info where backup_date = (select max(backup_date) from shm_backup_info)"<<endl<<ex.what();
	}
	if( backup_num <= 0 )
	{
		backup_num = 1;
	}
	else if ( backup_num >= max_backup_num )
	{
		backup_num = 1;
	}
	else
	{
		backup_num ++;
	}

	char file_name[60];
	sprintf( file_name, "%d", backup_num );
	//strcpy(file_name, ltoa( backup_num ));

	char full_name[300];
	strcpy( full_name, backup_dir );
	strcat( full_name, "/" );
	strcat( full_name, file_name );
	if( saveFile( full_name ) == 0 )
	{
		//m_sql = "alter session set NLS_DATE_FORMAT = yyyymmddhh24miss";
		try
		{
			g_statement.setSQLString( "alter session set NLS_DATE_FORMAT = yyyymmddhh24miss" );
			g_statement.execute();

			g_statement.setSQLString("insert into shm_backup_info ( BACKUP_DIR, BACKUP_FILENAME, BACKUP_NUM, BACKUP_DATE ) values (:dir, :filename, :num, SYSDATE)");
			g_statement<<backup_dir<<file_name<<backup_num;
			g_statement.execute();
			conn.commit();
		}
		catch( Exception& ex )
		{
			cout<<"错误：insert into shm_backup_info ( BACKUP_DIR, BACKUP_FILENAME, BACKUP_NUM, BACKUP_DATE ) values (:dir, :filename, :num, SYSDATE)"<<endl
				<<ex.what();
		}

		return 0;
	}
	else
	{
		return -2;
	}
}

int c_shm_merge::restoreShm()
{
	int backup_num = 0;
	char file_name[60];
	char file_dir[120];
	char full_name[300];
	try
	{
		g_statement.setSQLString("select BACKUP_NUM, BACKUP_DIR, BACKUP_FILENAME from shm_backup_info where backup_date = (select max(backup_date) from shm_backup_info)");
		g_statement.execute();
		while( g_statement>>backup_num>>file_dir>>file_name )
			;
	}
	catch( Exception& ex )
	{
		cout<<"错误:select BACKUP_NUM, BACKUP_DIR, BACKUP_FILENAME from shm_backup_info where backup_date = (select max(backup_date) from shm_backup_info)"<<endl
			<<ex.what();
	}
	if( backup_num <= 0 )
	{
		return -1;
	}
	else
	{
		strcpy( full_name, file_dir );
		strcat( full_name, "/" );
		strcat( full_name, file_name );
		if( loadFile( full_name ) == 0 )
		{
			return 0;
		}
		else
		{
			return -2;
		}
	}
}

int c_shm_merge::saveFile(const char* file_name)
{
	char fileName[150];
	//strcpy( fileName, backup_dir );
	//strcat( fileName , "/");
	strcpy( fileName, file_name );

	FILE * fp;
	fp = fopen( fileName, "wb");
	if( fp == NULL )
	{
		printf("文件[%s]打开错误\n",  file_name );
		return -1;
	}

	//写头信息
	//信息头指针
	//STSHAREINFO* p_stShareInfo;
	fwrite( p_stShareInfo, sizeof(STSHAREINFO), 1, fp );
	//配置信息头指针
	//SHARE_MEM_INFO* p_share_mem_info;
	fwrite( p_share_mem_info, sizeof(SHARE_MEM_INFO), 1, fp );
	//获取配置信息的类  
	//c_share_info* p_share_info;	
	//fwrite( p_share_info, sizeof(c_share_info), 1, fp );
	//写main_key_size
	fwrite( &main_key_size, sizeof(int), 1, fp );
//printf("main_key_size:%d\n", main_key_size);
	//写serial_list
	fwrite( p_serial_list, sizeof(int), p_serial_list[0]+2, fp );
	//写十个子块
	for( int i=0; i<MAX_ITEM_COUNT; i++ )
	{
		fwrite( p_merge_item[i]->p_merge_info, sizeof(SHM_MERGE_INFO), 1, fp );
		//printf("%drecord count:%d,%d\n", i,p_merge_item[i]->p_merge_info->record_count, p_merge_item[i]->p_merge_info->add_record_count);
		fwrite( p_merge_item[i]->p_merge_list, sizeof(SHM_MERGE_LIST), p_merge_item[i]->p_merge_info->record_count, fp );
		fwrite( p_merge_item[i]->p_add_merge_list, sizeof(SHM_MERGE_LIST), p_merge_item[i]->p_merge_info->add_record_count, fp );
	}

	//写附加块
	fwrite( p_merge_addition->p_merge_info, sizeof(SHM_MERGE_INFO), 1, fp );
	fwrite( p_merge_addition->p_merge_list_item, sizeof(SHM_MERGE_LIST_ITEM), p_merge_addition->p_merge_info->record_count, fp );

	return 0;
}

int c_shm_merge::loadFile(const char* file_name)
{
	char fileName[150];
	//strcpy( fileName, backup_dir );
	//strcat( fileName , "/");
	strcpy( fileName, file_name );

	FILE * fp;
	fp = fopen( fileName, "rb");
	if( fp == NULL )
	{
		printf("文件[%s]打开错误\n",  file_name );
		return -1;
	}

	//写头信息
	//信息头指针
	//STSHAREINFO* p_stShareInfo;	
	fread( p_stShareInfo, sizeof(STSHAREINFO), 1, fp );
	//配置信息头指针
	//SHARE_MEM_INFO* p_share_mem_info;
	fread( p_share_mem_info, sizeof(SHARE_MEM_INFO), 1, fp );
	//获取配置信息的类  
	//c_share_info* p_share_info;	
	//fread( p_share_info, sizeof(c_share_info), 1, fp );
	//写main_key_size
	int key_size;
	fread( &key_size, sizeof(int), 1, fp );