dBaseC - kezelsi tmutat

Bevezets
   A DBC egy rutinhalmaz,  melynek segtsgvel  dBase III kompa-
tibilis adatbzisokat kezelhetnk C nyelv programokbl. A rutin-
halmaz hrom, jl elklnthet rszbl ll:

	adatmanipull rutinok
	adatfile kezel rutinok
	indexfile kezel rutinok

   A  rendszer szinte semmilyen automatizmust nem  nyjt  a hrom
elklnl   rsz  egyttes  kezelsre,   a   gyakorlatban  ezek
sszehangolsa  teljesen  a programoz feladata.  Ez azt jelenti,
hogy az esetleg szksges adatkonverzikrl a felhasznlnak kell
gondoskodnia a DBC rutinok hvsa eltt. Az adat- s indexfile-ok
nem adatbzisknt kezeldnek,  a  felhasznl  feladata  az egyes
file-ok  helyes  karbantartsa  Ez  egy  nagyon  lnyeges   s  a
programozs  sorn  szem  eltt  tartand  szempont  az adatbzis
helyes kezelse cljbl.

   A  DBC  eredetileg  egyfelhasznls   programok  rst  tette
lehetv.  A jelenlegi mdostott verzi kpes a konkurens elrs
biztostsra.   Ez  nhny  rutin   mdostsval,  illetve  egy
negyedik  rsz  illesztsvel lett megvalstva.  A negyedik rsz
rutinjai  biztostjk  a  konkurens  elrs   sszehangolst.  A
megvltoztatott rutinok  felhasznli  oldalrl  vltozatlanok, a
konkurens elrs  a  DBC  rutinok  keretbe  foglalst  jelenti a
negyedik rsz rutinjai ltal.

   Minden fggvnyhvs visszatrsi  rtke  SUCCESS, ha sikeres
volt  a mvelet.  Az  egyb  visszatrsi  rtkek  rtelmezse a
kvetkez fejezetben tallhat.


Konstans, struktra s tpusdeklarcik:

Konstansdeklarcik:
#define ACTIVE    0                /* record is active              */
#define INACTIVE  1                /* record is inactive (marked del)*/

#define CHARKEY   'C'              /* CHARACTER key                 */
#define NDKEY     'N'              /* NUMERIC or DATE key           */

Tpusdeklarcik:
typedef unsigned char BYTE;        /* unsigned 1 byte data          */
typedef unsigned short U2BYTES;    /* unsigned 2 bytes data         */
typedef long     RECNUM;           /* record number                 */
typedef long     NBYTES;
typedef BYTE     FLDWIDTH;         /* field width in bytes          */
typedef BYTE     FLDDEC;           /* decimal places in field       */
typedef BYTE     FLDNUM;           /* number of fields per record   */
typedef U2BYTES  RECLEN;           /* record length                 */
typedef BYTE     KEYLEN;           /* key length                    */

Struktra defincik:

	.DBF (adatfile) record definicis struktra

typedef struct
        {
        char fieldnm[11];           /* meznv NULL(0)-al zrva       */
        char type;                  /* adattpus. Lehet:
                                                'C' - character
                                                'N' - numeric
                                                'D' - date
                                                'L' - logical
                                                'M' - memo            */
        FLDWIDTH width;             /* mezszlessg                  */
        FLDDEC   dec;               /* decimlis helyek hossza        */
} dBFIELD;

	.DBF (adatfile) file definicis struktra

typedef struct S_DBFFILE
        {
        int      _dbffn;         /* adatfile ler              */
        BYTE     _dbfmode;       /* nyitsi md                 */
        RECNUM   _alcnum;        /* alloklt rekordok szma     */
        RECNUM   _reclock;       /* a reteszelt rekord szma    */
        int      _dbfupd;        /* adatfile update-jelz       */
        RECLEN   _len;           /* adatrekord hossza           */

        /*** I/O buffer information ***/

        U2BYTES  _bufsize;       /* I/O buffer mrete           */
        char     *_bfptr;        /* az I/O buffer cme          */
        U2BYTES  _maxnum;        /* max. rekordszm a bufferben */
        RECNUM   _first;         /* az elso rekord szma a bufferben*/
        U2BYTES  _bfhas;         /* rekordok szma a bufferben  */
        BYTE     _month;         /* utols mdosts: hnap     */
        BYTE     _day;           /*                   nap       */
        BYTE     _year;          /*                   v        */
        FLDNUM   _nflds;         /* rekordmezk szma           */
        dBFIELD  *_flds;         /* a mezler tmb cme (dBIII)*/
        U2BYTES  _begdata;       /* beginning-of-data offset */
} DBFFILE;

	.NDX (indexfile) file definicis struktra

