types.c

eXtremeDB数据库在Linux平台下的使用源码。内含多个示例程序

/***************************************************************
 *                                                             *
 * Copyright (c) 2001-2007 McObject LLC. All Right Reserved.   *
 *                                                             *
 ***************************************************************/

/* This samples demonstartes various data types supported
 * by eXtremeDB.
 * insert() function creates an object that contains fields
 * of various types - integers, arrays, vectors, blob, string
 * see types.mco
 * erase() function deletes previously created objects one
 * by-one. Memory statistics is collected before and after
 * the objects are inserted and deleted.
 */

#include <platform.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "typesdb.h"

static const char   *dbname = "TypesDb";
static const int  SEGSZ = 1024 * 8000UL;
#ifndef MCO_PLATFORM_X64
static const int  PAGESIZE = 96;
#else
static const int  PAGESIZE = 192;
#endif

const int MAP_ADDRESS =  0x20000000;

static int obj_count=0;

#define NUMOBJECTS 2000

void _SH_(void) {

	char text[] = {
		"\nThis samples demonstartes various data types supported\n"
		"by eXtremeDB. It creates and than deletes a number of objects\n"
		"with fields of different types - integer numbers, arrays, vectors\n"
		"and blobs. Class statistics and memory usage is displayed\n"
	};

	char text1[] = {
		"Copyright (c) 2001-2007 McObject LLC. All Right Reserved.\n\n"
	};

	printf("%s\neXtremeDB runtime version %d.%d, build %d\n%s\n\nPress Enter to start",
		text, MCO_COMP_VER_MAJOR, MCO_COMP_VER_MINOR, MCO_COMP_BUILD_NUM,text1);

	getchar();

}


void showStat( mco_db_h db, uint2 class_code ) {
	MCO_RET             rc = 0;
	mco_trans_h         t;
	mco_class_stat_t    stat;

	mco_trans_start( db, MCO_READ_WRITE, MCO_TRANS_FOREGROUND, &t );
	rc = mco_class_stat_get( t, class_code, &stat );
	mco_trans_commit( t );

	if ( rc == MCO_S_OK ) {
		printf(
			"\n\tStatistics for the class with code %d:\n"
			"\tNumber of objects:\t%ld\n"
			"\tTotal core pages used:\t%ld\n"
			"\tTotal blob pages used:\t%ld\n"
			"\tTotal core space used:\t%ld\n",
			class_code,
			stat.objects_num,
			stat.core_pages,
			stat.blob_pages,
			stat.core_space
			);
	}
}


void showMem( mco_db_h db ) {
	mco_puint totalpg, freepg;

	mco_db_free_pages( db, &freepg );
	mco_db_total_pages( db, &totalpg );

	printf(	"\n\tMemory Report:\n\ttotal pages=%d (%dK)\n\tfree pages=%d (%dK)\n\tused %dK\n",
		totalpg,
		totalpg * PAGESIZE / 1024,
		freepg,
		freepg * PAGESIZE / 1024,
		(totalpg - freepg) * PAGESIZE / 1024
		);
}


static int random_string(int len, char *  str) {
	int ind;

	for (ind = 0; ind < len; ind++) {
		int num = 'A' + rand()%('Z'-'A');
		str[ind]= (char)num;
	}
	str[len] = '\0';
	return 0;

}


static uint2 rand2( uint2 lowlimit, uint2 uplimit ) {
	int n = rand();
	return( n % (uplimit - lowlimit + 1) ) + lowlimit;
}


static void get_random_string( char *to ) {
	static const char *exchange[3] = { "NASDAQ", "AMEX", "NYSE" };
	strcpy( to, exchange[rand2(0, 2)]);
}


/* 
 */
static int erase(mco_db_h db) {
	mco_cursor_t  csr;
	mco_trans_h   t;
	AllTypes      types_obj;
	int8          u8;
	MCO_RET       rc;

	mco_trans_start( db, MCO_READ_WRITE, MCO_TRANS_FOREGROUND, &t );

	/* initialize cursor */
	rc = AllTypes_list_cursor( t, &csr );

	if ( rc != MCO_S_OK ) {
		mco_trans_commit( t );
		return rc;
	}

	rc = mco_cursor_first(t, &csr);
	AllTypes_from_cursor( t, &csr, &types_obj );

	AllTypes_autoid_get(&types_obj, &u8);
	rc = AllTypes_delete( &types_obj );
	if (rc) {
		mco_trans_rollback(t);
#ifdef	MCO_CFG_QUAD_STRUCT
		printf("\nError erasing object with autoid = {%ld, %ld}\n", u8.lo, u8.hi);
#else  /* MCO_CFG_QUAD_STRUCT */
		printf("\nError erasing object with autoid = {%lld}\n", u8);
#endif /* MCO_CFG_QUAD_STRUCT */
	}

	mco_trans_commit( t );
	//  printf("\nObject with autoid = {%ld, %ld} deleted successfully\n", u8.lo, u8.hi);
	obj_count++;

	return 0;
}


