Difference between revisions of "Library dblsamp"
From Recital Documentation Wiki
Yvonnemilne (Talk | contribs) |
Yvonnemilne (Talk | contribs) |
||
| (3 intermediate revisions by one user not shown) | |||
| Line 2: | Line 2: | ||
<code lang="c"> | <code lang="c"> | ||
| − | /*#================================================== | + | /*#============================================================================ |
*# Copyright (C) 1988-2009 Recital Corporation Inc. | *# Copyright (C) 1988-2009 Recital Corporation Inc. | ||
| − | *# As an unpublished | + | *# As an unpublished licenced proprietary work. |
*# All rights reserved worldwide. | *# All rights reserved worldwide. | ||
*# | *# | ||
| Line 11: | Line 11: | ||
*# copyright notice is included. | *# copyright notice is included. | ||
*# | *# | ||
| − | #=================================================== | + | *#============================================================================ |
* | * | ||
| − | *MODULE : dblsamp.c | + | * MODULE : dblsamp.c |
* | * | ||
| − | *PURPOSE : Recital | + | * PURPOSE : Recital DataBase Library sample program. |
* | * | ||
| − | *AUTHOR : RECITAL CORPORATION | + | * AUTHOR : RECITAL CORPORATION |
| − | * | + | * |
| − | *==================================================*/ | + | * DATE : 26 Jan 91 |
| + | * REVISION : 29 Oct 91 | ||
| + | * REVISION : 09 May 95 | ||
| + | * | ||
| + | *==========================================================================*/ | ||
#include <stdio.h> | #include <stdio.h> | ||
| Line 26: | Line 30: | ||
#include <sys/types.h> | #include <sys/types.h> | ||
#include <unistd.h> | #include <unistd.h> | ||
| − | #include "dbl.h" | + | #include "dbl.h" /* Recital/Library include file */ |
| − | #include "dblproto.h" | + | #include "dblproto.h" /* Recital/Library prototype file */ |
| − | |||
| − | /* | + | extern int g_disable_iostats; |
| + | |||
| + | /*----------------------------------------------*/ | ||
/* Table structure for db to be constructed. */ | /* Table structure for db to be constructed. */ | ||
| − | /* Structure dBFIELD defined in dbl.h */ | + | /* Structure dBFIELD defined in dbl.h. */ |
| − | /* | + | /*----------------------------------------------*/ |
| − | static dBFIELD fields[7] = { | + | 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 | #define DB_RECORD_SIZE 100 | ||
| − | /*-----------------------------------------------------------------------------------------*/ | + | /*----------------------------------------------*/ |
| − | + | /* Static Error Handling procedure. */ | |
| − | /*-----------------------------------------------------------------------------------------*/ | + | /*----------------------------------------------*/ |
| − | static | + | 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 program entry point. */ | ||
| − | /* | + | /*---------------------------*/ |
| − | main() | + | 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 | + | int keyunique; /* Boolean for unqiue tag key */ |
| − | int | + | int keydescend; /* Boolean for descending tag key */ |
| − | int | + | 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); | rc = dbclose(dbf); | ||
| − | + | errorproc("dbclose()", "table closed.", rc); | |
| − | /* | + | /*----------------------------------------------*/ |
| − | + | /* Exclusive, read write access of the table is */ | |
| − | /* tags. */ | + | /* 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++) { | 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 */ | /* Lock data file */ | ||
| − | /* | + | /*----------------*/ |
rc = dblockf(dbf); | 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 */ | |
| − | /* | + | /*-------------------------------------------------*/ |
| − | rc = | + | 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 */ | |
| − | + | /*-----------------------------------------------*/ | |
| − | + | ||
| − | + | ||
| − | + | ||
| − | + | ||
| − | + | ||
| − | + | ||
| − | + | ||
| − | + | ||
| − | + | ||
| − | + | ||
| − | + | /*-------------------------------------------*/ | |
| − | dbiflsh(ndx); | + | /* 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); | 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. */ | + | /* 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. */ | + | /* 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; | ||
| + | } | ||
| + | </code> | ||
[[Category:Documentation]] | [[Category:Documentation]] | ||
[[Category:Library]] | [[Category:Library]] | ||
[[Category:Reference]] | [[Category:Reference]] | ||
Latest revision as of 13:54, 6 May 2009
The following program is written in 'C' as an example program using the RECITAL/Library functions. This file is stored in the SDK dbl sub-directory and is called "dblsamp.c".
/*#============================================================================ *# Copyright (C) 1988-2009 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; }