typedef struct S_NDXFILE
        {
        int      _ndxfn;               /* file ler                    */
        BYTE     _ndxmode;             /* nyitsi md                   */
        BLKNO    _orootbk;             /* eredeti gykrblokk           */
        BLKNO    _oeofbk;              /* eredeti file-vge blokk       */
        BLKNO    _rootblk;             /* aktulis gykrblokk          */
        BLKNO    _eofblk;              /* aktulis file-vge blokk      */
        KEYLEN   _keylen;              /* kulcshossz                    */
        KEYLEN   _kptrlen;             /* kulcs+adatpointer mrete      */
        BYTE     _maxknum;             /* max. kulcsszm egy blokkban   */
        char     _keytype;             /* kulcs tpusa: 'C', 'N', 'D'   */

        BYTE     *_actkey;             /* MI-SOFT: aktulis kulcs       */
        BLKNO    _actpointer;          /* MI-SOFT: aktulis adatpointer */

        /*** used for sequential accessing ***/

        struct _seqacc
                 {
                 BLKNO  _nxblkno;      /* blokkszm                     */
                 BYTE   _nxidno;       /* indexazonost szm           */
                 char   *_nxbfptr;     /* index I/O buffer cme         */
                 BYTE   _nxusage;      /* bufferllapot jelz           */
        } _svector[32],                /* elrsi vektor                */
        *_svptr, *_endofsv;            /* elrsi vektor pointerek      */
} NDXFILE;

typedef struct
        {
        int      _dbtfn;                    /* file ler              */
        BYTE     _dbtmode;                  /* nyitsi md             */
        BLKNO    _odbteof;                  /* eredeti file-vge blokk */
        BLKNO    _dbteof;                   /* aktulis file-vge blokk*/
} DBTFILE;

	stucture definitions to handle file

typedef struct S_HANDLE             /* describes a semaphore handle  */
        {
        int      base;
        int      offset;
} HANDLE;


typedef struct S_LOCK               /* the structure to handle file locks*/
        {
        char     s_name[128];       /* datafile name with complete path*/
        HANDLE   s1;                /* first semaphore handle        */
        HANDLE   s2;                /* second semaphore handle       */
} LOCK;

Visszatrsi kdok rtelmezse:

#define SUCCESS   0 sikeres vgrehajts
#define d_ERROR   1 ltalnos hibakd (alapvet hibk, pl nincs nyitva a file )
#define d_NODBF   2 a file nem .DBF formtum adatfile
#define d_BADREC  3 hibs adatrekordszm ( < 0 vagy tlmutat)
#define d_WTFAIL  4 rsi hiba (pl tele van a lemez)
#define d_NONDX   5 a file nem .NDX formtum indexfile
#define d_KYLONG  6 tl hossz kulcskifejezs
#define d_NOKEY   7 az .NDX file res vagy nem talltuk a kulcsot
#define d_MAYBE   8 a keresettnl nagyobb indexet tallt
#define d_ENDKEY  9 az .NDX file vghez rtnk (az ELOZO KULCS mvelet
az 				 utols indexet fogja elvenni)
#define d_NOSYNC 10 nincs meg a kulcshoz tartoz adatrekord
#define d_TOPKEY 11 az indexfile elejnl vagyunk (a KVETKEZ KULCS
					mvelet az els indexet fogja elvenni)
#define d_NETERR1 1 MI-SOFT: Hlzati hiba
#define d_NETERR2 3 MI-SOFT: Hlzati hiba
#define d_LOCKERR 1 MI-SOFT: Hiba a lock-olasban
#define d_BUSY    2 MI-SOFT: Foglalt rekord vagy adatbazis
#define d_COMPAT  1 NOVELL kompatibilis a rendszer

Adatkonverzis rutinok:

   A DBC kt tpus  indexet ismer:  karakteres s nem karakteres
tpus indexet. A nem karakteres index lehet numerikus vagy dtum
tpus,  kezelsk a rendszerben egyforma.Egy  index  maximum 100
byte hossz  lehet.A nem karakteres  tpus  index mindig  8 byte
hossz.
   
   A   karakteres   indexek   kezelse   nem   ignyel  klnfle
konverzikat.A  hasonlts  szempontjbl  NEM  stringnek,  hanem
adott  hosszsg  byte-sorozatnak rtelmezdnek,  vagyis az res
helyeket is mindig ki kell tlteni a helyes hasonlts rdekben.
   
   A  nem  karakteres  kulcsokat  oda-vissza  konvertlni  kell a
megfelel fggvnyek segtsgvel.
   
dBatofld

Funkcija:G String konvertlsa dBase III numerikus formra
HFormja

int dBatofld( ascii, width, decimal, field )
     char    *ascii;                 /* a konvertland string        */
     int     with;                   /* a mez szlessge             */
     int     decimal;                /* a tizedesjegyek szma         */
     char    *field;                 /* hova konvertlunk             */

dBfldtoa

Funkcija:G dBase III numerikus mez konvertlsa stringg
HFormja

int dBatofld( field, width, ascii )
     char    *field;                 /* mit konvertlunk              */
     int     with;                   /* a mez szlessge             */
     char    *ascii;                 /* hova konvertlunk             */

dBatokey

Funkcija:G String konvertlsa nem karakteres indexsz
HFormja

int dBatokey(ascii,numkey)
     char    *ascii;                 /* mit konvertlunk              */
     char    *numkey;                /* hova konvertlunk             */

Megjegyzs:
   A numerikus s dtum tpus kulcsokat mindig  konvertlni kell
a  dBatokey  fggvnnyel !  Numkey output  paramter,  de a hvs
eltt numkey els byte-jt a tpusra kell  inicializlni  (D vagy
N).

dBkeytoa

