xmlload.c

extremeDB s sample code,useful for you

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

/* This samples demonstartes eXtremeDB XML input capabilities
 * The insert() function parses the xml file, creating the
 * database objects.
 *
 * The output() function writes all database in XML format to
 * standard output
 *
 */

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

#include "XMLtestDB.h"

static const char *dbname = "XMLtestDB";
static const int  SEGSZ = 1024 * 1024 * 1;
#ifndef MCO_PLATFORM_X64
static const int  PAGESIZE = 96;
#else
static const int  PAGESIZE = 192;
#endif


static int num_obj[3];

static FILE *file;
#define XML_TEXT_SIZE 10000						  /* size in bytes for xml buffer for 1 xml-object */
static char xml[XML_TEXT_SIZE];
static int  ptr;

#if defined (_VXWORKS)
  char xml_name[] = "/tgtsvr/input.xml";
#elif defined (_WIN32_WCE)
  char xml_name[] = "input.xml";
#else
  char xml_name[] = "input.xml";
#endif

const int MAP_ADDRESS =  0x20000000;

/************************************************************/

void _SH_(void) {

	char text[] = {"\nThis samples demonstartes eXtremeDB XML load\n"};

	char text1[] = {
		"Copyright (c) 2001-2006 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);
		num_obj[class_code-1] = stat.objects_num;
	}
}


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\t free pages=%d (%dK)"
		"\n\t used %dK\n",
		totalpg, totalpg * PAGESIZE / 1024,
		freepg,  freepg * PAGESIZE / 1024,
		(totalpg - freepg) * PAGESIZE / 1024);
}


/************************************************************/

static int erase(mco_db_h db) {
	mco_cursor_t  csr;
	mco_trans_h   t;
	Person        p_obj;
	Children      c_obj;
	Dog           d_obj;
	int           n;

	for ( n=0; n < num_obj[Dog_code-1]; n++ ) {
		mco_trans_start( db, MCO_READ_WRITE, MCO_TRANS_FOREGROUND, &t );
		Dog_list_cursor( t, &csr );
		mco_cursor_first(t, &csr);
		Dog_from_cursor( t, &csr, &d_obj );
		Dog_delete( &d_obj );
		mco_trans_commit( t );
	}
	for ( n=0; n < num_obj[Children_code-1]; n++ ) {
		mco_trans_start( db, MCO_READ_WRITE, MCO_TRANS_FOREGROUND, &t );
		Children_list_cursor( t, &csr );
		mco_cursor_first(t, &csr);
		Children_from_cursor( t, &csr, &c_obj );
		Children_delete( &c_obj );
		mco_trans_commit( t );
	}
	for ( n=0; n < num_obj[Person_code-1]; n++ ) {
		mco_trans_start( db, MCO_READ_WRITE, MCO_TRANS_FOREGROUND, &t );
		Person_list_cursor( t, &csr );
		mco_cursor_first(t, &csr);
		Person_from_cursor( t, &csr, &p_obj );
		Person_delete( &p_obj );
		mco_trans_commit( t );
	}
	return 0;
}


/************************************************************/

int do_print(void *stream_handle,
const void * from, unsigned nbytes) {
	unsigned i;
	stream_handle = 0;
	for ( i=0; i < nbytes; i++ ) printf("%c", ((char*)from)[i]);
	return 0;
}


/************************************************************/

static const char xml_header1[] ="<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
static const char xml_header2[] ="<data>";
static const char xml_footer[] = "</data>";

