Difference between revisions of "Library dblsamp"

/*#=============================================================
 *# Copyright (C) 1988-2009 Recital Corporation Inc.
 *# As an unpublished licensed proprietary work.
 *# All rights reserved worldwide.
 *#
 *# This program may be freely copied and used as a template for user
 *# programs which make use of the Recital/Library in so long as the above
 *# copyright notice is included.
 *#
 #==============================================================
 *
 *MODULE		: dblsamp.c
 *
 *PURPOSE		: Recital Database Library sample program.
 *
 *AUTHOR		: RECITAL CORPORATION
 * *=============================================================*/
 
#include <stdio.h>
#include "dbl.h"		/* Recital/Library include file		*/
#include "dblproto.h" 		/* Recital/Library prototype file	*/
 
extern		int	g_disable_txcount;
 
/*-------------------------------------------------------------------------------------------------*/
/* Table structure for db to be constructed.						*/
/* Structure dBFIELD defined in dbl.h						*/
/*-------------------------------------------------------------------------------------------------*/
static  dBFIELD fields[7] = {
	"VESSEL",	'C',	18,	0,	0,
	"LAT",	'N',	4	1,	0,
	"LONG",	'N',	4,	1,	0,
	"AMOUNT",	'N',	10,	0,	0,
	"DATE",	'D',	8,	0,	0,
	"FLAG",	'C',	9,	0,	0,
	"MEMO",	'M',	4,	0,	0 
};
 
/*-------------------------------------------------------------------------------------------------*/
/* Static Error Handling procedure.							*/
/*-------------------------------------------------------------------------------------------------*/
static	int	errorproc();
 
/*-------------------------------------------------------------------------------------------------*/
/* Table records to add.								*/
/*-------------------------------------------------------------------------------------------------*/
static char *text_table[] =  {
	"Santa Margarita	80.027.5	7000000	95/01/01	Spanish  ",
	"Santa Rosa		81.824.8	30000000	32/01/01	Spanish  ",
	"Unknown galleon	83.123.0	0		15/01/01	Spanish",
	"Jessie			97.127.4	100000	75/01/01	U.S.     ",
	"Lea			96.227.8	1000000	80/01/01	U.S.     ",
	"S.J. Lee		96.926.9	200000	75/01/01	U.S.     ",
	"Genovase		78.418.4	1850000	30/01/01	Spanish  ",
	"Unknown Vessel	77.517.9 	0		75/01/01	U.S.     "
};
 