Funkcija:G Nem karakteres kulcs konvertlsa stringg
HFormja

int dBkeytoa(key,ascii)
     char    *key;                   /* a konvertland kulcs         */
     char    *ascii;                 /* hova konvertlunk             */

Megjegyzs:
   A nem karakter  tpus  kulcsok  kzvetlenl  nem jelenthetk
meg,  eltte stringg  kell  konvertlni a  dBkeytoa fggvnnyel.
Ascii  output  paramter,  de  a hvs eltt az  els  byte-jt a
tizedesjegyek  szmval,  msodik byte-jt a tpussal  (D vagy N)
kell inicializlni.

dBstrcpy

Funkcija:G String formtumozsa
HFormja

void dBstrcpy(string,adjmode,length,origstr)
     char   *string;                /* a formtumozott string (output)*/
     char   adjmode;                /* formtumspecifikci           */
     int    length;                 /* a formtumozott string hossza  */
     char   *origstr;               /* a formtumozand string        */
     
Megjegyzs:
   A formtumspecifikci jelentse 'r'  s 'R' karakterek esetn
jobbra  igazts,  minden ms karakter  esetn  balra igazts. A
tiszta programozs kedvrrt clszer a balra igaztst a  'l' s
'L' karakterekkel jellni.

Adatfile kezel rutinok

dBcreat

Funkcija:G Adatfile ltrehozsa
HFormja

int dBcreat(dbfname, nofields, fields)
     char    *dbfname;               /* a ltrehozand file neve      */
     FLDNUM  nofields;               /* mezk szma                   */
     dBFIELD fields[];               /* a mezket ler struktratmb */

Megjegyzs:
   Minden paramtre input.  Ha  ltezik  az  adatfile,  akkor azt
csonkolja.  A  fggvny  kizrlagos  hasznlattal  ltrehozza  a
file-t,  lmajd  le  is  zrja  azt.  Tovbbi  hasznlat  eltt az
adatfile meg kell nyitni !

dBopen

Funkcija:G Adatfile megnyitsa
HFormja

int dBopen(dbfname, dbffd)
     char    *dbfname;               /* megnyitand file neve (input) */
     char    **dbffd;                /* a file ler blokk cmt      */
                                     /* tartalmaz vltoz cme !!!   */

Megjegyzs:
   A dBopen  fggvny  osztott hasznlatra  nyitja  meg  a file-t
(lsd sopen). A file ler blokkot a dBopen fggvny alloklja.

dBclose

Funkcija:G Adatfile lezrsa
HFormja

int dBclose(dbffd)
     char *dbffd;                    /* a fileler blokk cme        */

dBgetr

Funkcija:G Adatrekord olvassa
HFormja

int dBgetr(dbffd, recno, recbuf, status)
     char    *dbffd;                 /* file ler blokk cme         */
     RECNUM  recno;                  /* olvasand rekord szma        */
     char    *recbuf;                /* rekord buffer (output)        */
     char    *status;                /* a rekord logikailag trlt-e  */

Megjegyzs:
   Az adatrekord maximlis mrete 4100 byte. Az adatrekord szmt
egy elz kulcskeresssel lehet belltani. A rekordllapot jelz
egy byte s a cmt kell tadni. 

dBgetrk

Funkcija:G A megadott kulcshoz tartoz rekord beolvassa
HFormja

int dBgetrk(dbffd, ndxfd, key, record, status)
     char    *dbffd;                 /* adatfile ler blokk          */
     char    *ndxfd;                 /* indexfile ler blokk         */
     char    *key;                   /* kulcs                         */
     char    *record;                /* az adatrekord cme            */
     char    *status;                /* rekord llapot jelz          */

Megjegyzs:
   A megadott  indexfile-ban  megkeresi  a  megadott  kulcsot. Ha
megtallta,  akkor a kulcshoz  tartoz  rekordot  beolvassa  s a
rekord ltal mutatott  cmre teszi.  Ha az llapotjelz INACTIVE,
akkor az adatrekord logikailag trlt.

dBgetnr

Funkcija:G Kulcs szerinti kvetkez adatrekord beolvassa
HFormja

     int dBgetnr(dbffd, ndxfd, record, status)
     char    *dbffd;                 /* adatfile ler blokk          */
     char    *ndxfd;                 /* indexfile ler blokk         */
     char    *key;                   /* kulcs                         */
     char    *record;                /* az adatrekord cme            */
     char    *status;                /* rekord llapot jelz          */

Megjegyzs:
   A megadott indexfile kvetkez indexre pozcionl.  Ha ez nem
a file vge pozci,  akkor beolvassa s a record  ltal mutatott
cmre teszi az adatrekordot.

dBgetpr

Funkcija:G Kulcs szerinti elz rekord beolvassa
HFormja

int dBgetpr(dbffd, ndxfd, record, status)
     char    *dbffd;                 /* adatfile ler blokk          */
     char    *ndxfd;                 /* indexfile ler blokk         */
     char    *key;                   /* kulcs                         */
     char    *record;                /* az adatrekord cme            */
     char    *status;                /* rekord llapot jelz          */

Megjegyzs:
   A megadott  indexfile elz indexre  pozcionl.  Ha ez nem a
file eleje pozci,  akkor beolvassa s  a record  ltal mutatott
cmre teszi az adatrekordot.