static int insert(mco_db_h db) {

	MCO_RET     rc;
	mco_trans_h t;
	Person      p_obj;
	Children    c_obj;
	Dog         d_obj;
	int         class_code;
	int         c;

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

	for (;;) {									  /* loop on xml-objects */
		/* skip all before class tag */
		do c = getc(file);
		while ( c != '<'  &&  c != EOF );
		if ( c == EOF ) break;					  /* finished */
		ptr = 1;
		xml[0] = '<';
		/* read class name */
		do {
			c = getc(file);
			xml[ptr++] = c;
		} while ( c != '>'  &&  c != EOF );
		if ( c == EOF ) break;					  /* finished */
		xml[ptr] = 0;
		if      ( strcmp(xml, "<Person>")   == 0 ) class_code = Person_code;
		else if ( strcmp(xml, "<Children>") == 0 ) class_code = Children_code;
		else if ( strcmp(xml, "<Dog>")      == 0 ) class_code = Dog_code;
		// skip the XML header

		else if (strcmp(xml, xml_header1)   == 0 ) continue;
		else if (strcmp(xml, xml_header2)   == 0 ) continue;
		else if (strcmp(xml, xml_footer)    == 0 ) continue;

		else {
			printf("\nError - undefined class '%s'\n", xml);
			exit(3);
		}

		/* read xml-object */
		for (;;) {
			c = getc(file);
			if ( c == EOF ) {
				xml[ptr] = 0;
				printf("\nError - unexpected end of file: %s\n",
					&xml[(ptr>50)?ptr-50:0]);
				exit(4);
			}
			xml[ptr++] = c;
			if ( c == '>' ) {
				xml[ptr] = 0;
				if ( class_code == Children_code ) {
					if ( strcmp("</Children>", &xml[ptr-11]) == 0 ) break;
				}
				else if ( class_code == Person_code ) {
					if ( strcmp("</Person>", &xml[ptr-9]) == 0 ) break;
				}
				else if ( class_code == Dog_code    ) {
					if ( strcmp("</Dog>", &xml[ptr-6]) == 0 ) break;
				}
			}
		}
		switch ( class_code ) {
			case Children_code: rc = Children_xml_create(t, xml, &c_obj); break;
			case Person_code  : rc =   Person_xml_create(t, xml, &p_obj); break;
			case Dog_code     : rc =      Dog_xml_create(t, xml, &d_obj); break;
		}
		if ( rc != MCO_S_OK )
			{ printf("ERR CREATE %d\n", rc); exit(0); }
			ptr =0;
	}											  /* loop on xml-objects */

	rc = mco_trans_commit(t);
	return rc;
}


/************************************************************/

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


/************************************************************/

#include "mcoxml.h"

MCO_RET output (mco_db_h db) {
	mco_trans_h t;
	Person p_obj;
	Children c_obj;
	Dog      d_obj;
	MCO_RET rc;
	mco_cursor_t  c;

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

	rc = Person_list_cursor(t, &c);
	if(rc) return rc;
	rc = mco_cursor_first(t, &c);
	if(rc) return rc;
	for(;;) {
		rc = Person_from_cursor ( t, &c, &p_obj);
		if(rc) return rc;
		rc = Person_xml_get(&p_obj, 0, &do_print);
		if(rc) return rc;
		if ( mco_cursor_next(t, &c) != MCO_S_OK ) break;
	}

	rc = Children_list_cursor(t, &c);
	if(rc) return rc;
	rc = mco_cursor_first(t, &c);
	if(rc) return rc;
	for(;;) {
		rc = Children_from_cursor ( t, &c, &c_obj);
		if(rc) return rc;
		rc = Children_xml_get(&c_obj, 0, &do_print);
		if(rc) return rc;
		if ( mco_cursor_next(t, &c) != MCO_S_OK ) break;
	}

	rc = Dog_list_cursor(t, &c);
	if(rc) return rc;
	rc = mco_cursor_first(t, &c);
	if(rc) return rc;
	for(;;) {
		rc = Dog_from_cursor ( t, &c, &d_obj);
		if(rc) return rc;
		rc = Dog_xml_get(&d_obj, 0, &do_print);
		if(rc) return rc;
		if ( mco_cursor_next(t, &c) != MCO_S_OK ) break;
	}

	rc = mco_trans_commit(t);
	return rc;
}


/************************************************************/

int main( int argc, char **argv ) {
	MCO_RET       rc;
	mco_db_h  db = 0;
	char    * start_mem;
	mco_trans_h   t;
	mco_xml_policy_t policy;

	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);
		}
	};

	file = fopen(xml_name, "r");

	if ( file == 0 ) {
		printf("Cannot open file\n");
		exit(2);
	}

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

	rc = mco_runtime_start();
	rc = mco_db_open( dbname, XMLtestDB_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",
		(int)db, SEGSZ/1024, PAGESIZE );

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

	if (MCO_E_UNSUPPORTED == (rc=mco_xml_get_policy(t, &policy))) {
		printf("\nXML is not supported!\n\n");
		goto end;
	}

	policy.text_coding = MCO_TEXT_ASCII;		  //BASE64;
	policy.blob_coding = MCO_TEXT_ASCII;		  //BASE64;
	policy.ignore_field = MCO_YES;

	mco_xml_set_policy(t, &policy);

	rc = mco_trans_commit(t);
	if(rc) goto end;

	printf("\n\nLoading XML from file...");
	rc = insert(db);
	printf ("done\n\n");
	if(rc) goto end;

	printf("\n\nReading XML from the database to the standard output\n\n");
	rc = output(db);

	end:
	/* 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);

}