static int insert(mco_db_h db, int num) {

	int i;
	MCO_RET     rc;
	mco_trans_h t;
	AllTypes    types_obj;

	char str[8];
	DynStruct   ds;
	FixedStruct fs;
	time_t ltime;

	static mco_uquad u8 = {0};

	rc = mco_trans_start(db,MCO_READ_WRITE,MCO_TRANS_FOREGROUND,&t);
	if(rc)
		return rc;

	rc = AllTypes_new(t, &types_obj);
	if (rc) {
		//printf("rc=%d\n", rc);
		goto err;
	}

	/* mco_time . This is unformatted time that corresponds
	   to ANSI time_t */
	time(&ltime);
	AllTypes_time_in_put(&types_obj,ltime);

	/* integers */
	AllTypes_u1_put(&types_obj,(uint1)num);
	AllTypes_u2_put(&types_obj,(uint2)num);
	AllTypes_u4_put(&types_obj,(uint4)num);

	mco_uquad_increment( &u8 );
	AllTypes_u8_put(&types_obj,u8);

	/* arrays */
	for (i=0; i< AllTypes_ds_length; i++) {
		AllTypes_ds_put(&types_obj,(uint2)i,&ds );
		get_random_string(str);
		DynStruct_s_put ( &ds, str, (uint2)strlen(str));
	}

	for (i=0; i< AllTypes_fs_length; i++) {
		AllTypes_fs_put(&types_obj, (uint2)i,&fs );

		FixedStruct_u4_put(&fs, (uint4)rand() );
		FixedStruct_u8_put(&fs, u8 );

	}

	for (i=0; i< AllTypes_vint4_length; i++) {
		AllTypes_vint4_put(&types_obj, (uint2)i, (uint4)rand() );
	}

	/* vectors */
	{
		uint2 nelem = rand2(1,20);
		AllTypes_vs_alloc ( &types_obj, nelem);
		for(i = 0; i < nelem; i++) {
			get_random_string(str);
			AllTypes_vs_put(&types_obj, (uint2)i, str, (uint2)strlen(str));
		}
	}

	/* blob */
	{
		char text[2000];
		random_string(strlen(text), text);
		rc = AllTypes_blo_put( &types_obj, text, strlen(text) );
	}

	rc = mco_trans_commit(t);
	obj_count++;
	return rc;

	err:
	rc = mco_trans_rollback(t);
	return rc;
}


/* fatal error handler */
static void errhandler( int n ) {
	printf( "\neXtremeDB runtime fatal error: %d", n );
	getchar();
	exit( -1 );
}


int main( void ) {
	MCO_RET     rc;
	mco_db_h    db = 0;
	int         num = NUMOBJECTS;
	char    * start_mem;
	mco_runtime_info_t info;

	_SH_();
	mco_get_runtime_info( &info);
	if ( info.mco_shm_supported ) {
		start_mem = (char*)MAP_ADDRESS;
	}
	else {
		start_mem = (char*)malloc(SEGSZ);
		if (!start_mem) {
			printf("Couldn't allocated memory\n");
			exit (1);
		}
	};

	/* set fatal error handler */
	mco_error_set_handler( &errhandler );

	rc = mco_runtime_start();

	rc = mco_db_open( dbname, typesdb_get_dictionary(), start_mem, SEGSZ, (uint2) PAGESIZE );

	if ( rc ) {
		printf( "\nerror creating database" );
		if ( !info.mco_shm_supported )
			free( start_mem );
		exit( 1 );
	}

	/* connect to the database, obtain a database handle */
	mco_db_connect( dbname, &db );
	printf( "\nDatabase created successfully, db handle = %d\n%dK allocated for the database\nDatabase pagesize is %d bytes\n\n",
		db, SEGSZ/1024, PAGESIZE );

	showStat( db, AllTypes_code);
	showMem( db );

	srand( (unsigned) time(NULL) );
	while ( 0 < num-- ) {
		/* create a new object */
		rc = insert(db, num);
		if (rc != 0)
			break;
	}

	showStat( db, AllTypes_code);

	num = NUMOBJECTS;
	obj_count = 0;
	/* delete all objects */
	while ( 0 < num-- ) {
		rc = erase(db);
		if (rc != 0)
			break;
	}

	showStat( db, AllTypes_code);
	showMem( db );

	/* disconnect from the database, db is no longer valid */
	mco_db_disconnect( db );
	/* destroy the db */
	mco_db_close( dbname );
	mco_runtime_stop();

	if ( !info.mco_shm_supported )
		free( start_mem );

	printf("\nPress Enter key to exit" );
	getchar();
  PROG_EXIT(0);

}