dBputr

Funkcija:G Adatrekord kirsa adott rekordszmra

HFormja

int dBputr(dbffd, recno, recbuf)
     char    *dbffd;                 /* file ler blokk              */
     RECNUM  recno;                  /* rand rekord szma           */
     char    *recbuf;                /* rekord buffer (max 4100 byte) */
     
Megjegyzs:
   A fggvny INSERT funkcit hajt vgre.  Ha az rand  rekord a
file vghez illesztdik,  akkor  nincsen  semmi  baj  (  recno =
dBsize +  (RECNUM)  1  ).  Ha az indexfile-ban lehetnek dupliklt
indexek,  akkor dBputrk helyett ezt a fggvny kell  hasznlni j
rekord kirsra, s recno-t a fenti mdon kell kiszmolni. Ha az
rand rekord  a file  kzepbe  tartozik,  akkor  ez  egy valdi
INSERT funkcit  jelent,  ami  az indexllomnyok tnkremensvel
jr.

dBupdr

Funkcija:G Egy adatrekord update-je
HFormja

int dBupdr(dbffd, recno, recbuf)
     char    *dbffd;                 /* file ler blokk              */
     RECNUM  recno;                  /* mdostand rekord szma      */
     char    *recbuf;                /* rekord buffer (max 4100 byte) */

Megjegyzs:
   Ltez  rekord  fellrsa.   Ha  recno  nagyobb  az  alloklt
rekordok  szmnl,  vagy  kisebb  nullnl,  akkor  hibazenetet
kapunk.

dBputrk

Funkcija:G Adott kulcs adatrekord kirsa
HFormja

int dBputrk(dbffd, ndxfd, key, record)
     char    *dbffd;                 /* adatfile ler blokk          */
     char    *ndxfd;                 /* indexfile ler blokk         */
     char    *key;                   /* kulcs                         */
     char    *record;                /* az adatrekord cme            */

Megjegyzs:
   Az indexfile megkeresi a  megadott  kulcsot.  Ha  megtallta a
kulcsot,   akkor  egy  dBupdr  fggvnyhvssal  aktualizlja  az
adatrekordot.  Ha nem tallta meg  a  kulcsot,  akkor  egy dBputr
fggvnyhvssal  a file  vghez illeszti  az  adatrekordot s a
kulcsot beszrja az indexfile-ba.

dBdelete

Funkcija:G Adatrekord logikai trlse
HFormja

int dBdelete(dbffd, recno)
     char    *dbffd;                 /* file ler blokk                */
     RECNUM  recno;                  /* trlend rekord szma           */
     
Megjegyzs:
A rekord csak logikailag trldik az llomnybl.

dBrecall

Funkcija:G Logikailag trlt adatrekord visszalltsa
HFormja

int dBrecall(dbffd, recno)
     char    *dbffd;                 /* file ler blokk                */
     RECNUM  recno;                  /* visszalltand rekord szma    */

dBrmvr

Funkcija:G Rekord fizikai trlse
HFormja

int dBrmvr(dbffd, recno)
     char    *dbffd;                 /* file ler blokk              */
     RECNUM  recno;                  /* trlend rekord szma         */

Megjegyzs:
Az  adatfile-ban  soha nincsenek  lyukak,  gy a fizikai trls a
htrbb ll  rekordok  elremozgatsval jr.  Ez a gyakorlatban
azt   jelenti,    hogy   az   adatfile-hoz   tartoz   llomnyok
tnkremennek, jra kell az adatfile indexelni.

dBgetf

Funkcija:G Az adatfile-ra jellemz adatok, mezlersok eolvassa
HFormja

int dBgetf(dbffd, reclen, month, day, year, nofields, fields)
     char    *dbffd;                 /* file ler blokk              */
     U2BYTES *reclen;                /* rekord hossza                 */
     BYTE    *month, *day, *year;    /* utols mdosts dtuma       */
     FLDNUM  *nofields;              /* a mezk szma                 */
     dBFIELD *fields;                /* mezlersok tmbje           */
     
Megjegyzs:
A dbffd kivtelvel mind output paramter.

dBsize

Funkcija:G A rekordok szmanak visszaadsa
HFormja

int dBsize(dbffd, size)
     char    *dbffd;                 /* file ler blokk              */
     RECNUM  *size;                  /* rekordok szma                */

Megjegyzs:
A size output paramter,  teht egy long rtk cmt kell tadni.
Ebben  jn  vissza  az  utols  alloklt  rekord  szma.Uj rekord
kirsa a (size+(RECNUM)1) szmu rekordba trtnik !

dBflush

Funkcija:G Az adatfile I/O buffernek rtse s a fejblokk kirsa
HFormja

int dBflush(dbffd)
     char    *dbffd;                 /* file ler blokk              */
     
Megjegyzs:
A buffert minden rsi file-lock felolds eltt  ki kell rteni.
Indexfile kezel rutinok

dBicreat

Funkcija:G Indexfile ltrehozsa
HFormja

int dBicreat(ndxname, keyexpr, keylen, keytype)
     char    *ndxname;               /* indexfile neve                */
     char    *keyexpr;               /* indexkifejezs                */
     KEYLEN  keylen;                 /* index hossza                  */
     char    keytype;                /* C, N vagy D                   */
     