/*-------------------------------------------------------------------------------------------------*/
/* Main program entry point.								*/
/*-------------------------------------------------------------------------------------------------*/
main()
{
	int		rc;			/* Return Code for error handling	*/
	char		*dbf;			/* File descriptor for table		*/
	char		*dbx;			/* File descriptor for tagged index	*/
	char		*ndx;			/* File descriptor for index		*/
	char		*dbt;			/* File descriptor for memo file	*/
	char		record[58];		/* Array of char for records		*/
	char		keytype;		/* Variable for varying keytype	*/
	char		key[21];		/* Storage location for keys		*/
	char		tagname[21];		/* Storage location for tag name	*/
	char		keyexpr[512];		/* Storage location for key expr	*/
	char		forexpr[512];		/* Storage location for for expr	*/
	int		kexprlen;		/* The key expression length		*/
	int		keylen;			/* The key length			*/
	dBFIELD	dbfields[128];		/* Storage location for field names	*/
	FLDNUM	fieldcount;		/* Number of fields to create		*/
	int		fldpos[128];		/* Fields position buffer		*/
	char		flddes[128][26];	/* Fields description buffer		*/
	char		tmpbuf[81];		/* Temporary storage buffer		*/
	char		fldbuf[128][256];	/* Field buffer (recin()/out())		*/
	char		nextkey[10][20];	/* Key buffers (dbnkey())		*/
	char		status;			/* Deleted record flag			*/
	long		recno;			/* Table record variable		*/
	long		rec_no[10];		/* Record number array (dbnkey())	*/
	long		db_size;		/* Size of table variable		*/
	int		reclen;			/* Table record length variable	*/
	char		month;			/* Month variable			*/
	char		day;			/* Day variable			*/
	char		year;			/* Year variable			*/
	FLDNUM	nofields;		/* Number of table fields variable	*/
	int		i;			/* Loop control variable		*/
	double		n;			/* Double numeric variable		*/
	int		keyunique;		/* Boolean for unique tag key		*/
	int		keydescend;		/* Boolean for descending tag key	*/
	int		notags;			/* number of tags in a dbx file	*/
 
 
	/*----------------------------------------------------------------------------------------*/
	/* Perform operational Library environment functions.			*/
	/*----------------------------------------------------------------------------------------*/
 
	/*----------------------------------------------------------------------------------------*/
	/* DBDCACHE() - this example allocates a 100 record caching area	*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbdcache(100);
	errorproc("dbdcache()","table cache specified.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBICACHE() - this example allocates 51200 bytes for index caching	*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbicache(100);
	errorproc("dbicache()", "index cache specified.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBFILEMODE() - shared, read write access				*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbfilemode(1,0);
	errorproc("dbfilemode()", "file mode specified.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBSET() - Set exact index match to true					*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbset("EXACT", 1);
	errorproc("dbset()", "filemode specified.", rc);
 
 
/*----------------------------------------------------------------------------------------*/
	/* Perform basic table functions.						*/
	/*----------------------------------------------------------------------------------------*/
	fieldcount = 7;		/* Number of Fields	*/
 
	/*----------------------------------------------------------------------------------------*/
	/* DBCREAT() - this example creates a table according to the 'dBFIELD'	*/
	/* array fields.									*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbcreat("shipwreck.dbf", fieldcount, fields);
	errorproc("dbcreat()","database created.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBCREATX() - Enables the addition of table field descriptions.		*/
	/*----------------------------------------------------------------------------------------*/
	strcpy(flddes[0], "The vessel's name.");
	strcpy(flddes[1], "The latitude.");
	strcpy(flddes[2], "The longitude.");
	strcpy(flddes[3], "The value.");
	strcpy(flddes[4], "The date.");
	strcpy(flddes[5], "The vessel's flag.");
	strcpy(flddes[6], "Notes.");
 
	rc = dbcreatx("shipwreck.dbf", fieldcount, fields, flddes);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBOPEN() - example opens table 'shipwreck.dbf' returning the table	*/
	/* file descriptor (dbf) used in upcoming functions				*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbopen("shipwreck.dbf", &dbf);
	errorproc("dbopen()","table opened.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBGETF() - obtain table information on the table referenced by the	*/
	/* 'dbf' file descriptor.								*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbgetf(dbf, &reclen, &month, &day,
	&year, &nofields, dbfields);
	errorproc("dbgetf()","information retrieved.", rc);
	printf("ttRecord length in bytes: %dn", reclen);
	printf("ttCreation date: tt%d/%d/%dn", month, day, year);
	printf("ttNumber of fields: t%dn", nofields);
 
 
/*----------------------------------------------------------------------------------------*/
	/* DBGETFX() - obtain extended table information including the numeric	*/
	/* field location array (fldpos) and the field descriptions (flddes).		*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbgetfx(dbf, &reclen, &month, &day, &year,
	&nofields, dbfields, fldpos, flddes);
	errorproc("dbgetfx()", "extra information retrieved.", rc);
	printf("ttLocation of fields in buffer: t%d,%d,%d,%d,%d,%dn",
	fldpos[1],fldpos[2],fldpos[3],fldpos[4],fldpos[5],fldpos[6]);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBLOCKF() - locks the table for the additions that follow.		*/
	/* Synonymous with DBTLOCKF(), which tests the lock			*/
	/*----------------------------------------------------------------------------------------*/
	rc = dblockf(dbf);
	if ( rc == SUCCESS ) {
	printf("Function: tdblockf() tfile locked successfully.n");
	} else {
	printf("Lock Failed. tError: %dn", rc);
	}
 
	/*----------------------------------------------------------------------------------------*/
	/* DBCLOSE() - close the active table					*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbclose(dbf);
	errorproc("dbclose()", "table closed.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* Exclusive read write access of the table is required to create or delete	*/
	/* tags.										*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbfilemode(0,0);
	rc = dbopen("shipwreck.dbf", &dbf);
	errorproc("dbopen()","table opened in exclusive mode.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* Perform basic tagged index functions.					*/
	/*----------------------------------------------------------------------------------------*/
 
 
/*----------------------------------------------------------------------------------------*/
	/* DBXCREATE() - in this example creates an tag on field VESSEL	*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbxcreate( dbf,
	fields[0].fieldnm,	/* "VESSEL",	*/
	&dbx,
	fields[0].fieldnm,	/* "VESSEL",	*/
	NULL,
	0,
	0);
	errorproc("dbxcreate()","tag created", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBXCREATE() - in this example creates an tag on field FLAG		*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbxcreate( dbf,
	fields[5].fieldnm,	/* "FLAG",	*/
	&dbx,
	fields[5].fieldnm,	/* "FLAG",	*/
	NULL,
	0,
	0);
	errorproc("dbxcreate()","tag created", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBXNOTAGS() - obtains the number of tagged indexes			*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbxnotags(dbx, &notags);
	errorproc("dbxnotags()","tagged index count obtained.", rc);
	printf("t	  Key count: t%dn", notags );
 
	/*----------------------------------------------------------------------------------------*/
	/* DBXKEXPR() - obtains tagged index information			*/
	/*----------------------------------------------------------------------------------------*/
	for (i = 1; i <= notags; i++) {
	rc = dbxkexpr(dbx, 
	&i,
	tagname,
	&keytype, 
	keyexpr, 
	forexpr,
	&kexprlen, 
	&keylen,
	&keyunique,
	&keydescend);
	errorproc("dbxkexpr()", "key information retrieved.", rc);
	printf("t	  Key number: t%dn", i );
	printf("t	  Key name: t%sn", tagname );
	printf("t	  Key type: t%cn", keytype );
	printf("t	  Key expression: %sn", keyexpr);
	printf("t	  Key length: %d   Expression length: %dn",
	kexprlen, keylen);
	printf("t	  For expression: %sn", forexpr);
	printf("t	  Key unique: t%sn", keyunique ? "Yes" : "No" );
	printf("t	  Key descending: t%sn", keydescend?"Yes":"No" );
	}
 
	/*----------------------------------------------------------------------------------------*/
	/* DBXDROPTAGS() - Drop the specified tag				*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbxdroptag(dbx, fields[5].fieldnm);
	errorproc("dbxdroptag()","tagged index 'FLAG' dropped.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBXCLOSE() - close the active tagged index				*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbxclose(dbx);
	errorproc("dbxclose()", "tagged index closed.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBCLOSE() - close the active table					*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbclose(dbf);
	errorproc("dbclose()", "table closed.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* Reopen the table in shared, read-write access mode			*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbfilemode(1,0);
	rc = dbopen("shipwreck.dbf", &dbf);
	errorproc("dbopen()","table opened in shared mode.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBXOPEN() - example opens index file 'shipwreck.dbx' returning the	*/
	/* tagged index file descriptor (dbx) used in upcoming functions		*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbxopen(dbf, "shipwreck.dbx", &dbx);
	errorproc("dbxopen()","tagged index opened.", rc);
 
 
/*----------------------------------------------------------------------------------------*/
	/* Perform basic index functions.						*/
	/*----------------------------------------------------------------------------------------*/
 
	/*----------------------------------------------------------------------------------------*/
	/* DBICREAT() - in this example creates an index on field VESSEL	*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbicreat( "shipwreck.ndx", fields[0].fieldnm, 18, 'C');
	errorproc("dbicreat()","index created", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBIOPEN() - opens index to active status					*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbiopen( "shipwreck.ndx", &ndx);
	errorproc("dbiopen()", "index opened.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBKEXPR() - obtains index information					*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbkexpr(ndx, &keytype, keyexpr, &kexprlen, &keylen);
	errorproc("dbkexpr()", "key information retrieved.", rc);
	printf("t	  Key type: t%cn", keytype );
	printf("t	  Key expression: %sn", keyexpr);
	printf("t	  Key length: %d   Expression length: %dn",
	kexprlen, keylen);
 
	/*----------------------------------------------------------------------------------------*/
	/* Lock data file								*/
	/*----------------------------------------------------------------------------------------*/
	rc = dblockf(dbf);
	if ( rc == SUCCESS ) {
	printf("Function: tdblockf() tfile locked successfully.n");
	} else {
	printf("Lock Failed. tError: %dn", rc);
	}
 
	/*----------------------------------------------------------------------------------------*/
/* DBLOCKI() - locks the index for following additions			*/
	/* Synonymous with DBTLOCKI() which tests the lock			*/
	/*----------------------------------------------------------------------------------------*/
	rc = dblocki(ndx);
	if ( rc == SUCCESS ) {
	printf("Function: tdblocki() tindex locked successfully.n");
	} else {
	printf("Lock Failed. tError: %dn", rc);
	}
 
	/*----------------------------------------------------------------------------------------*/
	/* Perform basic memo file functions.					*/
	/*----------------------------------------------------------------------------------------*/
 
	/*----------------------------------------------------------------------------------------*/
	/* DBMCREAT() - creates a table memo file (if one needs creating)	*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbmcreat("shipwreck.dbt");
	errorproc("dbmcreat()", "memo file create", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBMOPEN() - opens an associated memo file				*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbmopen("shipwreck.dbt", &dbt);
	errorproc("dbmopen()", "memo file open.", rc);
 
 
	/*----------------------------------------------------------------------------------------*/
	/* Perform table input functions.						*/
	/*----------------------------------------------------------------------------------------*/
 
	/*----------------------------------------------------------------------------------------*/
	/* DBAPPEND() - appends a record to the end of the active table		*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbappend(dbf, text_table[0], &recno);
	errorproc("dbappend()", "record appended.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBAKEY() - adds a key to the active index after dbappend()		*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbakey(ndx, "Santa Margarita   " , recno);
	errorproc("dbakey()",  "key added.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBXAKEY() - adds a key to the tagged index after dbappend()		*/
/* The tagged index file must be lock first					*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbxlocki(dbx);
	errorproc("dbxlocki()",  "tagged index file locked.", rc);
	rc = dbxakey(dbx, recno);
	errorproc("dbxakey()",  "key added.", rc);
	rc = dbxunlocki(dbx);
	errorproc("dbxunlocki()",  "tagged index file unlocked.", rc);
 
 
/*----------------------------------------------------------------------------------------*/
	/* DBFLUSH() - flushes the record cache to disk				*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbflush(dbf);
	errorproc("dbflush()", "table cache flushed.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBIFLSH() - flushes the index cache to disk				*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbiflsh(ndx);
	errorproc("dbiflsh()", "index cache flushed.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBXFLSH() - flushes the tagged index cache to disk			*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbxflsh(dbx);
	errorproc("dbxflsh()", "Tagged index cache flushed.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBGETR() - retrieves a record						*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbgetr(dbf, (long)1, record, &status);
	errorproc("dbgetr()", "record retrieved.", rc);
	printf("tt%sn", record);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBPUTM() - put the memo information					*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbputm(dbt, "128' 30% coral cover.", &record[53]);
	errorproc("dbputm", "memo placed in buffer", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBUPDR() - updates the record in buffer 'record'				*/
	/* As of v8.0 this function automatically updates any attached indexes.	*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbupdr(dbf, (long)1, record);
	errorproc("dbupdr()", "record updated.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBGETM() - this example extracts the memo from the record buffer	*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbgetm(dbt, &record[53], tmpbuf, 0);
	errorproc("dbgetm()", "retrieved memo.", rc);
 
 
/*----------------------------------------------------------------------------------------*/
	/* DBUPDM() - Updates the memo field for this record			*/
	/*----------------------------------------------------------------------------------------*/
	strcat(tmpbuf, " Appending this string to the end of memo...");
	rc = dbupdm(dbt, tmpbuf, &record[53], &record[53]);
	errorproc("dbupdm()", "updated memo.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBPUTRK() - the following example adds a record and index		*/
	/* to the respective files.							*/
	/* DBRECOUT() - scatter the record stored in buffer 'record' to a two	*/
	/* dimensional character array 'fldbuf'					*/
	/*----------------------------------------------------------------------------------------*/
 
	/*----------------------------------------------------------------------------------------*/
	/* Read in 6 more records							*/
	/*----------------------------------------------------------------------------------------*/
 
	for( i = 1; i <= 6; i++)  {
	dbrecout( dbf, dbfields, fldpos, text_table[i], fldbuf);
	rc = dbputrk(dbf, ndx, fldbuf[0], text_table[i]);
	errorproc("dbputrk()", "record placed by key.", rc);
	}
	errorproc("dbputrk()", "6 records placed by key.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBFLUSH() - flushes the record cache to disk				*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbflush(dbf);
	errorproc("dbflush()", "table cache flushed.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBIFLSH() - flushes the index cache to disk				*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbiflsh(ndx);
	errorproc("dbiflsh()", "index cache flushed.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBXFLSH() - flushes the tagged index cache to disk			*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbxflsh(dbx);
	errorproc("dbxflsh()", "Tagged index cache flushed.", rc);
 
 
/*----------------------------------------------------------------------------------------*/
	/* DBFIELD() - this example extracts the field 'VESSEL' from the		*/
	/* record (#5) stored in buffer 'record'					*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbgetr(dbf, (long)5, record, &status);
	/* rc = dbfield( dbf, record, "FLAG", tmpbuf); */
	rc = dbfield( dbf, record, fields[5].fieldnm, tmpbuf);
	errorproc("dbfield()", "field extracted.", rc);
	printf("ttFlag: t%sn", tmpbuf);
 
	/*----------------------------------------------------------------------------------------*/
	/* Modify a single field in record number 5					*/
	/*----------------------------------------------------------------------------------------*/
 
	/*----------------------------------------------------------------------------------------*/
	/* DBSCATTER() - scatter the record into specified field buffers		*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbscatter(dbf, record, fldbuf);
	errorproc("dbscatter()", "record scattered.", rc);
 
	for (i=0; i < nofields; i++) {
	fprintf(stdout, "ttfldbuf[%d]='%s'n", i, fldbuf[i]);
	}
	strcpy(fldbuf[5], "Spanish");		    /* Modify Field */
 
	/*----------------------------------------------------------------------------------------*/
	/* DBGATHER() - gather the field buffers and place the contents		*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbgather(dbf, record, fldbuf);
	errorproc("dbgather()", "record gathered.", rc);
	printf("tt%sn", record);
 
	rc = dbupdr(dbf, (long)5, record);		  /* Finish Example    */
	errorproc("dbupdr()", "record updated.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* Perform index / index conversion functions.				*/
	/*----------------------------------------------------------------------------------------*/
 
	/*----------------------------------------------------------------------------------------*/
	/* DBREWIND() - position the record pointer to the top of the index file	*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbrewind(ndx);
	errorproc("dbrewind()", "index rewound.", rc);
 
 
/*----------------------------------------------------------------------------------------*/
	/* DBGETNR() - after 'rewinding' to the top of the table, the first record	*/
	/* can be retrieved with dbgetnr() using the active key			*/
	/*----------------------------------------------------------------------------------------*/
	for( i = 1; i <= 6; i++)  {
	rc = dbgetnr(dbf, ndx, record, &status);
	printf("tt%d: %sn", i, record);
	}
	errorproc("dbgetnr()", "6 records retrieved by key.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBNKEY() - get next key							*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbnkey(ndx, nextkey[0], rec_no);
	errorproc("dbnkey()", "next key retrieved.", rc);
	printf("ttnext key: t%sn", nextkey[0]);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBFWD() - position the pointer to the end of the table			*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbfwd(ndx);
	errorproc("dbfwd()", "index pointer placed at bottom.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBPKEY() - get previous key						*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbpkey(ndx, nextkey[0], rec_no);
	errorproc("dbpkey()", "previous key found.", rc);
	printf("ttprev key: t%sn", nextkey[0]);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBGETPR() - obtain the previous record by key				*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbgetpr(dbf, ndx, record, &status);
	errorproc("dbgetpr()", "previous record (by key) retrieved.", rc);
	printf("Previous: t%sn", record);
 
	/*----------------------------------------------------------------------------------------*/
	/* Rewind the index								*/
	/*----------------------------------------------------------------------------------------*/
	dbrewind(ndx);
 
 
/*----------------------------------------------------------------------------------------*/
	/* Perform table retrieval functions using indexes.				*/
	/*----------------------------------------------------------------------------------------*/
 
	/*----------------------------------------------------------------------------------------*/
	/* DBTKEY() - translates supplied key to record number			*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbtkey(ndx, "Santa Rosa	  ", &recno);
	errorproc("dbtkey()", "record number found by key.", rc);
	printf("ttrecord number: t%dn", recno);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBGETRK() - obtains the record from the specified key			*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbgetrk(dbf, ndx, "Santa Rosa	  ", record, &status);
	errorproc("dbgetrk()", "record retrieved by key.", rc);
	printf("tt%sn", record);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBCKEY() - read the current key						*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbckey(ndx, key, &recno);
	errorproc("dbckey()", "current key read.", rc);
	printf("ttcurrent key: t%sn", key);
 
	/*----------------------------------------------------------------------------------------*/
	/* Perform tagged index functions.						*/
	/*----------------------------------------------------------------------------------------*/
 
	/*----------------------------------------------------------------------------------------*/
	/* DBXREWIND() - position the pointer to the top of the index file	*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbxrewind(dbx);
	errorproc("dbxrewind()", "Tagged index rewound.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBXGETNR() - after 'rewinding' to the top of the table, the first record	*/
	/* can be retrieved with dbgetnr() using the active key			*/
	/*----------------------------------------------------------------------------------------*/
	for( i = 1; i <= 6; i++)  {
	rc = dbxgetnr(dbf, dbx, record, &status);
	printf("tt%d: %sn", i, record);
	}
	errorproc("dbxgetnr()", "6 records retrieved by tag key.", rc);
 
 
/*----------------------------------------------------------------------------------------*/
	/* DBXNKEY() - get next key						*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbxnkey(dbx, nextkey[0], rec_no);
	errorproc("dbxnkey()", "next key retrieved in tagged index.", rc);
	printf("ttnext key: t%sn", nextkey[0]);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBXFWD() - position the pointer to the end of the table			*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbxfwd(dbx);
	errorproc("dbxfwd()", "index pointer placed at bottom.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBXPKEY() - get previous key						*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbxpkey(dbx, nextkey[0], rec_no);
	errorproc("dbxpkey()", "previous key found in tagged index.", rc);
	printf("ttprev key: t%sn", nextkey[0]);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBXGETPR() - obtain the previous record by key			*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbxgetpr(dbf, dbx, record, &status);
	errorproc("dbxgetpr()", "previous record (by key) retrieved.", rc);
	printf("Previous: t%sn", record);
 
	/*----------------------------------------------------------------------------------------*/
	/* Rewind the index								*/
	/*----------------------------------------------------------------------------------------*/
	dbxrewind(dbx);
 
	/*----------------------------------------------------------------------------------------*/
	/* Perform table retrieval functions using tagged indexes.			*/
	/*----------------------------------------------------------------------------------------*/
 
	/*----------------------------------------------------------------------------------------*/
	/* DBTKEY() - translates supplied key to record number			*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbtkey(ndx, "Santa Rosa	  ", &recno);
	errorproc("dbtkey()", "record number found by key.", rc);
	printf("ttrecord number: t%dn", recno);
 
 
/*----------------------------------------------------------------------------------------*/
	/* DBXGETRK() - obtains the record from the specified key		*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbxgetrk(dbf, dbx, "Santa Rosa	  ", record, &status);
	errorproc("dbxgetrk()", "record retrieved by key.", rc);
	printf("tt%sn", record);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBXCKEY() - read the current key					*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbxckey(dbx, key, &recno);
	errorproc("dbxckey()", "current key read.", rc);
	printf("ttcurrent key: t%sn", key);
 
	/*----------------------------------------------------------------------------------------*/
	/* Perform field level functions including index/ASCII functions.		*/
	/*----------------------------------------------------------------------------------------*/
 
	/*----------------------------------------------------------------------------------------*/
	/* DBATOFLD() - converts ASCII string to Recital field			*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbatofld("23.3", 4, 1, tmpbuf);
	errorproc("dbatofld()", "string converted.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBATOKEY() - converts a ASCII string to Recital date key		*/
	/*----------------------------------------------------------------------------------------*/
	key[0] = 'D';
	rc = dbatokey("16430411", key);
	errorproc("dbatokey()", "string converted to key.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBFLDTOA() - converts extracted field to ASCII			*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbfldtoa(record + 18, 4, tmpbuf);
	errorproc("dbfldtoa()", "field converted.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBSTRCPY() - formats character strings to Recital types		*/
	/*----------------------------------------------------------------------------------------*/
	dbstrcpy(key, 'L', 10, "  320000");
	printf("Function: tdbstrcpy() toutput: %sn", key);
 
 
/*----------------------------------------------------------------------------------------*/
	/* DBSTRING() - formats non-'C' strings to C strings (null term)		*/
	/*----------------------------------------------------------------------------------------*/
	dbstring("Santa Pedro", 13, tmpbuf);
	printf("Function: tdbstring() toutput: %sn", tmpbuf);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBKEYTOA() - converts an extracted key to ASCII			*/
	/*----------------------------------------------------------------------------------------*/
	tmpbuf[0] = 0;		/* Number of decimal places		*/
	tmpbuf[1] = 'N';	/* Key Type				*/
	rc = dbkeytoa(key, tmpbuf);
	errorproc("dbkeytoa()", "key converted.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* Perform record/index deletion and file access				*/
	/*----------------------------------------------------------------------------------------*/
 
	/*----------------------------------------------------------------------------------------*/
	/* DBSIZE() - retrieve the size of the table					*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbsize(dbf, &db_size);
	errorproc("dbsize()", "size retrieved.", rc);
	printf("t	  No. of Records: t%dn", db_size);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBPUTR() - adds a record to the end of the table				*/
	/* You can also 'insert' a record using this function				*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbputr(dbf, db_size + 1L, text_table[7]);
	errorproc("dbputr()", "record placed.", rc);
	rc = dbakey(ndx, "Unknown Vessel    " , db_size + 1L);
	errorproc("dbakey()",  "key added.", rc);
	/*----------------------------------------------------------------------------------------*/
	/* Add record to the Production Index as well */
	/*----------------------------------------------------------------------------------------*/
	rc = dbxakey(dbx, db_size + 1L);
	errorproc("dbxakey()",  "key added.", rc);
 
	dbflush(dbf);
	dbiflsh(ndx);
	dbxflsh(dbx);
 
 
/*----------------------------------------------------------------------------------------*/
	/* DBDELETE() - mark a record (number 8) for deletion			*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbdelete(dbf, 8L);
	errorproc("dbdelete()", "record 8 marked for deletion.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBRECALL() - recall a record marked for deletion (number 8)		*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbrecall(dbf, 8L);
	errorproc("dbrecall()", "record 8 recalled.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBRMVKEY() - physically remove a key.  As of v8.0, this function	*/
	/* is not permitted on tables opened shareable.				*/
	/*----------------------------------------------------------------------------------------*/
	/* rc = dbrmvkey(ndx, "Unknown Vessel    ", db_size+1L);		*/
	/* errorproc("dbrmvkey()", "key physically removed.", rc);	    */
 
	/*----------------------------------------------------------------------------------------*/
	/* DBRMVR() - physically remove a data record. As of v8.0 this		*/
	/* function is not permitted on tables opened shareable.			*/
	/*----------------------------------------------------------------------------------------*/
	/* rc = dbrmvr(dbf, db_size+1L);						*/
	/* errorproc("dbrmvr()", "record 7 physically removed.", rc);		*/
 
	/*----------------------------------------------------------------------------------------*/
	/* DBUNLOCKF() - unlocks a table file					*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbunlockf(dbf);
	if ( rc == SUCCESS ) {
	printf("Function: tdbunlockf() tFile unlocked successfullyn");
	} else {
	printf("Unlock Failed. tError: %dn", rc);
	}
 
	/*----------------------------------------------------------------------------------------*/
	/* DBUNLOCKI() - unlocks an index file					*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbunlocki(ndx);
	if ( rc == SUCCESS ) {
	printf("Function: tdbunlocki() tFile unlocked successfullyn");
	} else {
	printf("Unlock Failed. tError: %dn", rc);
	}
 
	/*----------------------------------------------------------------------------------------*/
	/* DBLOCKR() - tests available record locking in a multi user		*/
	/* environment.  Same as DBTLOCKR() in multi access			*/
	/*----------------------------------------------------------------------------------------*/
	rc = dblockr(dbf, (long)7);
	if ( rc == SUCCESS ) {
	printf("Function: tdblockr() trecord locked successfully.n");
	} else {
	printf("Lock Failed. tError: %dn", rc);
	}
 
	/*----------------------------------------------------------------------------------------*/
	/* DBUNLOCKR() - unlocks a table Record					*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbunlockr(dbf, (long)7);
	if ( rc == SUCCESS ) {
	printf("Function tdbunlockr(): trecord unlocked successfullyn");
	} else {
	printf("Unlock Failed. tError: %dn", rc);
	}
 
	/*----------------------------------------------------------------------------------------*/
	/* Perform record/index close functions					*/
	/*----------------------------------------------------------------------------------------*/
 
	/*----------------------------------------------------------------------------------------*/
	/* DBICLOSE() - close the active index					*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbiclose(ndx);
	errorproc("dbiclose()", "index closed.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBXCLOSE() - close the active tagged index				*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbxclose(dbx);
	errorproc("dbxclose()", "tagged index closed.", rc);
 
	/*----------------------------------------------------------------------------------------*/
	/* DBCLOSE() - close the active table					*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbclose(dbf);
	errorproc("dbclose()", "table closed.", rc);
 
 
/*----------------------------------------------------------------------------------------*/
	/* DBMCLOSE() - close the active memo table				*/
	/*----------------------------------------------------------------------------------------*/
	rc = dbmclose(dbt);
	errorproc("dbmclose()", "memo table closed.", rc);
 
 
	/*----------------------------------------------------------------------------------------*/
	/* Perform miscellaneous Recital/Library functions				*/
	/*----------------------------------------------------------------------------------------*/
 
	/*----------------------------------------------------------------------------------------*/
	/* DBONERROR() - enables/disables (1/0) recovery from errors		*/
	/*----------------------------------------------------------------------------------------*/
	dbonerror(0); 		/* Recovery disabled */
	printf("Function: tdbonerror()  terror checking disabledn");
 
	printf("nEnd of Recital C Library test program....n");
 
	exit(0);
 
}
 
/*-------------------------------------------------------------------------------------------------*/
/* This procedure handles the return codes from called RECITAL/library 		*/
/* functions.  Intended to eliminate cryptic  'if...else...' statements			*/
/* following library calls.								*/
/*-------------------------------------------------------------------------------------------------*/
 
static	int errorproc(func, str, rc)
char	*func;
char	*str;
int	rc;
{
	if ( rc != SUCCESS ) {
	printf("n  Error performing function %s -> %dn", func, rc);
	exit(1);
	}
printf("Function: t%s, t%s - Okn", func, str);
	return;
}