dbinit.c

extremeDB s sample code,useful for you

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

#include "load.h"

uint2 fv = 0;
uint2 dv = 0;
uint2 bv = 0;
uint2 bh = 0;
uint2 iv = 0;

uint2 nh = 0;
uint2 nb = 0;
uint2 nd = 0;
uint2 nf = 0;
uint2 ni = 0;

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;
	}
	return 0;

}


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


int new_fixed(mco_db_h  db, int count) {
	Fixed fixed;
	MCO_RET rc = 0;
	char txt[] = "abcd";
	mco_trans_h t;
	dbtest_oid oid;

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

	oid.seq = count;
	rc = Fixed_new(t, &oid, &fixed);
	if (rc) return rc;

	Fixed_oid_get(&fixed, &oid);
	//printf ("OID= %ld\n", oid.seq);

	Fixed_u4_put(&fixed, (uint4) count );
	Fixed_f_put (&fixed, (float) count) ;
	Fixed_u2_put(&fixed, (uint2) count );

	rc = Fixed_c4_put(&fixed, txt, (uint2)strlen(txt) );
	if (rc)
		mco_trans_rollback(t);
	else {
		rc = mco_trans_commit(t);
		nf++;
	}
	return rc;

}


int new_dynamic(mco_db_h    db, int cnt) {
	Dynamic dyn;
	MCO_RET rc = 0;
	mco_trans_h t;

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

	if (MCO_S_OK != (rc = Dynamic_new(t, &dyn)))
		return rc;
		
	{
		uint2 i;
		char *s = malloc(STEP * (cnt +1));
		if (!s) return -1;

		for (i = 0; i < STEP * (cnt +1); i++)
			s[i] = 'A';

		rc = Dynamic_str_put( &dyn, s, (uint2) (STEP * (cnt +1)));
		free (s);

		if (rc) {
			mco_trans_rollback(t);
			return rc;
		}
	}
	{
		uint2 vsize = rand2(0,50);
		uint2 i;

		Dynamic_vu4_alloc(&dyn, vsize);

		for (i = 0; i < vsize; i++)
			rc |= Dynamic_vu4_put(&dyn, i, rand2(100, 1000));

		if (rc) {
			mco_trans_rollback(t);
			return rc;
		}
	}

	if (cnt % 2) {
		Item item;
		uint2 i;
		char *s = malloc(STEP * (cnt +1));
		if (!s) return -1;

		Dynamic_item_write_handle(&dyn, &item);
		Item_id_put( &item, rand() );

		for (i = 0; i < STEP * (cnt +1); i++)
			s[i] = 'A';

		rc = Item_name_put( &item, s, (uint2) (STEP * (cnt +1)));
		free (s);
		if (rc) {
			mco_trans_rollback(t);
			return rc;
		}
	}
	rc = mco_trans_commit(t);
	return rc;

}


int new_blobs(mco_db_h  db, int cnt) {
	Blobs blob;
	MCO_RET rc = 0;
	mco_trans_h t;
	char *txt = 0;
	uint4 ind;
	int8 u8;
	static uint8 u8v = {0};
	uint4 this_blob_size = 10*STEP*(cnt +1);

	if ((txt = malloc(this_blob_size))==0)
		return -1;

	for (ind = 0; ind < this_blob_size; ind++)
		txt[ind]= 'A';

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

	rc = Blobs_new(t, &blob);
	if (rc)
		goto err;

	rc = Blobs_blo_put( &blob, txt, this_blob_size );
	if (rc)
		goto err;
	rc = Blobs_num_put( &blob, (uint2)rand());
	if (rc)
		goto err;

	mco_uquad_increment(&u8v);
	Blobs_u8_put(&blob, u8v );

	rc = Blobs_autoid_get( &blob, &u8);
	if (rc)
		goto err;

	free(txt);
	rc = mco_trans_commit(t);
	if (SUCCESS(rc)) nb++;

	/* Perform the update for ever other object */
	/* Since the class is declared with history, such
	   updates create it */
	if ( info.mco_versioning_supported ) {
		for (ind=0; ind <Blobs_versions_limit-1; ind++) {
			uint4 bsz = 0, real_bsz=0;
			uint4 i4;
			char *dest = 0;

			mco_trans_start(db, MCO_READ_WRITE, MCO_TRANS_FOREGROUND, &t);
			rc = Blobs_autoid_find (t, u8, &blob);
			if (rc )
				goto err;
			Blobs_blo_size (&blob, &bsz);

			if ((dest = malloc(bsz))==0) {
				mco_trans_rollback(t);
				break;
			}
			Blobs_blo_get (&blob, 0, dest, bsz, &real_bsz);
			for (i4 = 0; i4 < real_bsz; i4++)
				dest[i4]++;
			Blobs_blo_put (&blob, dest, real_bsz);

			rc = mco_trans_commit(t);
			if (rc)
				break;
			else
				nh++;
		};
	};

	return rc;

err:
	free(txt);
	mco_trans_rollback(t);
	return rc;

}


int new_idx(mco_db_h    db, int count) {
	MCO_RET rc = 0;
	Idxs iobj;
	dbtest_oid oid;
	mco_trans_h t;
	Item item;
	uint2 i, vsize = rand2(0,100);
	char itemname[30];

	rc = mco_trans_start(db, MCO_READ_WRITE, MCO_TRANS_FOREGROUND, &t);
	if (!SUCCESS(rc))
		return rc;
	oid.seq = OBJCOUNT + count;					  // don't get fancy, just make sure the OID is unique
	rc = Idxs_new ( t, &oid, &iobj);
	if (!SUCCESS(rc)) goto end;

	Idxs_u2_put( &iobj, (uint2)(count));

	rc = Idxs_items_alloc( &iobj, vsize);
	if (!SUCCESS(rc)) goto end;

	for (i = 0; i < vsize; i++) {

		rc = Idxs_items_put(&iobj, i, &item);
		if (!SUCCESS(rc)) goto end;

		sprintf( itemname, "item_%d",  next_item_id);
		Item_id_put( &item, next_item_id++);
		rc = Item_name_put( & item, itemname, (uint2)strlen(itemname) );
		if (!SUCCESS(rc)) goto end;
		ni++;
	}

	rc = mco_trans_commit(t);
	return rc;

end:
	mco_trans_rollback(t);
	return rc;

}


int init_database(mco_db_h  db) {
	MCO_RET rc=0;
	int j;

	//printf("\nReading original OIDs from Fixed\n");
	for(j = 0; j < OBJCOUNT; j++) {

		if (MCO_S_OK != (rc = new_fixed(db, j)))
			break;
		if (MCO_S_OK != (rc = new_dynamic(db, j)))
			break;
		if (MCO_S_OK != (rc = new_blobs(db, j)))
			break;
		if (MCO_S_OK != (rc = new_idx(db, j)))
			break;

	}
	return rc;

}