Megjegyzs:
Az  indexfile  a  ltrehozs  alatt  kizrlagos  hasznlatra van
megnyitva.  A ltrehozs utn a file-t lezrjuk,  teht a tovbbi
hozzfrs eltt meg kell nyitni.  Vigyzat, a fggvny a meglev
llomnyt csonkolja.   A  kulcshosszt  csak  karakter  (C) tpus
kulcs esetn  kell  megadni.  A msik kt  tpusnl  a kulcshossz
mindig 8 byte.

dBiopen

Funkcija:G Indexfile megnyitsa
HFormja

int dBiopen(ndxname, ndxfd)
     char    *ndxname;               /* a file neve                   */
     char    **ndxfd;                /* a fileler blokk cmt       */
                                     /* tartalmaz vltoz cme       */
     
Megjegyzs:
A  fggvnyhvs  eltt  a  fileler  blokk  cmt  nullra kell
inicializlni.  A  fileler  blokkot  a  fggvny  alloklja.  A
fggvny az indexfile osztott hasznlatra nyitja meg.

dBiclose

Funkcija:G Indexfile lezrsa
HFormja

int dBiclose(ndxfd)
     char        *ndxfd;             /* indexfile ler blokk         */

dBakey

Funkcija:G Index beszrsa az indexfile-ba
HFormja

int dBakey(ndxfd, key, recno)
     char    *ndxfd;                 /* indexfile ler blokk         */
     char    *key;                   /* index                         */
     RECNUM  recno;                  /* amely rekordhoz tartozik az index */
     
Megjegyzs:
Az indexet a megfelel  konvertl  rutinok  segtsgvel konver-
tlni kell.

A recno inicializlsa:
dBputrk automatikusan karbantart egy  indexfilet. A karbantartott
indexfile-ban meg  kell  keresni  a  beszrt  indexet,  a keress
egyttal visszaadja az adatrekord szmt  is,  ezt kell a tovbbi
dBakey hvsokban hasznlni.  Dupliklt kulcsok esetn  nem lehet
dBputrk-t hasznlni j  adatrekord felvitelre.  Ilyenkor a recno
kiszmtsi mdja: dBsize visszaadja az utols rekord szmt, ezt
eggyel  megnvelve  kapjuk  a  felrand   adatrekord  pozcijt
(recno).  (Az adatrekordot  a dBputr fggvnnyel  kell kirni) Az
index beszrsa utn  az  indexfile  aktulis  pozcija  az els
index eltti pozci.

dBrmvkey

Funkcija:G Index trlse
HFormja

int dBrmvkey(ndxfd, key, recno)
     char    *ndxfd;                 /* indexfile ler               */
     char    *key;                   /* index                         */
     RECNUM  recno;                  /* amely rekordhoz tartozik az index */

Megjegyzs:
Az  indexbejegyzs  azonostsa kulcs+recno  alajn  trtnik, ez
dupliklt kulcsok esetben is egyedi kell legyen. A fggvnyhvs
eltt  kulcsot  a  konvertlfggvnyek  segtsgvel konvertlni
kell.   A kulcs trlse utn  az indexfile  aktulis pozcija az
els index eltti pozci.

dBtkey

Funkcija:G A megadott kulcs keresse az indexfile-ban
HFormja

int dBtkey(ndxfd, key, recno)
     char    *ndxfd;                 /* indexfile ler blokk         */
     char    *key;                   /* index                         */
     RECNUM  *recno;                 /* indexhez tartoz adatpointer  */
     
Megjegyzs:
Ha a fggvny visszatrsi  rtke d_MAYBE  (csak nagyobb kulcsot
tallt),  akkor key  rtke  a  nagyobb  kulcsra inicializldik.
Recno mindig a key-ben lev kulcshoz  tartoz adatpointer. rtke
csak SUCCESS s d_MAYBE visszatrsi rtkek esetn lltdik be,
egybknt meghatrozatlan.

dBckey

Funkcija:G Az indexfile aktulis kulcsnak lekrdezse
HFormja

int dBckey(ndxfd, key, recno)
     char    *ndxfd;                 /* indexfile ler blokk         */
     char    *key;                   /* az aktulis index             */
     RECNUM  *recno;                 /* indexhez tartoz adatpointer  */
     
Megjegyzs:
Nincs aktulis kulcs:
 - res az indexfile
 - az aktulis pozci a file eleje pozci
 - az aktulis pozci a file vge pozci
 - konkurens elrs esetn az aktulis kulcsot egy msik felhasznl eltrlte

dBnkey

Funkcija:G Az indexfile kvetkez kulcsnak lekrdezse
HFormja

int dBnkey(ndxfd, key, recno)
     char    *ndxfd;                 /* indexfile ler blokk         */
     char    *key;                   /* index                         */
     RECNUM  *recno;                 /*az indexhez tartoz adatpointer*/
     
Megjegyzs:
Ha az  aktulis pozci  az utols kulcs az  indexfile-ban, akkor
egy  dBnkey  fggvnyhvs utn  az aktulis pozci a  file vge
pozci lesz.  Ha az aktulis pozci a file eleje pozci, akkor
egy  dBnkey  fggvnyhvs utn  az aktulis pozci a  file els
indexe  lesz.  Recno  a  key-ben  visszakapott  kulcshoz  tartoz
adatpointer,  rtke meghatrozatlan,  ha  az  aktulis pozci a
file eleje vagy vge pozci.

