verify.c

extremeDB s sample code,useful for you

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

#include "load.h"

MCO_RET mov_cursor(mco_db_h db, mco_cursor_h c, const code) {
	mco_trans_h t;
	MCO_RET rc = 0;

	for(;;) {
		mco_trans_start(db, MCO_READ_ONLY, MCO_TRANS_FOREGROUND, &t);
		rc = mco_cursor_next(t, c);
		if (rc) {
			mco_trans_commit(t);
			break;
		}
		switch(code) {
			case Blobs_code:
				rc = read_blob(t, c);
				break;
			case Dynamic_code:
				rc = read_dynamic(t, c);
				break;
			case Fixed_code:
				read_fixed(t,c);
				break;
			case Idxs_code:
				rc = read_idxs(t, c);
				break;
			default:
				mco_trans_rollback(t);
				return -1;
		}
		mco_trans_commit(t);
		if (!SUCCESS(rc))
			return rc;
	}

	if (rc != MCO_S_CURSOR_END)
		return rc;
	else
		return 0;

}


MCO_RET set_cursor(mco_db_h db, mco_cursor_h c, const code) {
	mco_trans_h t;
	MCO_RET rc = 0;

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

	switch(code) {
		case Blobs_code:
#ifdef USE_LISTS
			rc = Blobs_list_cursor(t, c );
#else
			rc = Blobs_tU8_index_cursor( t, c );
#endif
			break;
		case Dynamic_code:
			rc = Dynamic_list_cursor( t, c );
			break;
		case Fixed_code:
#ifdef USE_LISTS
			rc = Fixed_list_cursor( t, c );
#else
			rc = Fixed_tU4_index_cursor(t,c);
#endif
			break;
		case Idxs_code:
#ifdef USE_LISTS
			rc = Idxs_list_cursor( t, c );
#else
			rc = Idxs_tIdx_index_cursor(t, c);
#endif
			break;
		default:
			mco_trans_rollback(t);
			return -1;

	}

	if (rc) {
		mco_trans_rollback(t);
		return rc;
	}
	rc = mco_cursor_first( t, c);
	if (rc) {
		// not found
		mco_trans_rollback(t);
		return rc;
	}
	switch(code) {
		case Blobs_code:
			rc = read_blob(t, c);
			break;
		case Dynamic_code:
			rc = read_dynamic(t, c);
			break;
		case Fixed_code:
			read_fixed(t,c);
			break;
		case Idxs_code:
			read_idxs(t, c);
			break;
		default:
			return -1;
	}
	mco_trans_commit(t);
	return rc;
}


MCO_RET read_idxs(mco_trans_h t, mco_cursor_h c) {
	MCO_RET rc;
	Idxs obj;
	uint2 val, vsz;

	rc = Idxs_from_cursor(t, c, &obj);
	if (SUCCESS(rc)) {
		int idx;
		Item item;
		char * str;
		uint4 idval;
		uint2 sz;
		dbtest_oid oid;

		rc = Idxs_oid_get (&obj, &oid );
		if (!SUCCESS(rc))
			return rc;
		Idxs_u2_get( &obj, &val );
		Idxs_items_size ( &obj, &vsz );

		for (idx = 0; idx < vsz; idx++) {
			rc = Idxs_items_at( &obj, (uint2)idx, &item);
			if (!SUCCESS(rc)) return rc;
			Item_id_get(&item, &idval);
			Item_name_size (&item, &sz);
			if (sz != 0) {
				if (NULL != (str = malloc(sz + 1))) {
					rc = Item_name_get( &item, str, sz, NULL);
					free(str);
					if (!SUCCESS(rc)) return rc;
				}
			}
		}
	}
	iv++;
	return rc;
}


