Difference between revisions of "Library dblsamp"
From Recital Documentation Wiki
Yvonnemilne (Talk | contribs) |
Yvonnemilne (Talk | contribs) |
||
Line 22: | Line 22: | ||
#include <stdio.h> | #include <stdio.h> | ||
− | #include "dbl.h" /* Recital Library include file */ | + | #include "dbl.h" /* Recital Library include file */ |
− | #include "dblproto.h" /* Recital Library prototype file | + | #include "dblproto.h" /* Recital Library prototype file */ |
extern int g_disable_txcount; | extern int g_disable_txcount; | ||
/*-----------------------------------------------------------------------------------------*/ | /*-----------------------------------------------------------------------------------------*/ | ||
− | /* 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] | ||
Line 44: | Line 44: | ||
/*-----------------------------------------------------------------------------------------*/ | /*-----------------------------------------------------------------------------------------*/ | ||
− | /* Static Error Handling procedure. | + | /* Static Error Handling procedure. */ |
/*-----------------------------------------------------------------------------------------*/ | /*-----------------------------------------------------------------------------------------*/ | ||
static int errorproc(); | static int errorproc(); | ||
/*-----------------------------------------------------------------------------------------*/ | /*-----------------------------------------------------------------------------------------*/ | ||
− | /* Table records to add. | + | /* Table records to add. */ |
/*-----------------------------------------------------------------------------------------*/ | /*-----------------------------------------------------------------------------------------*/ | ||
static char | static char | ||
*text_table[] = { | *text_table[] = { | ||
− | "Santa Margarita 80.027.5 | + | "Santa Margarita 80.027.5 700000095/01/01Spanish ", |
− | "Santa Rosa | + | "Santa Rosa 81.824.8 3000000032/01/01Spanish ", |
− | "Unknown galleon 83.123.0 | + | "Unknown galleon 83.123.0 015/01/01Spanish ", |
− | "Jessie | + | "Jessie 97.127.4 10000075/01/01U.S. ", |
− | "Lea | + | "Lea 96.227.8 100000080/01/01U.S. ", |
− | "S.J. Lee | + | "S.J. Lee 96.926.9 20000075/01/01U.S. ", |
− | "Genovase | + | "Genovase 78.418.4 185000030/01/01Spanish ", |
− | "Unknown Vessel 77.517.9 | + | "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 | + | int rc; /* Return Code for error handling */ |
− | char *dbx; /* File descriptor for tagged index */ | + | char *dbf; /* File descriptor for table */ |
− | char *ndx; /* File descriptor for index | + | char *dbx; /* File descriptor for tagged index */ |
− | char *dbt; /* File descriptor for memo file | + | char *ndx; /* File descriptor for index */ |
− | char record[58]; | + | char *dbt; /* File descriptor for memo file */ |
− | char keytype; /* Variable for varying keytype | + | char record[58]; /* Array of char for records */ |
− | char key[21]; /* Storage location for keys | + | char keytype; /* Variable for varying keytype */ |
− | char tagname[21]; /* Storage location for tag name | + | char key[21]; /* Storage location for keys */ |
− | char keyexpr[512]; /* Storage location for key expr | + | char tagname[21]; /* Storage location for tag name */ |
− | char forexpr[512]; /* Storage location for for expr | + | char keyexpr[512]; /* Storage location for key expr */ |
− | int kexprlen; /* The key expression length | + | char forexpr[512]; /* Storage location for for expr */ |
− | int keylen; /* The key length | + | int kexprlen; /* The key expression length */ |
− | dBFIELD dbfields[128]; /* Storage location for field names */ | + | int keylen; /* The key length */ |
− | FLDNUM fieldcount; /* Number of fields to create | + | dBFIELD dbfields[128]; /* Storage location for field names */ |
− | int fldpos[128]; /* Fields position buffer | + | FLDNUM fieldcount; /* Number of fields to create */ |
− | char flddes[128][26]; /* Fields description buffer | + | int fldpos[128]; /* Fields position buffer */ |
− | char tmpbuf[81]; /* Temporary storage buffer | + | char flddes[128][26]; /* Fields description buffer */ |
− | char fldbuf[128][256]; /* Field buffer (recin()/out()) | + | char tmpbuf[81]; /* Temporary storage buffer */ |
− | char nextkey[10][20]; /* Key buffers (dbnkey()) | + | char fldbuf[128][256]; /* Field buffer (recin()/out()) */ |
− | char status; /* Deleted record flag | + | char nextkey[10][20]; /* Key buffers (dbnkey()) */ |
− | long recno; /* Table record variable | + | char status; /* Deleted record flag */ |
− | long rec_no[10]; /* Record number array (dbnkey()) */ | + | long recno; /* Table record variable */ |
− | long db_size; /* Size of table variable | + | long rec_no[10]; /* Record number array (dbnkey()) */ |
− | int reclen; /* Table record length variable | + | long db_size; /* Size of table variable */ |
− | char month; /* Month variable | + | int reclen; /* Table record length variable */ |
− | char day; /* Day variable | + | char month; /* Month variable */ |
− | char year; /* Year variable | + | char day; /* Day variable */ |
− | FLDNUM nofields; /* Number of table fields variable */ | + | char year; /* Year variable */ |
− | int i; /* Loop control variable | + | FLDNUM nofields; /* Number of table fields variable */ |
− | double n; /* Double numeric variable | + | int i; /* Loop control variable */ |
− | int keyunique; | + | double n; /* Double numeric variable */ |
− | int keydescend; /* Boolean for descending tag key */ | + | int keyunique; /* Boolean for unique tag key */ |
− | int notags; /* number of tags in a dbx file | + | int keydescend; /* Boolean for descending tag key */ |
+ | int notags; /* number of tags in a dbx file */ | ||
/*---------------------------------------------------------------------------------------*/ | /*---------------------------------------------------------------------------------------*/ | ||
− | /* Perform operational Library environment functions. | + | /* Perform operational Library environment functions. */ |
/*---------------------------------------------------------------------------------------*/ | /*---------------------------------------------------------------------------------------*/ | ||
/*---------------------------------------------------------------------------------------*/ | /*---------------------------------------------------------------------------------------*/ | ||
− | /* DBDCACHE() - this example allocates a 100 record caching area | + | /* DBDCACHE() - this example allocates a 100 record caching area */ |
/*---------------------------------------------------------------------------------------*/ | /*---------------------------------------------------------------------------------------*/ | ||
rc = dbdcache(100); | rc = dbdcache(100); | ||
Line 112: | Line 114: | ||
/*---------------------------------------------------------------------------------------*/ | /*---------------------------------------------------------------------------------------*/ | ||
− | /* DBICACHE() - this example allocates 51200 bytes for index caching | + | /* DBICACHE() - this example allocates 51200 bytes for index caching */ |
/*---------------------------------------------------------------------------------------*/ | /*---------------------------------------------------------------------------------------*/ | ||
rc = dbicache(100); | rc = dbicache(100); | ||
Line 118: | Line 120: | ||
/*---------------------------------------------------------------------------------------*/ | /*---------------------------------------------------------------------------------------*/ | ||
− | /* DBFILEMODE() - shared, read write access | + | /* DBFILEMODE() - shared, read write access */ |
/*---------------------------------------------------------------------------------------*/ | /*---------------------------------------------------------------------------------------*/ | ||
rc = dbfilemode(1, 0); | rc = dbfilemode(1, 0); | ||
Line 124: | Line 126: | ||
/*---------------------------------------------------------------------------------------*/ | /*---------------------------------------------------------------------------------------*/ | ||
− | /* DBSET() - Set exact index match to true | + | /* DBSET() - Set exact index match to true */ |
/*---------------------------------------------------------------------------------------*/ | /*---------------------------------------------------------------------------------------*/ | ||
rc = dbset("EXACT", 1); | rc = dbset("EXACT", 1); | ||
Line 130: | Line 132: | ||
/*---------------------------------------------------------------------------------------*/ | /*---------------------------------------------------------------------------------------*/ | ||
− | /* Perform basic table functions. | + | /* Perform basic table functions. */ |
/*---------------------------------------------------------------------------------------*/ | /*---------------------------------------------------------------------------------------*/ | ||
fieldcount = 7; /* Number of Fields */ | fieldcount = 7; /* Number of Fields */ | ||
/*---------------------------------------------------------------------------------------*/ | /*---------------------------------------------------------------------------------------*/ | ||
− | /* DBCREAT() - this example creates a table according to the 'dBFIELD' | + | /* DBCREAT() - this example creates a table according to the 'dBFIELD' */ |
− | /* array fields. | + | /* array fields. */ |
/*---------------------------------------------------------------------------------------*/ | /*---------------------------------------------------------------------------------------*/ | ||
rc = dbcreat("shipwreck.dbf", fieldcount, fields); | rc = dbcreat("shipwreck.dbf", fieldcount, fields); |
Revision as of 10:56, 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 licensed proprietary work. *# All rights reserved worldwide. *# *# This program may be freely copied and used as a template for user *# programs which make use of the Recital/Library in so long as the above *# copyright notice is included. *# #=================================================== * *MODULE : dblsamp.c * *PURPOSE : Recital Database Library sample program. * *AUTHOR : RECITAL CORPORATION * *==================================================*/ #include <stdio.h> #include "dbl.h" /* Recital Library include file */ #include "dblproto.h" /* Recital Library prototype file */ extern int g_disable_txcount; /*-----------------------------------------------------------------------------------------*/ /* Table structure for db to be constructed. */ /* Structure dBFIELD defined in dbl.h */ /*-----------------------------------------------------------------------------------------*/ static dBFIELD fields[7] = { "VESSEL", 'C', 18, 0, 0, "LAT", 'N', 4, 1, 0, "LONG", 'N', 4, 1, 0, "AMOUNT", 'N', 10, 0, 0, "DATE", 'D', 8, 0, 0, "FLAG", 'C', 9, 0, 0, "MEMO", 'M', 4, 0, 0 }; /*-----------------------------------------------------------------------------------------*/ /* Static Error Handling procedure. */ /*-----------------------------------------------------------------------------------------*/ static int errorproc(); /*-----------------------------------------------------------------------------------------*/ /* Table records to add. */ /*-----------------------------------------------------------------------------------------*/ static char *text_table[] = { "Santa Margarita 80.027.5 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[58]; /* Array of char for records */ char keytype; /* Variable for varying keytype */ char key[21]; /* Storage location for keys */ char tagname[21]; /* Storage location for tag name */ char keyexpr[512]; /* Storage location for key expr */ char forexpr[512]; /* Storage location for for expr */ int kexprlen; /* The key expression length */ int keylen; /* The key length */ dBFIELD dbfields[128]; /* Storage location for field names */ FLDNUM fieldcount; /* Number of fields to create */ int fldpos[128]; /* Fields position buffer */ char flddes[128][26]; /* Fields description buffer */ char tmpbuf[81]; /* Temporary storage buffer */ char fldbuf[128][256]; /* Field buffer (recin()/out()) */ char nextkey[10][20]; /* Key buffers (dbnkey()) */ char status; /* Deleted record flag */ long recno; /* Table record variable */ long rec_no[10]; /* Record number array (dbnkey()) */ long db_size; /* Size of table variable */ int reclen; /* Table record length variable */ char month; /* Month variable */ char day; /* Day variable */ char year; /* Year variable */ FLDNUM nofields; /* Number of table fields variable */ int i; /* Loop control variable */ double n; /* Double numeric variable */ int keyunique; /* Boolean for unique tag key */ int keydescend; /* Boolean for descending tag key */ int notags; /* number of tags in a dbx file */ /*---------------------------------------------------------------------------------------*/ /* Perform operational Library environment functions. */ /*---------------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------------*/ /* DBDCACHE() - this example allocates a 100 record caching area */ /*---------------------------------------------------------------------------------------*/ rc = dbdcache(100); errorproc("dbdcache()", "table cache specified.", rc); /*---------------------------------------------------------------------------------------*/ /* DBICACHE() - this example allocates 51200 bytes for index caching */ /*---------------------------------------------------------------------------------------*/ rc = dbicache(100); errorproc("dbicache()", "index cache specified.", rc); /*---------------------------------------------------------------------------------------*/ /* DBFILEMODE() - shared, read write access */ /*---------------------------------------------------------------------------------------*/ rc = dbfilemode(1, 0); errorproc("dbfilemode()", "file mode specified.", rc); /*---------------------------------------------------------------------------------------*/ /* DBSET() - Set exact index match to true */ /*---------------------------------------------------------------------------------------*/ rc = dbset("EXACT", 1); errorproc("dbset()", "filemode specified.", rc); /*---------------------------------------------------------------------------------------*/ /* Perform basic table functions. */ /*---------------------------------------------------------------------------------------*/ fieldcount = 7; /* Number of Fields */ /*---------------------------------------------------------------------------------------*/ /* DBCREAT() - this example creates a table according to the 'dBFIELD' */ /* array fields. */ /*---------------------------------------------------------------------------------------*/ rc = dbcreat("shipwreck.dbf", fieldcount, fields); errorproc("dbcreat()", "database created.", rc); /*---------------------------------------------------------------------------------------*/ /* DBCREATX() - Enables the addition of table field descriptions. */ /*---------------------------------------------------------------------------------------*/ strcpy(flddes[0], "The vessel's name."); strcpy(flddes[1], "The latitude."); strcpy(flddes[2], "The longitude."); strcpy(flddes[3], "The value."); strcpy(flddes[4], "The date."); strcpy(flddes[5], "The vessel's flag."); strcpy(flddes[6], "Notes."); rc = dbcreatx("shipwreck.dbf", fieldcount, fields, flddes); /*---------------------------------------------------------------------------------------*/ /* DBOPEN() - example opens table 'shipwreck.dbf' returning the table */ /* file descriptor (dbf) used in upcoming functions */ /*---------------------------------------------------------------------------------------*/ rc = dbopen("shipwreck.dbf", &dbf); errorproc("dbopen()", "table opened.", rc); /*---------------------------------------------------------------------------------------*/ /* DBGETF() - obtain table information on the table referenced by the */ /* 'dbf' file descriptor. */ /*---------------------------------------------------------------------------------------*/ rc = dbgetf(dbf, &reclen, &month, &day, &year, &nofields, dbfields); errorproc("dbgetf()", "information retrieved.", rc); printf("\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 the additions that follow. */ /* Synonymous with DBTLOCKF(), which tests the lock */ /*---------------------------------------------------------------------------------------*/ rc = dblockf(dbf); if (rc == SUCCESS) { printf("Function: \tdblockf() \tfile locked successfully.\n"); } else { printf("Lock Failed. tError: %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 a 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 a 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 index file 'shipwreck.dbx' returning the */ /* tagged index file descriptor (dbx) used in upcoming functions */ /*---------------------------------------------------------------------------------------*/ rc = dbxopen(dbf, "shipwreck.dbx", &dbx); errorproc("dbxopen()", "tagged index opened.", rc); /*---------------------------------------------------------------------------------------*/ /* Perform basic index functions. */ /*---------------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------------*/ /* DBICREAT() - in this example creates an index on field VESSEL */ /*---------------------------------------------------------------------------------------*/ rc = dbicreat("shipwreck.ndx", fields[0].fieldnm, 18, 'C'); errorproc("dbicreat()", "index created", rc); /*---------------------------------------------------------------------------------------*/ /* DBIOPEN() - opens index to active status */ /*---------------------------------------------------------------------------------------*/ rc = dbiopen("shipwreck.ndx", &ndx); errorproc("dbiopen()", "index opened.", rc); /*---------------------------------------------------------------------------------------*/ /* DBKEXPR() - obtains index information */ /*---------------------------------------------------------------------------------------*/ rc = dbkexpr(ndx, &keytype, keyexpr, &kexprlen, &keylen); errorproc("dbkexpr()", "key information retrieved.", rc); printf("\t Key type: \t%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 */ /* Synonymous with DBTLOCKI() which tests the lock */ /*---------------------------------------------------------------------------------------*/ rc = dblocki(ndx); if (rc == SUCCESS) { printf("Function: \tdblocki() \tindex locked successfully.\n"); } else { printf("Lock Failed. tError: %dn", rc); } /*---------------------------------------------------------------------------------------*/ /* Perform basic memo file functions. */ /*---------------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------------*/ /* DBMCREAT() - creates a table memo file (if one needs creating) */ /*---------------------------------------------------------------------------------------*/ rc = dbmcreat("shipwreck.dbt"); errorproc("dbmcreat()", "memo file create", rc); /*---------------------------------------------------------------------------------------*/ /* DBMOPEN() - opens an associated memo file */ /*---------------------------------------------------------------------------------------*/ rc = dbmopen("shipwreck.dbt", &dbt); errorproc("dbmopen()", "memo file open.", rc); /*---------------------------------------------------------------------------------------*/ /* Perform table input functions. */ /*---------------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------------*/ /* DBAPPEND() - appends a record to the end of the active table */ /*---------------------------------------------------------------------------------------*/ rc = dbappend(dbf, text_table[0], &recno); errorproc("dbappend()", "record appended.", rc); /*---------------------------------------------------------------------------------------*/ /* DBAKEY() - adds a key to the active index after dbappend() */ /*---------------------------------------------------------------------------------------*/ rc = dbakey(ndx, "Santa Margarita ", recno); errorproc("dbakey()", "key added.", rc); /*---------------------------------------------------------------------------------------*/ /* DBXAKEY() - adds a key to the tagged index after dbappend() */ /* The tagged index file must be lock first */ /*---------------------------------------------------------------------------------------*/ rc = dbxlocki(dbx); errorproc("dbxlocki()", "tagged index file locked.", rc); rc = dbxakey(dbx, recno); errorproc("dbxakey()", "key added.", rc); rc = dbxunlocki(dbx); errorproc("dbxunlocki()", "tagged index file unlocked.", rc); /*---------------------------------------------------------------------------------------*/ /* DBFLUSH() - flushes the record cache to disk */ /*---------------------------------------------------------------------------------------*/ rc = dbflush(dbf); errorproc("dbflush()", "table cache flushed.", rc); /*---------------------------------------------------------------------------------------*/ /* DBIFLSH() - flushes the index cache to disk */ /*---------------------------------------------------------------------------------------*/ rc = dbiflsh(ndx); errorproc("dbiflsh()", "index cache flushed.", rc); /*---------------------------------------------------------------------------------------*/ /* DBXFLSH() - flushes the tagged index cache to disk */ /*---------------------------------------------------------------------------------------*/ rc = dbxflsh(dbx); errorproc("dbxflsh()", "Tagged index cache flushed.", rc); /*---------------------------------------------------------------------------------------*/ /* DBGETR() - retrieves a record */ /*---------------------------------------------------------------------------------------*/ rc = dbgetr(dbf, (long) 1, record, &status); errorproc("dbgetr()", "record retrieved.", rc); printf("\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()", "retrieved memo.", rc); /*---------------------------------------------------------------------------------------*/ /* DBUPDM() - Updates the memo field for this record */ /*---------------------------------------------------------------------------------------*/ strcat(tmpbuf, " Appending this string to the end of memo..."); rc = dbupdm(dbt, tmpbuf, &record[53], &record[53]); errorproc("dbupdm()", "updated memo.", rc); /*---------------------------------------------------------------------------------------*/ /* DBPUTRK() - the following example adds a record and index */ /* to the respective files. */ /* DBRECOUT() - scatter the record stored in buffer 'record' to a two */ /* dimensional character array 'fldbuf' */ /*---------------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------------*/ /* Read in 6 more records */ /*---------------------------------------------------------------------------------------*/ for (i = 1; i <= 6; i++) { dbrecout(dbf, dbfields, fldpos, text_table[i], fldbuf); rc = dbputrk(dbf, ndx, fldbuf[0], text_table[i]); errorproc("dbputrk()", "record placed by key.", rc); } errorproc("dbputrk()", "6 records placed by key.", rc); /*---------------------------------------------------------------------------------------*/ /* DBFLUSH() - flushes the record cache to disk */ /*---------------------------------------------------------------------------------------*/ rc = dbflush(dbf); errorproc("dbflush()", "table cache flushed.", rc); /*---------------------------------------------------------------------------------------*/ /* DBIFLSH() - flushes the index cache to disk */ /*---------------------------------------------------------------------------------------*/ rc = dbiflsh(ndx); errorproc("dbiflsh()", "index cache flushed.", rc); /*---------------------------------------------------------------------------------------*/ /* DBXFLSH() - flushes the tagged index cache to disk */ /*---------------------------------------------------------------------------------------*/ rc = dbxflsh(dbx); errorproc("dbxflsh()", "Tagged index cache flushed.", rc); /*---------------------------------------------------------------------------------------*/ /* DBFIELD() - this example extracts the field 'VESSEL' from the */ /* record (#5) stored in buffer 'record' */ /*---------------------------------------------------------------------------------------*/ rc = dbgetr(dbf, (long) 5, record, &status); /* rc = dbfield( dbf, record, "FLAG", tmpbuf); */ rc = dbfield(dbf, record, fields[5].fieldnm, tmpbuf); errorproc("dbfield()", "field extracted.", rc); printf("\t\tFlag: \t%s\n", tmpbuf); /*---------------------------------------------------------------------------------------*/ /* Modify a single field in record number 5 */ /*---------------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------------*/ /* DBSCATTER() - scatter the record into specified field buffers */ /*---------------------------------------------------------------------------------------*/ rc = dbscatter(dbf, record, fldbuf); errorproc("dbscatter()", "record scattered.", rc); for (i = 0; i < nofields; i++) { fprintf(stdout, "\t\tfldbuf[%d]='%s'\n", i, fldbuf[i]); } strcpy(fldbuf[5], "Spanish"); /* Modify Field */ /*---------------------------------------------------------------------------------------*/ /* DBGATHER() - gather the field buffers and place the contents */ /*---------------------------------------------------------------------------------------*/ rc = dbgather(dbf, record, fldbuf); errorproc("dbgather()", "record gathered.", rc); printf("\t\t%s\n", record); rc = dbupdr(dbf, (long) 5, record); /* Finish Example */ errorproc("dbupdr()", "record updated.", rc); /*---------------------------------------------------------------------------------------*/ /* Perform index / index conversion functions. */ /*---------------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------------*/ /* DBREWIND() - position the record pointer to the top of the index file */ /*---------------------------------------------------------------------------------------*/ rc = dbrewind(ndx); errorproc("dbrewind()", "index rewound.", rc); /*---------------------------------------------------------------------------------------*/ /* DBGETNR() - after 'rewinding' to the top of the table, the first record */ /* can be retrieved with dbgetnr() using the active key */ /*---------------------------------------------------------------------------------------*/ for (i = 1; i <= 6; i++) { rc = dbgetnr(dbf, ndx, record, &status); printf("\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() - position the pointer to the top of the index file */ /*---------------------------------------------------------------------------------------*/ rc = dbxrewind(dbx); errorproc("dbxrewind()", "Tagged index rewound.", rc); /*---------------------------------------------------------------------------------------*/ /* DBXGETNR() - after 'rewinding' to the top of the table, the first record */ /* can be retrieved with dbgetnr() using the active key */ /*---------------------------------------------------------------------------------------*/ for (i = 1; i <= 6; i++) { rc = dbxgetnr(dbf, dbx, record, &status); printf("\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 field */ /*---------------------------------------------------------------------------------------*/ rc = dbatofld("23.3", 4, 1, tmpbuf); errorproc("dbatofld()", "string converted.", rc); /*---------------------------------------------------------------------------------------*/ /* DBATOKEY() - converts a ASCII string to Recital date key */ /*---------------------------------------------------------------------------------------*/ key[0] = 'D'; rc = dbatokey("16430411", key); errorproc("dbatokey()", "string converted to key.", rc); /*---------------------------------------------------------------------------------------*/ /* DBFLDTOA() - converts extracted field to ASCII */ /*---------------------------------------------------------------------------------------*/ rc = dbfldtoa(record + 18, 4, tmpbuf); errorproc("dbfldtoa()", "field converted.", rc); /*---------------------------------------------------------------------------------------*/ /* DBSTRCPY() - formats character strings to Recital types */ /*---------------------------------------------------------------------------------------*/ dbstrcpy(key, 'L', 10, " 320000"); printf("Function: \tdbstrcpy() \toutput: %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 decimal places */ tmpbuf[1] = 'N'; /* Key Type */ rc = dbkeytoa(key, tmpbuf); errorproc("dbkeytoa()", "key converted.", rc); /*---------------------------------------------------------------------------------------*/ /* Perform record/index deletion and file access */ /*---------------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------------*/ /* DBSIZE() - retrieve the size of the table */ /*---------------------------------------------------------------------------------------*/ rc = dbsize(dbf, &db_size); errorproc("dbsize()", "size retrieved.", rc); printf("\t No. of Records: \t%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); /*---------------------------------------------------------------------------------------*/ /* Add record to the Production Index as well */ /*---------------------------------------------------------------------------------------*/ rc = dbxakey(dbx, db_size + 1L); errorproc("dbxakey()", "key added.", rc); dbflush(dbf); dbiflsh(ndx); dbxflsh(dbx); /*---------------------------------------------------------------------------------------*/ /* DBDELETE() - mark a record (number 8) for deletion */ /*---------------------------------------------------------------------------------------*/ rc = dbdelete(dbf, 8L); errorproc("dbdelete()", "record 8 marked for deletion.", rc); /*---------------------------------------------------------------------------------------*/ /* DBRECALL() - recall a record marked for deletion (number 8) */ /*---------------------------------------------------------------------------------------*/ rc = dbrecall(dbf, 8L); errorproc("dbrecall()", "record 8 recalled.", rc); /*---------------------------------------------------------------------------------------*/ /* DBRMVKEY() - physically remove a key. As of v8.0, this function */ /* is not permitted on tables opened shareable. */ /*---------------------------------------------------------------------------------------*/ /* rc = dbrmvkey(ndx, "Unknown Vessel ", db_size+1L); */ /* errorproc("dbrmvkey()", "key physically removed.", rc); */ /*---------------------------------------------------------------------------------------*/ /* DBRMVR() - physically remove a data record. As of v8.0 this */ /* function is not permitted on tables opened shareable. */ /*---------------------------------------------------------------------------------------*/ /* rc = dbrmvr(dbf, db_size+1L); */ /* errorproc("dbrmvr()", "record 7 physically removed.", rc); */ /*---------------------------------------------------------------------------------------*/ /* DBUNLOCKF() - unlocks a table file */ /*---------------------------------------------------------------------------------------*/ rc = dbunlockf(dbf); if (rc == SUCCESS) { printf("Function: \tdbunlockf() tFile unlocked 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 multi user */ /* environment. Same as DBTLOCKR() in multi access */ /*---------------------------------------------------------------------------------------*/ rc = dblockr(dbf, (long) 7); if (rc == SUCCESS) { printf("Function: \tdblockr() \trecord locked successfully.\n"); } else { printf("Lock Failed. tError: %dn", rc); } /*---------------------------------------------------------------------------------------*/ /* DBUNLOCKR() - unlocks a table Record */ /*---------------------------------------------------------------------------------------*/ rc = dbunlockr(dbf, (long) 7); if (rc == SUCCESS) { printf("Function \tdbunlockr(): \trecord unlocked 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 int 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; }