dBpkey

Funkcija:G Az indexfile elz kulcsnak lekrdezse
HFormja

int dBpkey(ndxfd, key, recno)
     char    *ndxfd;                 /* indexfile ler blokk         */
     char    *key;                   /* index                         */
     RECNUM  *recno;                 /* indexhez tartoz adatpointer  */
     
Megjegyzs:
Ha az aktulis pozci az els kulcs az indexfile-ban,  akkor egy
dBpkey  fggvnyhvs  utn  az  aktulis  pozci  a  file eleje
pozci lesz.  az aktulis pozci a file vge pozci, akkor egy
dBpkey fggvnyhvs  utn  az  aktulis  pozci  a  file utols
indexe  lesz.  Recno  a  key-ben  visszakapott  kulcshoz  tartoz
adatpointer,  rtke meghatrozatlan,  ha  az  aktulis pozci a
file eleje vagy vge pozci.

dBrewind

Funkcija:G Az indexfile elejre pozcionl
HFormja

int dBrewind(ndxfd)
     char    *ndxfd;                 /* indexfile ler blokk         */
     
Megjegyzs:
A fggvnyhvs utn az aktulis pozci a file eleje pozci lesz.

dBfwd

Funkcija:G Az indexfile vgre pozicionl
HFormja

int dBfwd(ndxfd)
     char    *ndxfd;                 /* indexfile ler blokk         */
     
Megjegyzs:
A fggvnyhvs utn az aktulis pozci a file vge pozci lesz.

dBkeyexpr

Funkcija:G Indexfile jellemzinek beolvassa
HFormja

int dBkexpr(ndxfd, keytype, keyexpr, kexprlen, keylen)
     char    *ndxfd;                 /* indexfile ler blokk         */
     char    *keytype;               /* kulcs tpusa (output)         */
     char    *keyexpr;               /* indexkifejezs (output)       */
     int     *keyexprlen;            /* indexkifejezs hossza (output)*/
     KEYLEN  *keylen;                /* kulcs hossza (output)         */

dBiflush

Funkcija:G Az indexfile I/O buffernek rtse s a fejblokk kirsa
HFormja

int dBiflsh(ndxfd)
     char    *ndxfd;                 /* indexfile ler blokk         */
     
Megjegyzs:
A fggvnyt minden rsi file lock felolds eltt meg kell hvni.
Konkurens  hozzfrs  A   DBC   rutinhalmaz  bvtett  vltozata
tartalmazza azokat a fgvnyeket, melyek segtsgvel a konkurens
hozzfrs  sszehangolsa  megvalsthat.  A  konkurens kezels
biztostsra   nincs   semmilyen   automatizmus,   a  programoz
felelssge, hogy a fggvnyeket a megfelel mdon hasznlja.  Az
adatbzishoz trtn hozzfrst kt  csoportra oszthatjuk: rsi
jelleg mveletek s olvassi jelleg mveletek.

- adatbzis nyitsa
- adatbzisrl informcik krdezse: pl. mret,kulcskifejezs, aktulis
	pozci, stb.
- keress
- pozcionls
- olvass
- adatbzis zrsa
- beszrs
- aktualizls
- logikai s fizikai trls

   A  konkurens  elrs  megkveteli  egyrszt  a  munkallomsok
munkjnak  sszehangolst,  msrszt a  file-kezel sajt bels
buffereinek  helyes  kezelst.  Az  sszehangolst  lock-olssal
valsthatjuk meg,  a file-kezel buffereit a megfelel  rt s
trl eljrsokon keresztl tudjuk kezelni.

   Adatbzis  szinten ltezik rsi  lock  s  olvassi  lock. Az