MCO_RET read_blob(mco_trans_h t, mco_cursor_h c) {
	MCO_RET rc, rc1;
	Blobs blob, v_blob;
	uint2 val = 0;
	uint4 size = 0;
	char * buff= 0;

	rc = Blobs_from_cursor (t, c, &blob );
	if (SUCCESS(rc)) {
		Blobs_num_get(&blob, &val);
		Blobs_blo_size( &blob, &size);
		if (size) {
			buff = malloc(size);
			if (buff) {
				uint4 len = 0;
				rc = Blobs_blo_get(&blob, 0, buff, size, &len);
				if (SUCCESS(rc))
					bv++;
				free(buff);
			}
		}
	}

	/* verify history */
	if ( info.mco_versioning_supported ) {
		for(;;) {
			if (MCO_S_OK != (rc1 = Blobs_version_prev(&blob, &v_blob)))
				break;
			blob = v_blob;
			Blobs_blo_size(&blob, &size);
			if ((buff = malloc(size))==0)
				break;
			rc = Blobs_blo_get(&blob, 0, buff, size, NULL);
			free(buff);
			if (SUCCESS(rc))
				bh++;
			else
				break;
		};
	};

	return rc;
}


MCO_RET read_fixed(mco_trans_h t, mco_cursor_h c) {
	MCO_RET rc;
	Fixed fixed;
	char txt[5];
	uint4 u4;
	uint2 u2;
	float f;
	dbtest_oid oid;

	rc = Fixed_from_cursor (t, c, &fixed );
	if (SUCCESS(rc)) {

		Fixed_oid_get(&fixed, &oid );

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

		Fixed_c4_get( &fixed, txt, sizeof txt);

		Fixed_u4_get(&fixed, &u4 );

		Fixed_f_get (&fixed, &f) ;

		rc = Fixed_u2_get(&fixed, &u2 );
		if (!SUCCESS(rc))
			return rc;
		fv++;
	}
	return rc;
}


MCO_RET read_dynamic(mco_trans_h t, mco_cursor_h c) {
	MCO_RET rc;
	uint2   sz, idx;
	uint4   val;
	Dynamic dyn;
	Item    hItem;

	rc = Dynamic_from_cursor (t, c, &dyn );
	if (!SUCCESS(rc)) return rc;

	/* read string */
	Dynamic_str_size ( &dyn, &sz);
	if(sz) {
		uint2 len;
		char *str = malloc(sz+1);
		if (str) {
			rc = Dynamic_str_get(&dyn, str, (uint2)(sz+1), &len);
			free(str);

		}
	}
	if (!SUCCESS(rc))
		return rc;

	/* read vector */
	Dynamic_vu4_size( &dyn, &sz );				  // sz is vector size
	for (idx = 0; idx < sz; idx++) {
		if (MCO_S_OK != (rc = Dynamic_vu4_at( &dyn, idx, &val)))
			return rc;
	}

	/* optional structure */
	rc = Dynamic_item_read_handle( &dyn, &hItem );
	if (rc == MCO_S_OK) {						  // every other Item should be there...
		rc = Item_id_get( &hItem, & val );

		Item_name_size(&hItem, &sz);
		if (sz != 0) {
			uint2 len = 0;
			char *str = malloc(sz+1);
			if (str) {
				rc = Item_name_get( &hItem, str, (uint2)sz, &len);
				free(str);
			}
		}

	}
	else if (rc != MCO_E_EMPTYOPTIONAL) {
		printf ("\tfailed reading optional\n\n");
		return rc;
	}
	dv++;
	return MCO_S_OK;
}


/* 
 * We don't intend to verify the content of each object, but only
 * fields accessibility. This is to make sure that our pointer
 * conversions to file offsets and back are done correctly.
 */
int verify_db(mco_db_h  db) {

	MCO_RET rc = 0;
	mco_cursor_t c;

	//  printf("\nReading restored OIDs from Fixed\n");
	rc = set_cursor(db, &c, Fixed_code);
	if (!SUCCESS(rc))
		return rc;
	rc = mov_cursor(db, &c, Fixed_code);
	if (!SUCCESS(rc))
		return rc;

	rc = set_cursor(db, &c, Dynamic_code);
	if (!SUCCESS(rc))
		return rc;
	rc = mov_cursor(db, &c, Dynamic_code);
	if (!SUCCESS(rc))
		return rc;
	rc = set_cursor(db, &c, Blobs_code);
	if (!SUCCESS(rc))
		return rc;
	rc = mov_cursor(db, &c, Blobs_code);
	if (!SUCCESS(rc))
		return rc;

	rc = set_cursor(db,&c, Idxs_code);
	if (!SUCCESS(rc))
		return rc;
	rc = mov_cursor(db, &c, Idxs_code);

	return rc;
}