Difference between revisions of "Library dblsamp"

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

Revision as of 12:46, 2 April 2009

// Template:Todo: tidy up

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        7000000 95/01/01        Spanish  ",
          "Santa Rosa             81.824.8        30000000        32/01/01        Spanish  ",
          "Unknown galleon        83.123.0        0               15/01/01        Spanish",
          "Jessie                 97.127.4        100000  75/01/01        U.S.     ",
          "Lea                    96.227.8        1000000 80/01/01        U.S.     ",
          "S.J. Lee               96.926.9        200000  75/01/01        U.S.     ",
          "Genovase               78.418.4        1850000 30/01/01        Spanish  ",
          "Unknown Vessel 77.517.9        0               75/01/01        U.S.     " };
 
/*-------------------------------------------------------------------------------------------------*/
/* Main program entry point.                                                            */
/*-------------------------------------------------------------------------------------------------*/
main()
{
  int rc; /* Return Code for error handling       */
  char *dbf; /* File descriptor for table            */
  char *dbx; /* File descriptor for tagged index     */
  char *ndx; /* File descriptor for index            */
  char *dbt; /* File descriptor for memo file        */
  char record[58]; /* Array of char for records            */
  char keytype; /* Variable for varying keytype */
  char key[21]; /* Storage location for keys            */
  char tagname[21]; /* Storage location for tag name        */
  char keyexpr[512]; /* Storage location for key expr        */
  char forexpr[512]; /* Storage location for for expr        */
  int kexprlen; /* The key expression length            */
  int keylen; /* The key length                       */
  dBFIELD dbfields[128]; /* Storage location for field names     */
  FLDNUM fieldcount; /* Number of fields to create           */
  int fldpos[128]; /* Fields position buffer               */
  char flddes[128][26]; /* Fields description buffer            */
  char tmpbuf[81]; /* Temporary storage buffer             */
  char fldbuf[128][256]; /* Field buffer (recin()/out())         */
  char nextkey[10][20]; /* Key buffers (dbnkey())               */
  char status; /* Deleted record flag                  */
  long recno; /* Table record variable                */
  long rec_no[10]; /* Record number array (dbnkey())       */
  long db_size; /* Size of table variable               */
  int reclen; /* Table record length variable */
  char month; /* Month variable                       */
  char day; /* Day variable                 */
  char year; /* Year variable                        */
  FLDNUM nofields; /* Number of table fields variable      */
  int i; /* Loop control variable                */
  double n; /* Double numeric variable              */
  int keyunique; /* Boolean for unique tag key           */
  int keydescend; /* Boolean for descending tag key       */
  int notags; /* number of tags in a dbx file */
 
  /*----------------------------------------------------------------------------------------*/
  /* Perform operational Library environment functions.                   */
  /*----------------------------------------------------------------------------------------*/
 
  /*----------------------------------------------------------------------------------------*/
  /* DBDCACHE() - this example allocates a 100 record caching area        */
  /*----------------------------------------------------------------------------------------*/
  rc = dbdcache(100);
  errorproc("dbdcache()", "table cache specified.", rc);
 
  /*----------------------------------------------------------------------------------------*/
  /* DBICACHE() - this example allocates 51200 bytes for index caching    */
  /*----------------------------------------------------------------------------------------*/
  rc = dbicache(100);
  errorproc("dbicache()", "index cache specified.", rc);
 
  /*----------------------------------------------------------------------------------------*/
  /* DBFILEMODE() - shared, read write access                             */
  /*----------------------------------------------------------------------------------------*/
  rc = dbfilemode(1, 0);
  errorproc("dbfilemode()", "file mode specified.", rc);
 
  /*----------------------------------------------------------------------------------------*/
  /* DBSET() - Set exact index match to true                                      */
  /*----------------------------------------------------------------------------------------*/
  rc = dbset("EXACT", 1);
  errorproc("dbset()", "filemode specified.", rc);
 
  /*----------------------------------------------------------------------------------------*/
  /* Perform basic table functions.                                               */
  /*----------------------------------------------------------------------------------------*/
  fieldcount = 7; /* Number of Fields     */
 
  /*----------------------------------------------------------------------------------------*/
  /* DBCREAT() - this example creates a table according to the 'dBFIELD'  */
  /* array fields.                                                                        */
  /*----------------------------------------------------------------------------------------*/
  rc = dbcreat("shipwreck.dbf", fieldcount, fields);
  errorproc("dbcreat()", "database created.", rc);
 
  /*----------------------------------------------------------------------------------------*/
  /* DBCREATX() - Enables the addition of table field descriptions.               */
  /*----------------------------------------------------------------------------------------*/
  strcpy(flddes[0], "The vessel's name.");
  strcpy(flddes[1], "The latitude.");
  strcpy(flddes[2], "The longitude.");
  strcpy(flddes[3], "The value.");
  strcpy(flddes[4], "The date.");
  strcpy(flddes[5], "The vessel's flag.");
  strcpy(flddes[6], "Notes.");
 
  rc = dbcreatx("shipwreck.dbf", fieldcount, fields, flddes);
 
  /*----------------------------------------------------------------------------------------*/
  /* DBOPEN() - example opens table 'shipwreck.dbf' returning the table   */
  /* file descriptor (dbf) used in upcoming functions                             */
  /*----------------------------------------------------------------------------------------*/
  rc = dbopen("shipwreck.dbf", &dbf);
  errorproc("dbopen()", "table opened.", rc);
 
  /*----------------------------------------------------------------------------------------*/
  /* DBGETF() - obtain table information on the table referenced by the   */
  /* 'dbf' file descriptor.                                                               */
  /*----------------------------------------------------------------------------------------*/
  rc = dbgetf(dbf, &reclen, &month, &day, &year, &nofields, dbfields);
  errorproc("dbgetf()", "information retrieved.", rc);
  printf("\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 an tag on field VESSEL */
  /*----------------------------------------------------------------------------------------*/
  rc = dbxcreate(dbf, fields[0].fieldnm, /* "VESSEL",    */
  &dbx, fields[0].fieldnm, /* "VESSEL",    */
  NULL, 0, 0);
  errorproc("dbxcreate()", "tag created", rc);
 
  /*----------------------------------------------------------------------------------------*/
  /* DBXCREATE() - in this example creates an tag on field FLAG           */
  /*----------------------------------------------------------------------------------------*/
  rc = dbxcreate(dbf, fields[5].fieldnm, /* "FLAG",      */
  &dbx, fields[5].fieldnm, /* "FLAG",      */
  NULL, 0, 0);
  errorproc("dbxcreate()", "tag created", rc);
 
  /*----------------------------------------------------------------------------------------*/
  /* DBXNOTAGS() - obtains the number of tagged indexes                   */
  /*----------------------------------------------------------------------------------------*/
  rc = dbxnotags(dbx, &notags);
  errorproc("dbxnotags()", "tagged index count obtained.", rc);
  printf("\t         Key count: \t%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;
}
Retrieved from "https://www.recitalsoftware.com/wiki/index.php?title=Library_dblsamp&oldid=4884"