rsi lock minden ms hozzfrst kizr s  minden  rsi jelleg
mvelet eltt ki  kell  adni.  Az olvassi  jelleg lock  csak az
rsi mveleteket zrja ki.  Hasznlata csak  akkor  ktelez, ha
egyidben rjk s  olvassk  a file-t.  Ha mindenki csak olvasni
akar,  akkor mindenfle sszehangols felesleges. A rekord szint
lock  mindig  olvassi  lock,  teht  a rekord  aktualizlst s
trlst  zrja ki.  Hasznlata szintn csak  akkor  ktelez, ha
rni  is akarunk  a file-ba,  egybknt felesleges. { Megjegyzs:
Minden mukahely egyszerre legfeljebb egy rekordot lock-olhat.
   
   Konkurens krnyezetben nem maradhat  olyan informci  a bels
bufferekben,  melyek az adatbzis llapott rjk le,  mert ezt a
tbbi lloms is  hasznlja.  Ezrt minden  rsi jelleg mvelet
utn,  de  szigoran  a  lock  feloldsa  eltt  rteni  kell az
adatfile  s  az  sszes indexfile  buffert (flush). Mindenfajta
mvelet eltt,  de  szigoran a  megfelel  lock  belltsa utn
trlni  kell  a   buffereket,   hogy  az   aktulis  informcik
beolvasdjanak   a   lemezrl  (clear).   A  bufferek  ilyenfajta
kezelsre  csak  akkor  van  szksg,  ha  rni  is  akarunk. Ha
mindenki csak olvasni akar,  akkor a bufferek rtse  s trlse
felesleges  bonyoltja  s  lasstja  az  adatelrst. A bufferek
ilyenfajta kezelse csak a lock-olssal egytt hibamentes.

if (olvassi lock nem sikerlt)
   {
   error("Foglalt a file, olvass nem indthat !");
   return;
   }
adatfile buffernek trlse;
az sszes indexfile buffernek trlse;
adatbzis olvassa;
olvassi lock feloldsa;

if (rsi lock nem sikerlt)
   {
   error("Foglalt a file, rs nem indthat !");
   return;
   }
adatfile buffernek trlse;
az sszes indexfile buffernek trlse;
adatbzis rsa;
az sszes indexfile buffernek rtse;
adatfile buffernek rtse;
rsi lock feloldsa;

if (olvassi lock nem sikerlt)
   {
   error("Foglalt a file, olvass nem indthat !");
   return;
   }
adatfile buffernek trlse;
az sszes indexfile buffernek trlse;
adarekord szmnak meghatrozsa

if (rekord lock nem sikerlt)
   {
   error("A mdostani kvnt rekord foglalt !");
   goto quit;
   }
adatbzis olvassa
quit:
olvassi lock feloldsa;

if (rsi lock nem sikerlt)
   {
   error("Foglalt a file, trls nem indthat !");
   return;
   }
adatfile buffernek trlse;
az sszes indexfile buffernek trlse;
adarekord szmnak meghatrozsa

if (rekord lock nem sikerlt)
   {
   error("A trlni kvnt rekord foglalt !");
   goto quit;
   }
else
   rekord lock feloldsa;
adatbzis rsa
adatfile buffernek trlse;
az sszes indexfile buffernek trlse;
quit:
rsi lock feloldsa;

Az adatbzis szint lock-ols belltsa s a lock-ols feloldsa
kztt a kommunikcit LOCK tpus vltozk biztostjk, melyeket
a felhasznli  programban  kell  deklarlni.  Egy  ilyen vltoz
tartalmt a lock-ols eltt  inicializlni  kell  s  tartalmt a
lock  felodsig  meg  kell  rizni!  Clszer  minden  adatbzis
szmra  egy  LOCK  tpus  vltozt   fenntartani  az  esetleges
fellrs elkerlse  vgett.  Ebben  az esetben  a vltozt csak
egyszer kell inicializlni.

A  kommunikcis vltoz inicializlsa  az init_lock() fggvny-
hvssal trtnhet.  A fggvny  lersa  ksbb  kvetkezik, itt
csak  annyit  jegyznk  meg,  hogy  az  egyrtelmsg biztostsa
vgett clszer  az  adatfile  teljes  path-jt  megadni: server,
ktet, stb.

A konkurens kezels adminisztrcijnak csak  akkor  van rtelme,
ha a felhasznli program valban konkurens krnyezetben mkdik.
A filekezel  konkurens rutinjai  szmra  jelezni  kell,  hogy a
program  konkurens  krnyezetben  mkdik-e  vagy  sem.  Ezrt  a
felhasznli   programban  deklarlnunk  kell   egy   vltozt  a
kvetkez mdon:

extern int network;

A vltozt az els DBC fggvnyhvs eltt  inicializlni  kell a
kvetkez mdon:

network = is_network();

Ez  egyrszt  inicializlja a  hlzatot  -  ha  az  mkdik  - a
filekezel  szmra,  msrszt a network vltoz  jelezni fogja a
filekezel szmra, hogy konkurens-e a rendszer vagy sem.

A vltoz 1-tl eltr rtke  azt jeleneti,  hogy a rendszer nem
konkurens  rendszer.  Ebben  az esetben a  lock-ol, a lock-olst
felold,  valamint  a  buffereket  trl  rutinok  nem  csinlnak
semmit,  csak  visszaadjk a sikeres mvelet  kdjt.  A bufferek
rtse   az  rt   fggvnyek  hvsa  esetn   nem  konkurens
rendszerben  is  megtrtnik,  mert lyen mdon  hiba esetn (pl.
hlzatkimarads) kevesebb informci veszik el.

read_lock

Funkcija:G Adatbzisra olvassi lock belltsa
HFormja

int read_lock(lockptr)
     LOCK    *lockptr;               /* struktra a hvsok kztti   */
                                     /* kommunikcira                */
     
Megjegyzs:
A   struktra   s_name  mezjt   a  hvs  eltt   az  adatbzis
adatfile-jnak nevvel kell inicializlni.  A struktra tartalmt
a  lock  feloldsig meg  kell  rizni.  A  fggvny visszatrsi
rtke SUCCESS  sikeres  mvelet  esetn.  A  d_BUSY visszatrsi
rtk azt jelenti,  hogy az adatbzis rsra foglalt. A d_NETERR1
vagy d_NETERR2 visszatrsi rtkek a hlzat hibjt jelentik.

read_release

Funkcija:G Adatbzis olvassi lock-jnak feloldsa
HFormja

int read_release(lockptr)
     LOCK    *lockptr;               /* struktra a hvsok
     kztti   */
                                     /*
     kommunikcira                */

Megjegyzs:
A fggvny visszatrsi rtke SUCCESS sikeres  mvelet esetn. A
d_LOCKERR visszatrsi  rtk azt jelenti,  hogy  a kommunikcit
biztost struktra tartalma megsrlt.

write_lock

Funkcija:G Adatbzisra rsi lock belltsa
HFormja

int write_lock(lockptr)
     LOCK    *lockptr;               /* struktra a hvsok kztti   */
                                     /* kommunikcira                */
     
Megjegyzs:
A  struktra   s_name  mezjt   a   hvs   eltt  az  adatbzis
adatfile-jnak nevvel kell inicializlni.  A struktra tartalmt
a lock  feloldsig meg  kell  rizni.   A  fggvny visszatrsi
rtke  SUCCESS sikeres  mvelet  esetn.  A  d_BUSY visszatrsi
rtk azt jelenti,  hogy az adatbzis rsra foglalt. A d_NETERR1
visszatrsi rtk a hlzat hibjt jelenti.

write_release

Funkcija:G Adatbzis rsi lock-jnak feloldsa
HFormja

int write_release(lockptr)
     LOCK    *lockptr;               /* struktra a hvsok kztti   */
                                     /* kommunikcira                */
     
Megjegyzs:
A fggvny visszatrsi rtke SUCCESS sikeres mvelet  esetn. A
d_LOCKERR  visszatrsi  rtk azt jelenti,  hogy a kommunikcit
biztost struktra tartalma megsrlt.

lock_record

Funkcija:G Rekord lock-olsa
HFormja

int lock_record(fname,dbfptr,recno)
     char    *fname;                 /* az adatbzis adatfile-nak neve*/
     DBFFILE *dbfptr;                /* adatfile ler blokk          */
     RECNUM  recno;                  /* a lockoland rekord szma     */
     
Megjegyzs:
A fggvny visszatrsi rtke sikeres mvelet esetn SUCCESS. Az
d_LOCKERR  visszatrsi  rtk azt jelenti,  hogy  az  lloms az
adatfile-bl mr tart reteszelve rekordot.  A d_BUSY visszatrsi
rtk azt jelenti, hogy a rekord foglalt.

release_record

Funkcija:G Rekord lock feloldsa
HFormja

int release_record(fname,dbfptr,recno)
     char    *fname;                 /* az adatbzis adatfile-nak neve*/
     DBFFILE *dbfptr;                /* adatfile ler blokk          */
     RECNUM  recno;                  /* a feloldand rekord szma     */
     
Megjegyzs:
A fggvny visszatrsi rtke sikeres mvelet esetn SUCCESS. Az
d_LOCKERR  visszatrsi  rtk azt jelenti,  hogy  a  rekordot az
lloms nem lock-olta.

is_network

Funkcija:G Lockolsi md llts
HFormja

int is_network()

Megjegyzs:
A  fggvnyt minden  futtathat  program elejn  egyszer meg kell
hvni,  klnben a konkurrnes  hozzfrs hlzat  esetn nem fog
mkdni. A fggvny visszatrsi rtke d_COMPAT, ha a rendszer a
NOVELL NetWare 4.6  verzij rendszerrel kompatibilis.  Ez egyben
belltja  a hlzat lock  mdjt  gy,  hogy a DBC rekord szint
lockolsa  is  helyesen  mkdjn.  Ha a  visszatrsi  rtk nem
d_COMPAT,  akkor a rendszer  nem kompatibilis !  A NOVELL NetWare
4.6-tal nem kompatibilis rendszereket nem konkurrens rendszerknt
kezeljk.

init_lock

Funkcija:G Kommunikcis vltoz inicializlsa
HFormja

int init_lock(lockptr,name)
     LOCK	*lockptr;	  /* mutat a kommunikcis vltozra */
     char	*name;		  /* az adatbzis adatfile-jnak neve */
     
Megjegyzs:
Az adatfile nevnl clszer a teljes path specifikcit (server,
ktet,   stb)   megadni  az   egyrtelmsg  biztostsa  vgett.
Ellenkez esetben felesleges vrakozsok fordulhatnak  el, de ez
hibt nem okoz.

dBclrbuf

Funkcija:G Az adatfile buffernek kitrlse
HFormja

int dBclrbuf(dbffile)
     char	*dbffile;	/* az adatfile lerja		      */

Megjegyzs:
Adatbzis szint  rsi s  olvassi lock utn,  a tnyleges rs
vagy  olvass eltt meg kell  hvni.  Igy tudjuk biztostani azt,
hogy  minden  olyan informci,  mely megvltozhatott, a lemezrl
kerljn beolvassra.

dBclibuf

Funkcija:G Az indexfile buffernek kitrlse
HFormja


int dBclibuf(ndxfile)
     char	*ndxfile;	/* az indexfile lerja 	      */
Megjegyzs:
Adatbzis szint  rsi s  olvassi lock utn,  a tnyleges rs
vagy  olvass eltt meg kell  hvni.  Igy tudjuk biztostani azt,
hogy  minden  olyan informci,  mely megvltozhatott, a lemezrl
kerljn beolvassra.
 
