Library dblsamp
/*#============================================================================
*# Copyright (C) 1988-1991 Recital Corporation Inc. *# As an unpublished licenced 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 * * DATE : 26 Jan 91 * REVISION : 29 Oct 91 * REVISION : 09 May 95 * *==========================================================================*/
- include <stdio.h>
- include <stdlib.h>
- include <string.h>
- include <sys/types.h>
- include <unistd.h>
- include "dbl.h" /* Recital/Library include file */
- include "dblproto.h" /* Recital/Library prototype file */
extern int g_disable_iostats;
/*----------------------------------------------*/ /* 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', sizeof(MEMO), 0, 0
};
- define DB_RECORD_SIZE 100
/*----------------------------------------------*/ /* Static Error Handling procedure. */ /*----------------------------------------------*/ static void errorproc( char *func, char *str, int rc);
/*----------------------------------------------*/ /* Table records to add. */ /*----------------------------------------------*/ static char *text_table[] = {
"Santa Margarita 80.027.5 700000095/01/01Spanish ", "Santa Rosa 81.824.8 3000000032/01/01Spanish ", "Unknown galleon 83.123.0 015/01/01Spanish ", "Jessie 97.127.4 10000075/01/01U.S. ", "Lea 96.227.8 100000080/01/01U.S. ", "S.J. Lee 96.926.9 20000075/01/01U.S. ", "Genovase 78.418.4 185000030/01/01Spanish ", "Unknown Vessel 77.517.9 075/01/01U.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[DB_RECORD_SIZE]; /* 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[MAX_RECORD_FIELDS]; /* Storage location for fld names */
FLDNUM fieldcount; /* Number of fields to create */
int fldpos[MAX_RECORD_FIELDS]; /* Fields position buffer */
char flddes[MAX_RECORD_FIELDS][26]; /* Fields description buffer */
char tmpbuf[81]; /* Temporary storage buffer */
char fldbuf[MAX_RECORD_FIELDS][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 var */
int i; /* Loop control variable */
double n; /* Double numeric variable */
int keyunique; /* Boolean for unqiue 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()", "filemode 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()","datebase 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 funcs */
/*----------------------------------------------------------------*/
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("\t\tRecord length in bytes: %d\n", reclen);
printf("\t\tCreation date: \t\t%d/%d/%d\n",month,day,year);
printf("\t\tNumber of fields: \t%d\n", 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("\t\tLocation of fields in buffer: \t%d,%d,%d,%d,%d,%d\n",
fldpos[1],fldpos[2],fldpos[3],fldpos[4],fldpos[5],fldpos[6]);
/*-------------------------------------------------------------*/
/* DBLOCKF() - locks the table for following additions. */
/* Synonomous with DBTLOCKF() which tests the lock */
/*-------------------------------------------------------------*/
rc = dblockf(dbf);
if ( rc == SUCCESS ) {
printf("Function: \tdblockf() \tfile locked successfully.\n");
} else {
printf("Lock Failed. \tError: %d\n",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, ¬ags);
errorproc("dbxnotags()","tagged index count obtained.", rc);
printf("\t Key count: \t%d\n", 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%d\n", i );
printf("\t Key name: \t%s\n", tagname );
printf("\t Key type: \t%c\n", keytype );
printf("\t Key expression: %s\n", keyexpr);
printf("\t Key length: %d Expression length: %d\n",
kexprlen, keylen);
printf("\t For expression: %s\n", forexpr);
printf("\t Key unique: \t%s\n", keyunique ? "Yes" : "No" );
printf("\t Key descending: \t%s\n", 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 tag index 'shipwreck.dbx' returning the */
/* taged index file descriptor (dbx) used in upcoming funcs */
/*--------------------------------------------------------------------*/
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%c\n", keytype );
printf("\t Key expression: %s\n", keyexpr);
printf("\t Key length: %d Expression length: %d\n",
kexprlen, keylen);
/*----------------*/ /* Lock data file */ /*----------------*/ rc = dblockf(dbf);
if ( rc == SUCCESS ) {
printf("Function: \tdblockf() \tfile locked successfully.\n");
} else {
printf("Lock Failed. \tError: %d\n",rc);
}
/*-------------------------------------------------------------*/
/* DBLOCKI() - locks the index for following additions */
/* Synonomous with DBTLOCKI() which tests the lock */
/*-------------------------------------------------------------*/
rc = dblocki(ndx);
if ( rc == SUCCESS ) {
printf("Function: \tdblocki() \tindex locked successfully.\n");
} else {
printf("Lock Failed. \tError: %d\n",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 retreived.", rc);
printf("\t\t%s\n", 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()", "retreived memo.", rc);
/*--------------------------------------------------*/
/* DBUPDM() - Updates the memofield 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 */
/* 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("\t\tFlag: \t%s\n", tmpbuf);
/*------------------------------------------*/
/* Modify a single field in record number 5 */
/*------------------------------------------*/
/*----------------------------------------------------------------*/
/* DBSCATTER() - scatters the record into specified field buffers.*/
/*----------------------------------------------------------------*/
rc = dbscatter(dbf, record, fldbuf);
errorproc("dbscatter()", "record scattered.", rc);
strcpy(fldbuf[6], "Spanish"); /* Modify Field */
/*----------------------------------------------------------------*/
/* DBGATHER() - Gathers the field buffers and places the contents */
/*----------------------------------------------------------------*/
rc = dbgather(dbf, record, fldbuf);
errorproc("dbgather()", "record gathered.", rc);
printf("\t\t%s\n", record);
rc = dbupdr(dbf, (long)5, record); /* Finish Example */
errorproc("dbupdr()", "record updated.", rc);
/*---------------------------------------------*/
/* Perform index / index conversion functions. */
/*---------------------------------------------*/
/*-------------------------------------------------------------*/
/* DBREWIND() - positions the record pointer to the top of the */
/* index file */
/*-------------------------------------------------------------*/
rc = dbrewind(ndx);
errorproc("dbrewind()", "index rewound.", rc);
/*----------------------------------------------------------*/
/* DBGETNR() - after 'rewind()ing' to the top of the table */
/* the first record using the active key can be */
/* retrieved with dbgetnr() */
/*----------------------------------------------------------*/
for( i = 1; i <= 6; i++) {
rc = dbgetnr(dbf, ndx, record, &status);
printf("\t\t%d: %s\n", 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("\t\tnext key: \t%s\n", 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("\t\tprev key: \t%s\n", 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%s\n", 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("\t\trecord number: \t%d\n", 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("\t\t%s\n", record);
/*---------------------------------*/
/* DBCKEY() - read the current key */
/*---------------------------------*/
rc = dbckey(ndx, key, &recno);
errorproc("dbckey()", "current key read.", rc);
printf("\t\tcurrent key: \t%s\n", key);
/*---------------------------------*/
/* Perform tagged index functions. */
/*---------------------------------*/
/*--------------------------------------------------------------*/
/* DBXREWIND() - positions the record pointer to the top of the */
/* index file */
/*--------------------------------------------------------------*/
rc = dbxrewind(dbx);
errorproc("dbxrewind()", "Tagged index rewound.", rc);
/*-----------------------------------------------------------*/
/* DBXGETNR() - after 'rewind()ing' to the top of the table */
/* the first record using the active key can be */
/* retrieved with dbgetnr() */
/*-----------------------------------------------------------*/
for( i = 1; i <= 6; i++) {
rc = dbxgetnr(dbf, dbx, record, &status);
printf("\t\t%d: %s\n", 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("\t\tnext key: \t%s\n", 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("\t\tprev key: \t%s\n", 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%s\n", 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("\t\trecord number: \t%d\n", 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("\t\t%s\n", record);
/*---------------------------------*/
/* DBXCKEY() - read the current key */
/*---------------------------------*/
rc = dbxckey(dbx, key, &recno);
errorproc("dbxckey()", "current key read.", rc);
printf("\t\tcurrent key: \t%s\n", key);
/*---------------------------------------------------------------*/
/* Perform field level functions including index/ASCII functions.*/
/*---------------------------------------------------------------*/
/*-------------------------------------------------------------*/
/* DBATOFLD() - converts ASCII string to Recital compat. 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 Rectial types */
/*---------------------------------------------------------*/
dbstrcpy(key, 'L', 10, " 320000");
printf("Function: \tdbstrcpy() \toutput: %s\n", key);
/*---------------------------------------------------------------*/
/* DBSTRING() - formats non-'C' strings to C strings (null term) */
/*---------------------------------------------------------------*/
dbstring("Santa Pedro", 13, tmpbuf);
printf("Function: \tdbstring() \toutput: %s\n", tmpbuf);
/*-------------------------------------------------*/
/* DBKEYTOA() - converts an extracted key to ASCII */
/*-------------------------------------------------*/
tmpbuf[0] = 0; /* Number of dec. 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%d\n", 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);
rc = dbxakey(dbx, db_size + 1L);
errorproc("dbxakey()", "key added.", rc);
dbflush(dbf); /* Good Habit on shared files */
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 successfully\n");
} else {
printf("Unlock Failed. \tError: %d\n", rc);
}
/*-------------------------------------*/
/* DBUNLOCKI() - unlocks an index file */
/*-------------------------------------*/
rc = dbunlocki(ndx);
if ( rc == SUCCESS ) {
printf("Function: \tdbunlocki() \tFile unlocked successfully\n");
} else {
printf("Unlock Failed. \tError: %d\n", rc);
}
/*---------------------------------------------------------------*/
/* DBLOCKR() - tests available record locking in a multiuser */
/* 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: %d\n", rc);
}
/*--------------------------------------*/
/* DBUNLOCKR() - unlocks a table Record */
/*--------------------------------------*/
rc = dbunlockr(dbf, (long)7);
if ( rc == SUCCESS ) {
printf("Function \tdbunlockr(): \trecord unlocked successfully\n");
} else {
printf("Unlock Failed. \tError: %d\n", 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 disabled\n");
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 void errorproc(func, str, rc) char *func; char *str; int rc; {
if ( rc != SUCCESS ) {
printf("\n Error performing function %s -> %d\n", func, rc);
exit(1);
}
printf("Function: \t%s, \t%s - Ok\n", func,str);
return;
}
