c_shm_mem.cpp

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

	for( int i = 0 ; i < p_share_mem_info->field_count ; i ++ )
	{
		if( p_field_info[i].key_count != 0 )
		{
			memcpy( &check1[0], &p_element_point[ p_field_info[i].field_pos ], p_field_info[i].field_size );
			memcpy( &check2[0], &c_element[ p_field_info[i].field_pos ], p_field_info[i].field_size );
			if( memcmp( check1, check2, p_field_info[i].field_size ) != 0 )
			{
				theLog<<"不可以修改索引字段!"<<endi;
				v_update_mutex[lock_pos].leaveMutex();
				return errChangeKeyValue;
			}
		}
	}

	/////////////////////////////////////
	//更新，直接修改
	memcpy( &flag[1], c_element, p_share_mem_info->element_size );
	//解锁
	v_update_mutex[lock_pos].leaveMutex();
	///////////////////////////////////////

	//////////////////////////////////////
	//更新，新增一条新记录
	//appendElement( element_value );
	///////////////////////////////////////

	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::loadDataToFile( const char* file_name, const int sql_seq )
// Purpose:    Implementation of c_shm_mem::loadDataToFile( const char* file_name, const int sql_seq )
// Comment:    从数据库中加载数据到文件
// Return:     int，成功:0，失败-1
////////////////////////////////////////////////////////////////////////
int c_shm_mem::loadDataToFile( const char* file_name, const int sql_seq )
{
	char fileName[150];
	strcpy( fileName, file_path );
	strcat( fileName , "/");
	strcat( fileName, file_name );

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

	int i, j = 0;
	char field[MAX_FIELD_SIZE];

	//从数据库中加载数据
	loadSQL();
	loadFieldInfo();
	buildSQLString();

	Statement statement = conn.createStatement();
	
	//把记录组合成一个结构，并写入共享内存中
	char buffer[ MAX_RECORD_SIZE ];
	int record_count = 0;
	char flag = '1';
	char temp[MAX_RECORD_SIZE];
	int* p_int_field;
	int int_field = 0;
	double double_field = 0;
	double* p_double_field;
	long long_field = 0;
	long* p_long_field;

	record_count = 0;
	fwrite( &record_count, sizeof(int), 1, fp );
	//所有sql语句
	for( i = 0 ; i < v_sqlstring.size() ; i ++ )
	{
		if( (sql_seq != -1) || (sql_seq != i) )
		{
			continue;
		}
		
		statement.setSQLString( v_sqlstring[i].c_str() );
		statement.execute();
		
		while( statement>>field )
		{
			//memcpy( &(buffer[p_field_info[j].field_pos]), field, p_field_info[j].field_size );
			switch( p_field_info[j].field_type )
			{
			case STRING_TYPE_D:
				memcpy( &(buffer[p_field_info[j].field_pos]), field, p_field_info[j].field_size );
				break;
			case INT_TYPE_D:
				int_field =  atoi( field );
				p_int_field = (int*) temp;
				memcpy( temp, &int_field, sizeof(int) );
				memcpy( &(buffer[p_field_info[j].field_pos]), temp, sizeof(int) );
				/*if( p_stShareInfo->real_record_count < 10 )
				{
					memcpy( kk, &(buffer[p_field_info[j].field_pos]), sizeof(int) );
					p_int_field = (int*)kk;
					theLog<<field<<"|";
					theLog<<p_int_field[0]<<endi;
				}*/
				break;
			case CHAR_TYPE_D:
				memcpy( &(buffer[p_field_info[j].field_pos]), field, p_field_info[j].field_size );
				break;
			case DOUBLE_TYPE_D :
				double_field = atof(field);
				p_double_field = (double*) temp;
				memcpy( temp, &double_field, sizeof(double) );
				memcpy( &(buffer[p_field_info[j].field_pos]), temp, sizeof(double) );
				break;
			case LONG_TYPE_D :
				long_field = atof(field);
				p_long_field = (long*) temp;
				memcpy( temp, &long_field, sizeof(double) );
				memcpy( &(buffer[p_field_info[j].field_pos]), temp, sizeof(long) );
				break;
			default:
				memcpy( &(buffer[p_field_info[j].field_pos]), field, p_field_info[j].field_size );
				break;
			};
			j ++;
			if( j == p_share_mem_info->field_count )
			{
				//theLog<<"buffer:"<<&buffer[30]<<"|"<<endi;
				j = 0;
				record_count++;				
				fwrite( &flag, 1, 1, fp );
				fwrite( buffer, p_share_mem_info->element_size, 1, fp );
			}
		}
		if( j > 0 )
		{
			//theLog<<"buffer:"<<&buffer[30]<<"|"<<endi;
			j = 0;
			record_count ++;
			fwrite( &flag, 1, 1, fp );
			fwrite( buffer, p_share_mem_info->element_size, 1, fp );
		}
	}
	//写数量
	fseek(fp,0,0);
	fwrite( &record_count, sizeof(int), 1, fp );

	fclose( fp );

	theLog<<"load count:"<<record_count<<"to file:["<<fileName<<"]"<<endi;
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::loadDataFromFile( const char* file_name )
// Purpose:    Implementation of c_shm_mem::loadDataFromFile( const char* file_name )
// Comment:    从文件中读取数据并加载到共享内存中
// Return:     int，成功:0，失败-1
////////////////////////////////////////////////////////////////////////
int c_shm_mem::loadDataFromFile( const char* file_name )
{
	//char fileName[150];
	//strcpy( fileName, file_path );
	//strcat( fileName , "/");
	//strcat( fileName, file_name );

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

	int record_count = 0;
	fread( &record_count, 4, 1, fp );
	theLog<<"共享内存记录数:"<<record_count<<endi;

	fread( head_point, record_count * (p_share_mem_info->element_size + 1), 1, fp );

	//p_stShareInfo->real_record_count = record_count;
	record_count_mutex.enterMutex();
	p_stShareInfo->append_record_count = record_count;
	p_stShareInfo->real_record_count = record_count;
	record_count_mutex.leaveMutex();

	int last_pos;
	fread( &last_pos, 4, 1, fp );
	theLog<<"共享内存记录附加块记录数:"<<last_pos<<endi;
	if ( last_pos > 0 )
	{
		addition_mutex.enterMutex();
		fread( addition_point, 1, last_pos, fp );
		p_stShareInfo->addition_pos = last_pos;
		addition_mutex.leaveMutex();
	}	

	fclose( fp );
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::writeToFile( const char* file_name )
// Purpose:    Implementation of c_shm_mem::writeToFile( const char* file_name )
// Comment:    从共享内存中加载数据到文件
// Return:     int，成功:0，失败-1
////////////////////////////////////////////////////////////////////////
int c_shm_mem::writeToFile( const char* file_name )
{
	//char fileName[150];
	//strcpy( fileName, file_path );
	//strcat( fileName , "/");
	//strcat( fileName, file_name );

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

	//fwrite( &(p_stShareInfo->real_record_count), sizeof(int), 1, fp );
	int recordCount = getRecordCount();
	fwrite( &recordCount, 4, 1, fp);
	fwrite( head_point, recordCount * (p_share_mem_info->element_size +1), 1, fp );

	addition_mutex.enterMutex();
	int last_pos = p_stShareInfo->addition_pos;
	fwrite( &last_pos, 4, 1, fp);
	if ( last_pos > 0 )
	{		
		fwrite( addition_point, 1, last_pos, fp );
	}
	addition_mutex.leaveMutex();



	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::SetData( int seq, void * buf_v )
// Purpose:    Implementation of c_shm_mem::SetData( int seq, void * buf_v )
// Comment:    设置字段的值。
// Return:     int，成功:0，失败errMemLimited
////////////////////////////////////////////////////////////////////////
int c_shm_mem::SetData( int seq, void * buf_v )
{
	if( seq >= p_share_mem_info->field_count )
	{
		theLog<<seq<<"d超过了字段数"<<p_share_mem_info->field_count<<ende;
		return 1;
	}
	if( p_field_info[seq].field_type == 1 )
	{
		if( strlen( (char*) buf_v ) > p_field_info[seq].field_size )
		{
			strncpy( &buff[p_field_info[seq].field_pos], (char*)buf_v, p_field_info[seq].field_size );
		}
		else
		{
			strcpy( &buff[p_field_info[seq].field_pos], (char*)buf_v );
		}
	}
	else
	{
		memcpy( &buff[p_field_info[seq].field_pos], buf_v, p_field_info[seq].field_size );
	}
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::appendElement()
// Purpose:    Implementation of c_shm_mem::appendElement()
// Comment:    添加记录。
//				使用该函数，须先使用SetData，将记录内容添加到buff中，添加时，从buff中获取要修改的记录内容。
// Return:     int，成功:0，失败errMemLimited
////////////////////////////////////////////////////////////////////////
int c_shm_mem::appendElement()
{
	return appendElement( buff );
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::updateElement( int seq )
// Purpose:    Implementation of c_shm_mem::updateElement( int seq )
// Comment:    修改时， 不能修改关键字， 只能修改非关键字的部分。
//				使用该函数，须先使用SetData，将记录内容添加到buff中，更新时，从buff中获取要修改的记录内容。
// Return:     int，成功，0，失败：errNoDataSeq, errDataDelete, errChangeKeyValue
////////////////////////////////////////////////////////////////////////
int c_shm_mem::updateElement( int seq )
{
	void * p_ele = buff;
	updateElement( seq, p_ele );
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::getRecordCount()
// Purpose:    Implementation of c_shm_mem::getRecordCount()
// Comment:		读取实际记录数。
//				在读的过程中需要使用到锁，以防止其它程序在同时更新记录数，因此而读到的错误值。
// Return:     int
////////////////////////////////////////////////////////////////////////
int c_shm_mem::getRecordCount()
{
	int temp;
	record_count_mutex.enterMutex();
	temp = p_stShareInfo->real_record_count;
	record_count_mutex.leaveMutex();
	return temp;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::setRecordCount()
// Purpose:    Implementation of c_shm_mem::setRecordCount()
// Comment:		将append_record_count的值赋给real_record_count，即更新实际记录数
//				使用锁，以防止更新到错误的值。
// Return:     int
////////////////////////////////////////////////////////////////////////
int c_shm_mem::setRecordCount()
{
	record_count_mutex.enterMutex();
	append_mutex.enterMutex();
	p_stShareInfo->real_record_count = p_stShareInfo->append_record_count;
	append_mutex.leaveMutex();
	record_count_mutex.leaveMutex();
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::leaveAllMutex()
// Purpose:    Implementation of c_shm_mem::leaveAllMutex()
// Comment:		解除所有的锁，在有死锁发生时可以调用以解除锁。
// Return:     void
////////////////////////////////////////////////////////////////////////
void c_shm_mem::leaveAllMutex()
{
	append_key_mutex.unlockMutex(3);
	record_count_mutex.unlockMutex(3);
	append_mutex.unlockMutex(60);	
	for(int i = 0; i<v_update_mutex.size(); i++)
		v_update_mutex[i].unlockMutex(60);
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::updateField( int element_seq, int field_seq, void* field_value);
// Purpose:    Implementation of c_shm_mem::updateField( int element_seq, int field_seq, void* field_value);
// Comment:		解除所有的锁，在有死锁发生时可以调用以解除锁。
// Return:     void
////////////////////////////////////////////////////////////////////////
int c_shm_mem::updateField( int element_seq, int field_seq, void* field_value)
{
	int record_count = getRecordCount();
	if( ( element_seq > record_count ) || ( element_seq < 0 ) )
	{
		theLog<<"没有第"<<element_seq<<"个数据!"<<endi;
		return errNoDataSeq;
	}

	int element_pos = element_seq * (p_share_mem_info->element_size + 1) + 1;

	

	if( (field_seq >= p_share_mem_info->field_count) || (field_seq < 0))
	{
		theLog<<"没有第"<<field_seq<<"个字段!"<<endi;
		return errNoFieldSeq;
	}
	
	if( p_field_info[field_seq].key_count != 0 )
	{
		theLog<<"不可以修改索引字段!"<<endi;
		return errChangeKeyValue;
	}

	//计算所在的锁	
	int lock_pos = element_pos / p_share_mem_info->block_size;
	//锁住
	v_update_mutex[lock_pos].enterMutex();

	char* flag = (char *)&(head_point[ element_pos - 1 ]);
	if( flag[0] != '1' )
	{
		theLog<<"这个序号的数据已经被删除了!"<<endi;
		v_update_mutex[lock_pos].leaveMutex();
		return errDataDelete;
	}

	//更新，直接修改
	memcpy( &flag[1+p_field_info[field_seq].field_pos], (char*)field_value, p_field_info[field_seq].field_size );
	//解锁
	v_update_mutex[lock_pos].leaveMutex();
	return 0;
}

int c_shm_mem::getEventAttrByName( const char* event_attr_name, char* out_value )
{
	int event_attr_id = getEventAttrIDByName ( event_attr_name );
	if( event_attr_id < 0 )
	{
		theLog<<"没有事件属性:"<<event_attr_name<<endi;

		return -1;
	}
	else
		return getAttrValue( event_attr_id, out_value );
}

int c_shm_mem::getEventAttrIDByName ( const char* event_attr_name )
{
	return p_share_info->getEventAttrIDByName(event_attr_name);
}

int c_shm_mem::getFieldSeqByAttrName(const char* event_attr_name)
{
	int event_attr_id = getEventAttrIDByName ( event_attr_name );
	if( event_attr_id < 0 )
	{
		return -1;
	}
	else
	{
		return field_attr_id[event_attr_id];
	}
}