$eli.
$con.
$par/nou,noi.
$ctr/mar=5,cnb=90.
$tit.
$spa/20.
$mid/tc.
DBC - kezel'esi 'utmutat'o
MI-SOFT bels"o haszn'alatra

1987
$eoc.
$cpt.
Bevezet'es
A DBC egy rutinhalmaz, melynek seg'its'eg'evel dBase III kompatibilis
adatb'azisokat kezelhet:unk C nyelv"u programokb'ol.
A rutinhalmaz h'arom, j'ol elk:ul:on'ithet"o r'eszb"ol 'all:
{{-{adatmanipul'al'o rutinok
{{-{adatfile kezel"o rutinok
{{-{indexfile kezel"o rutinok

A rendszer szinte semmilyen automatizmust nem ny'ujt a h'arom
elk:ul:on:ul"o r'esz egy:uttes kezel'es'ere, a gyakorlatban ezek
:osszehangol'asa teljesen a programoz'o feladata.
Ez azt jelenti, hogy az esetleg sz:uks'eges adatkonverzi'okr'ol a
felhaszn'al'onak kell gondoskodnia a DBC rutinok h'iv'asa el"ott.
Az adat- 'es indexfile-ok nem adatb'azisk'ent kezel"odnek, a felhaszn'al'o
feladata az egyes file-ok helyes karbantart'asa.
Ez egy nagyon l'enyeges 'es a programoz'as sor'an szem el"ott tartand'o
szempont az adatb'azis helyes kezel'ese c'elj'ab'ol.

A DBC eredetileg egyfelhaszn'al'os programok 'ir'as'at tette lehet"ov'e.
A jelenlegi m'odos'itott verzi'o k'epes a konkurrens el'er'es
biztos'it'as'ara.
Ez n'eh'any rutin m'odos'it'as'aval, illetve egy negyedik r'esz
illeszt'es'evel lett megval'os'itva.
A negyedik r'esz rutinjai biztos'itj'ak a konkurrens el'er'es
:osszehangol'as'at.

A megv'altoztatott rutinok felhaszn'al'oi oldalr'ol v'altozatlanok, a
konkurrens el'er'es a DBC rutinok keretbe foglal'as'at jelenti a negyedik
r'esz rutinjai 'altal.

Minden f:uggv'enyh'iv'as visszat'er'esi 'ert'eke SUCCESS, ha sikeres volt
a m"uvelet.
Az egy'eb visszat'er'esi 'ert'ekek 'ertelmez'ese a k:ovetkez"o fejezetben
tal'alhat'o.
$cpt.
Konstans, strukt'ura 'es t'ipusdeklar'aci'ok
$sec.
Konstansdeklar'aci'ok
$pic/tc.
#define ACTIVE    0                /* record is active              */
#define INACTIVE  1                /* record is inactive (marked deleted)*/

#define CHARKEY   'C'              /* CHARACTER key                 */
#define NDKEY     'N'              /* NUMERIC or DATE key           */
$eoc.
$pag/15.
$sec.
T'ipusdeklar'aci'ok
$pic/tc.
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                    */
$eoc.
$pag/15.
$sec.
Strukt'ura defin'ici'ok
$mid/tc.
/************************************************/
/* .DBF (adatfile) record definici'os strukt'ura  */
/************************************************/
$eoc.

$pic/tc.
typedef struct
        {
        char fieldnm[11];           /* mez"on'ev NULL(0)-al z'arva     */
        char type;                  /* adatt'ipus. Lehet:
                                                'C' - character
                                                'N' - numeric
                                                'D' - date
                                                'L' - logical
                                                'M' - memo             */
        FLDWIDTH width;             /* mez"osz'eless'eg                   */
        FLDDEC   dec;               /* decim'alis helyek hossza         */
} dBFIELD;
$eoc.

$pag.
$mid/tc.
/**********************************************/
/* .DBF (adatfile) file definici'os strukt'ura  */
/**********************************************/
$eoc.

$pic/tc.
typedef struct S_DBFFILE
        {
        int      _dbffn;         /* adatfile le'ir'o              */
        BYTE     _dbfmode;       /* nyit'asi m'od                 */
        RECNUM   _alcnum;        /* allok'alt rekordok sz'ama     */
        RECNUM   _reclock;       /* a reteszelt rekord sz'ama    */
        int      _dbfupd;        /* adatfile update-jelz"o       */
        RECLEN   _len;           /* adatrekord hossza           */

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

        U2BYTES  _bufsize;       /* I/O buffer m'erete           */
        char     *_bfptr;        /* az I/O buffer c'ime          */
        U2BYTES  _maxnum;        /* max. rekordsz'am a bufferben */
        RECNUM   _first;         /* az elso rekord sz'ama a bufferben*/
        U2BYTES  _bfhas;         /* rekordok sz'ama a bufferben  */
        BYTE     _month;         /* utols'o m'odos'it'as: h'onap     */
        BYTE     _day;           /*                   nap       */
        BYTE     _year;          /*                   'ev        */
        FLDNUM   _nflds;         /* rekordmez"ok sz'ama           */
        dBFIELD  *_flds;         /* a mez"ole'ir'o t:omb c'ime (dBIII)*/
        U2BYTES  _begdata;       /* beginning-of-data offset */
} DBFFILE;
$eoc.

$pag.
$mid/tc.
/***********************************************/
/* .NDX (indexfile) file definici'os strukt'ura  */
/***********************************************/
$eoc.

$pic/tc.
typedef struct S_NDXFILE
        {
        int      _ndxfn;               /* file le'ir'o                    */
        BYTE     _ndxmode;             /* nyit'asi m'od                   */
        BLKNO    _orootbk;             /* eredeti gy:ok'erblokk           */
        BLKNO    _oeofbk;              /* eredeti file-v'ege blokk       */
        BLKNO    _rootblk;             /* aktu'alis gy:ok'erblokk          */
        BLKNO    _eofblk;              /* aktu'alis file-v'ege blokk      */
        KEYLEN   _keylen;              /* kulcshossz                    */
        KEYLEN   _kptrlen;             /* kulcs+adatpointer m'erete      */
        BYTE     _maxknum;             /* max. kulcssz'am egy blokkban   */
        char     _keytype;             /* kulcs t'ipusa: 'C', 'N', 'D'   */

        BYTE     *_actkey;             /* MI-SOFT: aktu'alis kulcs       */
        BLKNO    _actpointer;          /* MI-SOFT: aktu'alis adatpointer */

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

        struct _seqacc
                 {
                 BLKNO  _nxblkno;      /* blokksz'am                     */
                 BYTE   _nxidno;       /* indexazonos'it'o sz'am           */
                 char   *_nxbfptr;     /* index I/O buffer c'ime         */
                 BYTE   _nxusage;      /* buffer'allapot jelz"o           */
        } _svector[32],                /* el'er'esi vektor                */
        *_svptr, *_endofsv;            /* el'er'esi vektor pointerek      */

} NDXFILE;



typedef struct
        {
        int      _dbtfn;                    /* file le'ir'o              */
        BYTE     _dbtmode;                  /* nyit'asi m'od             */
        BLKNO    _odbteof;                  /* eredeti file-v'ege blokk */
        BLKNO    _dbteof;                   /* aktu'alis file-v'ege blokk*/
} DBTFILE;
$eoc.

$pag.
$mid/tc.
******************************************************
* MI_SOFT: stucture definitions to handle file locks *
******************************************************
$eoc.

$pic/tc.
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;
$eoc.
$pag/15.
$sec.
Visszat'er'esi k'odok 'ertelmez'ese
$tab/1,22,30.
{#define SUCCESS{0{sikeres v'egrehajt'as
{#define d_ERROR1{{'altal'anos hibak'od (~alapvet"o hib'ak, pl nincs
megnyitva a file~)
{#define d_NODBF{2{a file nem .DBF form'atum'u adatfile
{#define d_BADREC{3{hib'as adatrekordsz'am (<0 vagy t'ulmutat)
{#define d_WTFAIL{4{'ir'asi hiba (~pl tele van a lemez~)
{#define d_NONDX{5{a file nem .NDX form'atum'u indexfile
{#define d_KYLONG{6{t'ul hossz'u kulcskifejez'es
{#define d_NOKEY{7{az .NDX file :ures vagy nem tal'altuk a kulcsot
{#define d_MAYBE{8{a keresettn'el nagyobb indexet tal'alt
{#define d_ENDKEY{9{az .NDX file v'eg'ehez 'ert:unk (~az ELOZO KULCS
m"uvelet az utols'o indexet fogja el"ovenni~)
{#define d_NOSYNC{10{nincs meg a kulcshoz tartoz'o adatrekord
{#define d_TOPKEY{11{az indexfile elej'en'el vagyunk (~a K:OVETKEZ"O KULCS
m"uvelet az els"o indexet fogja el"ovenni~)
{#define d_NETERR1{1{MI-SOFT: Halozati hiba
{#define d_NETERR2{3{MI-SOFT: Halozati 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
$tab.
$cpt.
Adatkonverzi'os rutinok
A DBC k'et t'ipus'u indexet ismer: karakteres 'es nem karakteres
t'ipus'u indexet.
A nem karakteres index lehet numerikus vagy d'atum t'ipus'u, kezel'es:uk a
rendszerben egyforma.

Egy index maximum 100 byte hossz'u lehet.
A nem karakteres t'ipus'u index mindig 8 byte hossz'u.

A karakteres indexek kezel'ese nem ig'enyel k:ul:onf'ele konverzi'okat.
A hasonl'it'as szempontj'ab'ol NEM stringnek, hanem adott hossz'us'ag'u
byte-sorozatnak 'ertelmez"odnek, vagyis az :ures helyeket is mindig ki
kell t:olteni a helyes hasonl'it'as 'erdek'eben.

A nem karakteres kulcsokat oda-vissza konvert'alni kell a megfelel"o
f:uggv'enyek seg'its'eg'evel.
$pag/15.
$sec.
dBatofld
Funkci'oja:

{{{String konvert'al'asa dBase III numerikus form'ara

Form'aja:

$pic/tc.
int dBatofld(ascii,width,decimal,field)
    char    *ascii;                 /* a konvert'aland'o string        */
    int     with;                   /* a mez"o sz'eless'ege             */
    int     decimal;                /* a tizedesjegyek sz'ama         */
    char    *field;                 /* hova konvert'alunk             */
$eoc.

Megjegyz'es:
Ha valaki kital'alta, hogy mikor kell haszn'alni, az sz'oljon (~Gyuri~).
$pag/15.
$sec.
dBfldtoa
Funkci'oja:

{{{dBase III numerikus mez"o konvert'al'asa stringg'e

Form'aja:

$pic/tc.
int dBatofld(field,width,ascii)
    char    *field;                 /* mit konvert'alunk              */
    int     with;                   /* a mez"o sz'eless'ege             */
    char    *ascii;                 /* hova konvert'alunk             */
$eoc.

Megjegyz'es:
Ha valaki kital'alta, hogy mikor kell haszn'alni, az sz'oljon (~Gyuri~).
$pag/15.
$sec.
dBatokey
Funkci'oja:

{{{String konvert'al'asa nem karakteres indexsz'e

Form'aja:

$pic/tc.
int dBatokey(ascii,numkey)
    char    *ascii;                 /* mit konvert'alunk              */
    char    *numkey;                /* hova konvert'alunk             */
$eoc.
 
Megjegyz'es:
A numerikus 'es d'atum t'ipus'u kulcsokat mindig konvert'alni kell a
dBatokey f:uggv'ennyel !!!
Numkey output param'eter, de a h'iv'as el"ott numkey els"o byte-j'at
a t'ipusra kell inicializ'alni (~D vagy N~).
$pag/15.
$sec.
dBkeytoa
Funkci'oja:

{{{Nem karakteres kulcs konvert'al'asa stringg'e

Form'aja:

$pic/tc.
int dBkeytoa(key,ascii)
    char    *key;                   /* a konvert'aland'o kulcs         */
    char    *ascii;                 /* hova konvert'alunk              */
$eoc.

Megjegyz'es:
A nem karakter t'ipus'u kulcsok k:ozvetlen:ul nem jelen'ithet"ok meg,
el"otte stringg'e kell konvert'alni a dBkeytoa f:uggv'ennyel.
Ascii output param'eter, de a h'iv'as el"ott az els"o byte-j'at a
tizedesjegyek sz'am'aval, m'asodik byte-j'at a t'ipussal (~D vagy N~)
kell inicializ'alni.
$pag/15.
$sec.
dBstrcpy
Funkci'oja:

{{{String form'atumoz'asa

Form'aja:

$pic/tc.
void dBstrcpy(string,adjmode,length,origstr)
     char   *string;                /* a form'atumozott string (output)*/
     char   adjmode;                /* form'atumspecifik'aci'o          */
     int    length;                 /* a form'atumozott string hossza */
     char   *origstr;               /* a form'atumozand'o string       */
$eoc.

Megjegyz'es:
A form'atumspecifik'aci'o jelent'ese 'r' 'es 'R' karakterek eset'en jobbra
igaz'it'as, minden m'as karakter eset'en balra igaz'it'as.
A tiszta programoz'as kedv'er'ert c'elszer"u a balra igaz'it'ast a 'l' 'es
'L' karakterekkel jel:olni.
$cpt.
Adatfile kezel"o rutinok
$sec.
dBcreat
Funkci'oja:

{{{Adatfile l'etrehoz'asa

Form'aja:

$pic/tc.
int dBcreat(dbfname, nofields, fields)
    char    *dbfname;               /* a l'etrehozand'o file neve         */
    FLDNUM  nofields;               /* mez"ok sz'ama                      */
    dBFIELD fields[];               /* a mez"oket le'ir'o strukt'urat:omb    */
$eoc.

Megjegyz'es:
Minden param'etre input.
Ha l'etezik az adatfile, akkor azt csonkolja.
A f:uggv'eny kiz'ar'olagos haszn'alattal l'etrehozza a file-t, majd
le is z'arja azt.
Tov'abbi haszn'alat el"ott az adatfile meg kell nyitni !
$pag/15.
$sec.
dBopen
Funkci'oja:

{{{Adatfile megnyit'asa

Form'aja:

$pic/tc.
int dBopen(dbfname, dbffd)
    char    *dbfname;               /* megnyitand'o file neve (input)  */
    char    **dbffd;                /* a file le'ir'o blokk c'im'et       */
                                    /* tartalmaz'o v'altoz'o c'ime !!!    */
$eoc.

Megjegyz'es:
A dBopen f:uggv'eny osztott haszn'alatra nyitja meg a file-t (~l'asd
sopen~).
A file le'ir'o blokkot a dBopen f:uggv'eny allok'alja.
$pag/15.
$sec.
dBclose
Funkci'oja:

{{{Adatfile lez'ar'asa

Form'aja:

$pic/tc.
int dBclose(dbffd)
    char *dbffd;                    /* a filele'ir'o blokk c'ime          */
$eoc.
$pag/15.
$sec.
dBgetr
Funkci'oja:

{{{Adatrekord olvas'asa

Form'aja:

$pic/tc.
int dBgetr(dbffd, recno, recbuf, status)
    char    *dbffd;                 /* file le'ir'o blokk c'ime         */
    RECNUM  recno;                  /* olvasand'o rekord sz'ama        */
    char    *recbuf;                /* rekord buffer (output)        */
    char    *status;                /* a rekord logikailag t:or:olt-e  */
                                    /* vagy nem ( ACTIVE, INACTIVE)  */
$eoc.

Megjegyz'es:
Az adatrekord maxim'alis m'erete 4100 byte.
Az adatrekord sz'am'at egy el"oz"o kulcskeres'essel lehet be'all'itani.
A rekord'allapot jelz"o egy byte 'es a c'im'et kell 'atadni.
$pag/15.
$sec.
dBgetrk
Funkci'oja:

{{{A megadott kulcshoz tartoz'o rekord beolvas'asa

Form'aja:

$pic/tc.
int dBgetrk(dbffd, ndxfd, key, record, status)
    char    *dbffd;                 /* adatfile le'ir'o blokk          */
    char    *ndxfd;                 /* indexfile le'ir'o blokk         */
    char    *key;                   /* kulcs                         */
    char    *record;                /* az adatrekord c'ime            */
    char    *status;                /* rekord 'allapot jelz"o          */
                                    /* ACTIVE vagy INACTIVE          */
$eoc.

Megjegyz'es:
A megadott indexfile-ban megkeresi a megadott kulcsot.
Ha megtal'alta, akkor a kulcshoz tartoz'o rekordot beolvassa 'es a rekord
'altal mutatott c'imre teszi.
Ha az 'allapotjelz"o INACTIVE, akkor az adatrekord logikailag t:or:olt.
$pag/15.
$sec.
dBgetnr
Funkci'oja:

{{{Kulcs szerinti k:ovetkez"o adatrekord beolvas'asa

Form'aja:

$pic/tc.
int dBgetnr(dbffd, ndxfd, record, status)
    char    *dbffd;                 /* adatfile le'ir'o blokk          */
    char    *ndxfd;                 /* indexfile le'ir'o blokk         */
    char    *key;                   /* kulcs                         */
    char    *record;                /* az adatrekord c'ime            */
    char    *status;                /* rekord 'allapot jelz"o          */
                                    /* ACTIVE vagy INACTIVE          */
$eoc.

Megjegyz'es:
A megadott indexfile k:ovetkez"o index'ere poz'icion'al.
Ha ez nem a file v'ege poz'ici'o, akkor beolvassa 'es a record 'altal
mutatott c'imre teszi az adatrekordot.
$pag/15.
$sec.
dBgetpr
Funkci'oja:

{{{Kulcs szerinti el"oz"o rekord beolvas'asa

Form'aja:

$pic/tc.
int dBgetpr(dbffd, ndxfd, record, status)
    char    *dbffd;                 /* adatfile le'ir'o blokk          */
    char    *ndxfd;                 /* indexfile le'ir'o blokk         */
    char    *key;                   /* kulcs                         */
    char    *record;                /* az adatrekord c'ime            */
    char    *status;                /* rekord 'allapot jelz"o          */
                                    /* ACTIVE vagy INACTIVE          */
$eoc.

Megjegyz'es:
A megadott indexfile el"oz"o index'ere poz'icion'al.
Ha ez nem a file eleje poz'ici'o, akkor beolvassa 'es a record 'altal
mutatott c'imre teszi az adatrekordot.
$pag/15.
$sec.
dBputr
Funkci'oja:

{{{Adatrekord ki'ir'asa adott rekordsz'amra

Form'aja:

$pic/tc.
int dBputr(dbffd, recno, recbuf)
    char    *dbffd;                 /* file le'ir'o blokk                */
    RECNUM  recno;                  /* 'irand'o rekord sz'ama             */
    char    *recbuf;                /* rekord buffer (max 4100 byte)   */
$eoc.

Megjegyz'es:
A f:uggv'eny INSERT funkci'ot hajt v'egre.
Ha az 'irand'o rekord a file v'eg'ehez illeszt"odik, akkor nincsen
semmi baj (~recno~=~dBsize~+~(RECNUM)~1~).
Ha az indexfile-ban lehetnek duplik'alt indexek, akkor dBputrk helyett
ezt a f:uggv'eny kell haszn'alni 'uj rekord ki'ir'as'ara, 'es recno-t a
fenti m'odon kell kisz'amolni.
Ha az 'irand'o rekord a file k:ozep'ebe tartozik, akkor ez egy val'odi INSERT
funkci'ot jelent, ami az index'allom'anyok t:onkremen'es'evel j'ar.
$pag/15.
$sec.
dBupdr
Funkci'oja:

{{{Egy adatrekord update-je

Form'aja:

$pic/tc.
int dBupdr(dbffd, recno, recbuf)
    char    *dbffd;                 /* file le'ir'o blokk                */
    RECNUM  recno;                  /* m'odos'itand'o rekord sz'ama        */
    char    *recbuf;                /* rekord buffer (max 4100 byte)   */
$eoc.

Megjegyz'es:
L'etez"o rekord fel:ul'ir'asa.
Ha recno nagyobb az allok'alt rekordok sz'am'an'al, vagy kisebb null'an'al,
akkor hiba:uzenetet kapunk.
$pag/15.
$sec.
dBputrk
Funkci'oja:

{{{Adott kulcs'u adatrekord ki'ir'asa

Form'aja:

$pic/tc.
int dBputrk(dbffd, ndxfd, key, record)
    char    *dbffd;                 /* adatfile le'ir'o blokk          */
    char    *ndxfd;                 /* indexfile le'ir'o blokk         */
    char    *key;                   /* kulcs                         */
    char    *record;                /* az adatrekord c'ime            */
$eoc.

Megjegyz'es:
Az indexfile megkeresi a megadott kulcsot.
Ha megtal'alta a kulcsot, akkor egy dBupdr f:uggv'enyh'iv'assal
aktualiz'alja az adatrekordot.
Ha nem tal'alta meg a kulcsot, akkor egy dBputr f:uggv'enyh'iv'assal a
file v'eg'ehez illeszti az adatrekordot 'es a kulcsot besz'urja az
indexfile-ba.
$pag/15.
$sec.
dBdelete
Funkci'oja:

{{{Adatrekord logikai t:orl'ese

Form'aja:

$pic/tc.
int dBdelete(dbffd, recno)
    char    *dbffd;                 /* file le'ir'o blokk                */
    RECNUM  recno;                  /* t:orlend"o rekord sz'ama           */
$eoc.

Megjegyz'es:
A rekord csak logikailag t:orl"odik az 'allom'anyb'ol.
$pag/15.
$sec.
dBrecall
Funkci'oja:

{{{Logikailag t:or:olt adatrekord vissza'all'it'asa

Form'aja:

$pic/tc.
int dBrecall(dbffd, recno)
    char    *dbffd;                 /* file le'ir'o blokk                */
    RECNUM  recno;                  /* vissza'all'itand'o rekord sz'ama    */
$eoc.
$pag/15.
$sec.
dBrmvr
Funkci'oja:

{{{Rekord fizikai t:orl'ese

Form'aja:

$pic/tc.
int dBrmvr(dbffd, recno)
    char    *dbffd;                 /* file le'ir'o blokk                */
    RECNUM  recno;                  /* t:orlend"o rekord sz'ama          */
$eoc.

Megjegyz'es:
Az adatfile-ban soha nincsenek lyukak, 'igy a fizikai t:orl'es a
h'atr'ebb 'all'o rekordok el"oremozgat'as'aval j'ar.
Ez a gyakorlatban azt jelenti, hogy az adatfile-hoz tartoz'o 'allom'anyok
t:onkremennek, 'ujra kell az adatfile indexelni.
$pag/15.
$sec.
dBgetf
Funkci'oja:

{{{Az adatfile-ra jellemz"o adatok, mez"ole'ir'asok beolvas'asa

Form'aja:

$pic/tc.
int dBgetf(dbffd, reclen, month, day, year, nofields, fields)
    char    *dbffd;                 /* file le'ir'o blokk                */
    U2BYTES *reclen;                /* rekord hossza                   */
    BYTE    *month, *day, *year;    /* utols'o m'odos'it'as d'atuma         */
    FLDNUM  *nofields;              /* a mez"ok sz'ama                  */
    dBFIELD *fields;                /* mez"ole'ir'asok t:ombje             */
$eoc.

Megjegyz'es:
{{{A dbffd kiv'etel'evel mind output param'eter.
$pag/15.
$sec.
dBsize
Funkci'oja:

{{{A rekordok sz'amanak visszaad'asa

Form'aja:

$pic/tc.
int dBsize(dbffd, size)
    char    *dbffd;                 /* file le'ir'o blokk                */
    RECNUM  *size;                  /* rekordok sz'ama                  */
$eoc.

Megjegyz'es:
A size output param'eter, teh'at egy long 'ert'ek c'im'et kell 'atadni.
Ebben j:on vissza az utols'o allok'alt rekord sz'ama.
'Uj rekord ki'ir'asa a (~size~+~(RECNUM)~1~) sz'amu rekordba t:ort'enik !
$pag/15.
$sec.
dBflush
Funkci'oja:

{{{Az adatfile I/O buffer'enek :ur'it'ese 'es a fejblokk ki'ir'asa

Form'aja:

$pic/tc.
int dBflush(dbffd)
    char    *dbffd;                 /* file le'ir'o blokk                */
$eoc.

Megjegyz'es:
A buffert minden 'ir'asi file-lock felold'as el"ott ki kell :ur'iteni.
$cpt.
Indexfile kezel"o rutinok
$sec.
dBicreat
Funkci'oja:

{{{Indexfile l'etrehoz'asa

Form'aja:

$pic/tc.
int dBicreat(ndxname, keyexpr, keylen, keytype)
    char    *ndxname;               /* indexfile neve                  */
    char    *keyexpr;               /* indexkifejez'es                  */
    KEYLEN  keylen;                 /* index hossza                    */
    char    keytype;                /* C, N vagy D                     */
$eoc.

Megjegyz'es:
Az indexfile a l'etrehoz'as alatt kiz'ar'olagos haszn'alatra van
megnyitva.
A l'etrehoz'as ut'an a file-t lez'arjuk, teh'at a tov'abbi hozz'af'er'es
el"ott meg kell nyitni.
Vigy'azat, a f:uggv'eny a meglev"o 'allom'anyt csonkolja.

A kulcshosszt csak karakter (~C~) t'ipus'u kulcs eset'en kell megadni.
A m'asik k'et t'ipusn'al a kulcshossz mindig 8 byte.
$pag/15.
$sec.
dBiopen
Funkci'oja:

{{{Indexfile megnyit'asa

Form'aja:

$pic/tc.
int dBiopen(ndxname, ndxfd)
    char    *ndxname;               /* a file neve                   */
    char    **ndxfd;                /* a filele'ir'o blokk c'im'et       */
                                    /* tartalmaz'o v'altoz'o c'ime       */
$eoc.

Megjegyz'es:
A f:uggv'enyh'iv'as el"ott a filele'ir'o blokk c'im'et null'ara kell
inicializ'alni.
A filele'ir'o blokkot a f:uggv'eny allok'alja.
A f:uggv'eny az indexfile osztott haszn'alatra nyitja meg.
$pag/15.
$sec.
dBiclose
Funkci'oja:

{{{Indexfile lez'ar'asa

Form'aja:

$pic/tc.
int dBiclose(ndxfd)
    char        *ndxfd;             /* indexfile le'ir'o blokk           */
$eoc.
$pag/15.
$sec.
dBakey
Funkci'oja:

{{{Index besz'ur'asa az indexfile-ba

Form'aja:

$pic/tc.
int dBakey(ndxfd, key, recno)
    char    *ndxfd;                 /* indexfile le'ir'o blokk           */
    char    *key;                   /* index                             */
    RECNUM  recno;                  /* amely rekordhoz tartozik az index */
$eoc.

Megjegyz'es:
Az indexet a megfelel"o konvert'al'o rutinok seg'its'eg'evel konvert'alni
kell.

A recno inicializ'al'asa:
{{-{dBputrk automatikusan karbantart egy indexfilet.
A karbantartott indexfile-ban meg kell keresni a besz'urt indexet, a
keres'es egy'uttal visszaadja az adatrekord sz'am'at is, ezt kell a
tov'abbi dBakey h'iv'asokban haszn'alni.

{{-{Duplik'alt kulcsok eset'en nem lehet dBputrk-t haszn'alni 'uj adatrekord
felvitel'ere.
Ilyenkor a recno kisz'am'it'asi m'odja: dBsize visszaadja az utols'o rekord
sz'am'at, ezt eggyel megn:ovelve kapjuk a fel'irand'o adatrekord
poz'ici'oj'at (~recno~). (~Az adatrekordot a dBputr f:uggv'ennyel
kell ki'irni~)

Az index besz'ur'asa ut'an az indexfile aktu'alis poz'ici'oja az els"o
index el"otti poz'ici'o.
$pag/15.
$sec.
dBrmvkey
Funkci'oja:

{{{Index t:orl'ese

Form'aja:

$pic/tc.
int dBrmvkey(ndxfd, key, recno)
    char    *ndxfd;                 /* indexfile le'ir'o                   */
    char    *key;                   /* index                             */
    RECNUM  recno;                  /* amely rekordhoz tartozik az index */
$eoc.
Az indexbejegyz'es azonos'it'asa kulcs+recno alaj'an t:ort'enik,
ez duplik'alt kulcsok eset'eben is egyedi kell legyen.
A f:uggv'enyh'iv'as el"ott kulcsot a konvert'al'of:uggv'enyek
seg'its'eg'evel konvert'alni kell.

A kulcs t:orl'ese ut'an az indexfile aktu'alis poz'ici'oja az els"o
index el"otti poz'ici'o.
$pag/15.
$sec.
dBtkey
Funkci'oja:

{{{A megadott kulcs keres'ese az indexfile-ban

Form'aja:

$pic/tc.
int dBtkey(ndxfd, key, recno)
    char    *ndxfd;                 /* indexfile le'ir'o blokk           */
    char    *key;                   /* index                           */
    RECNUM  *recno;                 /* az indexhez tartoz'o adatpointer */
$eoc.

Megjegyz'es:
Ha a f:uggv'eny visszat'er'esi 'ert'eke d_MAYBE (~csak nagyobb kulcsot
tal'alt~), akkor key 'ert'eke a nagyobb kulcsra inicializ'al'odik.
Recno mindig a key-ben lev"o kulcshoz tartoz'o adatpointer.
'Ert'eke csak SUCCESS 'es d_MAYBE visszat'er'esi 'ert'ekek eset'en
'all'it'odik be, egy'ebk'ent meghat'arozatlan.
$pag/15.
$sec.
dBckey
Funkci'oja:

{{{Az indexfile aktu'alis kulcs'anak lek'erdez'ese

Form'aja:

$pic/tc.
int dBckey(ndxfd, key, recno)
    char    *ndxfd;                 /* indexfile le'ir'o blokk           */
    char    *key;                   /* az aktu'alis index               */
    RECNUM  *recno;                 /* az indexhez tartoz'o adatpointer */
$eoc.

Megjegyz'es:
Nincs aktu'alis kulcs:
{{-{:ures az indexfile
{{-{az aktu'alis poz'ici'o a file eleje poz'ici'o
{{-{az aktu'alis poz'ici'o a file v'ege poz'ici'o
{{-{konkurrens el'er'es eset'en az aktu'alis kulcsot egy m'asik
felhaszn'al'o elt:or:olte
$pag/15.
$sec.
dBnkey
Funkci'oja:

{{{Az indexfile k:ovetkez"o kulcs'anak lek'erdez'ese

Form'aja:

$pic/tc.
int dBnkey(ndxfd, key, recno)
    char    *ndxfd;                 /* indexfile le'ir'o blokk           */
    char    *key;                   /* index                           */
    RECNUM  *recno;                 /*az indexhez tartoz'o adatpointer  */
$eoc.

Megjegyz'es:
Ha az aktu'alis poz'ici'o az utols'o kulcs az indexfile-ban, akkor egy
dBnkey f:uggv'enyh'iv'as ut'an az aktu'alis poz'ici'o a file v'ege
poz'ici'o lesz.
Ha az aktu'alis poz'ici'o a file eleje poz'ici'o, akkor egy dBnkey
f:uggv'enyh'iv'as ut'an az aktu'alis poz'ici'o a file els"o indexe lesz.
Recno a key-ben visszakapott kulcshoz tartoz'o adatpointer, 'ert'eke
meghat'arozatlan, ha az aktu'alis poz'ici'o a file eleje vagy v'ege
poz'ici'o.
$pag/15.
$sec.
dBpkey
Funkci'oja:

{{{Az indexfile el"oz"o kulcs'anak lek'erdez'ese

Form'aja:

$pic/tc.
int dBpkey(ndxfd, key, recno)
    char    *ndxfd;                 /* indexfile le'ir'o blokk           */
    char    *key;                   /* index                           */
    RECNUM  *recno;                 /* az indexhez tartoz'o adatpointer */
$eoc.

Megjegyz'es:
Ha az aktu'alis poz'ici'o az els"o kulcs az indexfile-ban, akkor egy
dBpkey f:uggv'enyh'iv'as ut'an az aktu'alis poz'ici'o a file eleje
poz'ici'o lesz.
Ha az aktu'alis poz'ici'o a file v'ege poz'ici'o, akkor egy dBpkey
f:uggv'enyh'iv'as ut'an az aktu'alis poz'ici'o a file utols'o indexe lesz.
Recno a key-ben visszakapott kulcshoz tartoz'o adatpointer, 'ert'eke
meghat'arozatlan, ha az aktu'alis poz'ici'o a file eleje vagy v'ege
poz'ici'o.
$pag/15.
$sec.
dBrewind
Funkci'oja:

{{{Az indexfile elej'ere poz'icion'al

Form'aja:

$pic/tc.
int dBrewind(ndxfd)
    char    *ndxfd;                 /* indexfile le'ir'o blokk         */
$eoc.

Megjegyz'es:
A f:uggv'enyh'iv'as ut'an az aktu'alis poz'ici'o a file eleje poz'ici'o
lesz.
$pag/15.
$sec.
dBfwd
Funkci'oja:

{{{Az indexfile v'eg'ere pozicion'al

Form'aja:

$pic/tc.
int dBfwd(ndxfd)
    char    *ndxfd;                 /* indexfile le'ir'o blokk         */
$eoc.

Megjegyz'es:
A f:uggv'enyh'iv'as ut'an az aktu'alis poz'ici'o a file v'ege poz'ici'o
lesz.
$pag/15.
$sec.
dBkeyexpr
Funkci'oja:

{{{Indexfile jellemz"oinek beolvas'asa

Form'aja:

$pic/tc.
int dBkexpr(ndxfd, keytype, keyexpr, kexprlen, keylen)
    char    *ndxfd;                 /* indexfile le'ir'o blokk         */
    char    *keytype;               /* kulcs t'ipusa (output)         */
    char    *keyexpr;               /* indexkifejez'es (output)       */
    int     *keyexprlen;            /* indexkifejez'es hossza (output)*/
    KEYLEN  *keylen;                /* kulcs hossza (output)         */
$eoc.
$pag/15.
$sec.
dBiflush
Funkci'oja:

{{{Az indexfile I/O buffer'enek :ur'it'ese 'es a fejblokk ki'ir'asa

Form'aja:

$pic/tc.
int dBiflsh(ndxfd)
    char    *ndxfd;                 /* indexfile le'ir'o blokk         */
$eoc.

Megjegyz'es:
A f:uggv'enyt minden 'ir'asi file lock felold'as el"ott meg kell h'ivni.
$cpt.
Konkurrens hozz'af'er'es
A DBC rutinhalmaz b"ov'itett v'altozata tartalmazza azokat a
f:uggv'enyeket, melyek seg'its'eg'evel a konkurrens hozz'af'er'es
:osszehangol'asa megval'os'ithat'o.
A konkurrens kezel'es biztos'it'as'ara nincs semmilyen automatizmus, a
programoz'o felel"oss'ege, hogy a f:uggv'enyeket a megfelel"o m'odon
haszn'alja.

Az adatb'azishoz t:ort'en"o hozz'af'er'est k'et csoportra oszthatjuk: 'ir'asi
jelleg"u m"uveletek 'es olvas'asi jelleg"u m"uveletek.
$_Olvas'asi~jelleg"u~m"uveletek
{{-{adatb'azis nyit'asa
{{-{adatb'azisr'ol inform'aci'ok k'erdez'ese: pl. m'eret,
kulcskifejez'es, aktu'alis poz'ici'o, stb.
{{-{keres'es
{{-{poz'icion'al'as
{{-{olvas'as

$_'Ir'asi~jelleg"u~m"uveletek
{{-{adatb'azis z'ar'asa
{{-{besz'ur'as
{{-{aktualiz'al'as
{{-{logikai 'es fizikai t:orl'es

A konkurrens el'er'es megk:oveteli egyr'eszt a
munka'allom'asok munk'aj'anak :osszehangol'as'at, m'asr'eszt a
file-kezel"o saj'at bels"o buffereinek helyes kezel'es'et.
Az :osszehangol'ast lock-ol'assal val'os'ithatjuk meg, a
file-kezel"o buffereit a megfelel"o :ur'it"o 'es t:orl"o
elj'ar'asokon kereszt:ul tudjuk kezelni.

Adatb'azis szinten l'etezik 'ir'asi lock 'es olvas'asi lock.
Az 'ir'asi lock minden m'as hozz'af'er'est kiz'ar 'es minden
'ir'asi jelleg"u m"uvelet el"ott ki kell adni.
Az olvas'asi jelleg"u lock csak az 'ir'asi m"uveleteket z'arja ki.
Haszn'alata csak akkor k:otelez"o, ha egyid"oben 'irj'ak 'es
olvass'ak a file-t.
Ha mindenki csak olvasni akar, akkor mindenf'ele :osszehangol'as
felesleges.
A rekord szint"u lock mindig olvas'asi lock, teh'at a rekord
aktualiz'al'as'at 'es t:orl'es'et z'arja ki.
Haszn'alata szint'en csak akkor k:otelez"o, ha 'irni is akarunk
a file-ba, egy'ebk'ent felesleges.
{$_Megjegyz'es: Minden mukahely egyszerre legfeljebb egy rekordot
lock-olhat.

Konkurrens k:ornyezetben nem maradhat olyan inform'aci'o a
bels"o bufferekben, melyek az adatb'azis 'allapot'at 'irj'ak le,
mert ezt a t:obbi 'allom'as is haszn'alja.
Ez'ert minden 'ir'asi jelleg"u m"uvelet ut'an, de szigor'uan a
lock felold'asa el"ott :ur'iteni kell az adatfile 'es az :osszes
indexfile buffer'et (~flush~).
Mindenfajta m"uvelet el"ott, de szigor'uan a megfelel"o lock
be'all'it'asa ut'an t:or:olni kell a buffereket, hogy az
aktu'alis inform'aci'ok beolvas'odjanak a lemezr"ol (~clear~).
A bufferek ilyenfajta kezel'es'ere csak akkor van sz:uks'eg, ha
'irni is akarunk.
Ha mindenki csak olvasni akar, akkor a bufferek :ur'it'ese 'es
t:orl'ese felesleges bonyol'itja 'es lass'itja az adatel'er'est.
A bufferek ilyenfajta kezel'ese csak a lock-ol'assal egy:utt
hibamentes (~legal'abbis rem'elem K.Gy.~).

$pag/26.
$_Ezek~alapj'an~az~adatb'azis~olvas'as'anak~algoritmusa~a~k:ovetkez"o:

$pic/tc.
           .
           .
           .
if (olvas'asi lock nem siker:ult)
   {
   error("Foglalt a file, olvas'as nem ind'ithat'o !");
   return;
   }
adatfile buffer'enek t:orl'ese;
az :osszes indexfile buffer'enek t:orl'ese;
           .
           .
           .
adatb'azis olvas'asa;
           .
           .
           .
olvas'asi lock felold'asa;
           .
           .
           .
$eoc.
$spa/3.
$pag/26.

$_Az~'ir'asi~m"uvelet~algoritmusa~a~k:ovetkez"o:

$pic/tc.
           .
           .
           .
if ('ir'asi lock nem siker:ult)
   {
   error("Foglalt a file, 'ir'as nem ind'ithat'o !");
   return;
   }
adatfile buffer'enek t:orl'ese;
az :osszes indexfile buffer'enek t:orl'ese;
           .
           .
           .
adatb'azis 'ir'asa;
           .
           .
           .
az :osszes indexfile buffer'enek :ur'it'ese;
adatfile buffer'enek :ur'it'ese;
'ir'asi lock felold'asa;
           .
           .
           .
$eoc.
$spa/3.
$pag/32.
$_Adatrekord~beolvas'asa~m'odos'it'asra
$pic/tc.
           .
           .
           .
if (olvas'asi lock nem siker:ult)
   {
   error("Foglalt a file, olvas'as nem ind'ithat'o !");
   return;
   }
adatfile buffer'enek t:orl'ese;
az :osszes indexfile buffer'enek t:orl'ese;
           .
           .
           .
adarekord sz'am'anak meghat'aroz'asa
if (rekord lock nem siker:ult)
   {
   error("A m'odos'itani k'iv'ant rekord foglalt !");
   goto quit;
   }
adatb'azis olvas'asa
           .
           .
           .
quit:
olvas'asi lock felold'asa;
           .
           .
           .
$eoc.
$spa/3.
$pag/32.
$_Adatrekord~t:orl'ese
$pic/tc.
           .
           .
           .
if ('ir'asi lock nem siker:ult)
   {
   error("Foglalt a file, t:orl'es nem ind'ithat'o !");
   return;
   }
adatfile buffer'enek t:orl'ese;
az :osszes indexfile buffer'enek t:orl'ese;
           .
           .
           .
adarekord sz'am'anak meghat'aroz'asa
if (rekord lock nem siker:ult)
   {
   error("A t:or:olni k'iv'ant rekord foglalt !");
   goto quit;
   }
else
   rekord lock felold'asa;
           .
           .
           .
adatb'azis 'ir'asa
           .
           .
           .
adatfile buffer'enek t:orl'ese;
az :osszes indexfile buffer'enek t:orl'ese;
quit:
'ir'asi lock felold'asa;
           .
           .
           .
$eoc.
$spa/3.
Az adatb'azis szint"u lock-ol'as be'all'it'asa 'es a lock-ol'as
felold'asa k:oz:ott a kommunik'aci'ot LOCK t'ipus'u v'altoz'ok
biztos'itj'ak, melyeket a felhaszn'al'oi programban kell deklar'alni.
Egy ilyen v'altoz'o tartalm'at a lock-ol'as el"ott
inicializ'alni kell 'es tartalm'at a lock felod'as'aig meg kell "orizni !
C'elszer"u minden adatb'azis sz'am'ara egy LOCK t'ipus'u v'altoz'ot
fenntartani az esetleges fel:ul'ir'as elker:ul'ese v'egett.
Ebben az esetben a v'altoz'ot csak egyszer kell inicializ'alni.

A kommunik'aci'os v'altoz'o inicializ'al'asa az init_lock()
f:uggv'enyh'iv'assal t:ort'enhet.
A f:uggv'eny le'ir'asa k'es"obb k:ovetkezik, itt csak annyit
jegyz:unk meg, hogy az egy'ertelm"us'eg biztos'it'asa v'egett
c'elszer"u az adatfile teljes path-j'at megadni: server, k:otet,
stb.

A konkurrens kezel'es adminisztr'aci'oj'anak csak akkor van
'ertelme, ha a felhaszn'al'oi program val'oban konkurrens
k:ornyezetben m"uk:odik.
A filekezel"o konkurrens rutinjai sz'am'ara jelezni kell, hogy a
program konkurrens k:ornyezetben m"uk:odik-e vagy sem.
Ez'ert a felhaszn'al'oi programban deklar'alnunk kell egy
v'altoz'ot a k:ovetkez"o m'odon:

extern int network;

A v'altoz'ot az els"o DBC f:uggv'enyh'iv'as el"ott
inicializ'alni kell a k:ovetkez"o m'odon:

network = is_network();

Ez egyr'eszt inicializ'alja a h'al'ozatot - ha az m"uk:odik - a
filekezel"o sz'am'ara, m'asr'eszt a network v'altoz'o jelezni
fogja a filekezel"o sz'am'ara, hogy konkurrens-e a rendszer vagy
sem.

$_A~netwrok~v'altoz'o~haszn'alat'anak~'ertelme:

A v'altoz'o 1-t"ol elt'er"o 'ert'eke azt jeleneti, hogy a
rendszer nem konkurrens rendszer.
Ebben az esetben a lock-ol'o, a lock-ol'ast felold'o, valamint a
buffereket t:orl"o rutinok nem csin'alnak semmit, csak
visszaadj'ak a sikeres m"uvelet k'odj'at.
A bufferek :ur'it'ese az :ur'it"o f:uggv'enyek h'iv'asa eset'en
nem konkurrens rendszerben is megt:ort'enik, mert 'ilyen m'odon
hiba eset'en (~pl. h'al'ozatkimarad'as~) kevesebb inform'aci'o
veszik el.
$pag/15.
$sec.
read_lock
Funkci'oja:

{{{Adatb'azisra olvas'asi lock be'all'it'asa

Form'aja:

$pic/tc.
int read_lock(lockptr)
    LOCK    *lockptr;               /* strukt'ura a h'iv'asok k:oz:otti   */
                                    /* kommunik'aci'ora                */
$eoc.

Megjegyz'es:
A strukt'ura s_name mez"oj'et a h'iv'as el"ott az adatb'azis
adatfile-j'anak nev'evel kell inicializ'alni.
A strukt'ura tartalm'at a lock felold'as'aig meg kell "orizni.

A f:uggv'eny visszat'er'esi 'ert'eke SUCCESS sikeres m"uvelet eset'en.
A d_BUSY visszat'er'esi 'ert'ek azt jelenti, hogy az adatb'azis 'ir'asra
foglalt.
A d_NETERR1 vagy d_NETERR2 visszat'er'esi 'ert'ekek a h'al'ozat hib'aj'at
jelentik.
$pag/15.
$sec.
read_release
Funkci'oja:

{{{Adatb'azis olvas'asi lock-j'anak felold'asa

Form'aja:

$pic/tc.
int read_release(lockptr)
    LOCK    *lockptr;               /* strukt'ura a h'iv'asok k:oz:otti   */
                                    /* kommunik'aci'ora                */
$eoc.

Megjegyz'es:
A f:uggv'eny visszat'er'esi 'ert'eke SUCCESS sikeres m"uvelet eset'en.
A d_LOCKERR visszat'er'esi 'ert'ek azt jelenti, hogy a kommunik'aci'ot
biztos'it'o strukt'ura tartalma megs'er:ult.
$pag/15.
$sec.
write_lock
Funkci'oja:

{{{Adatb'azisra 'ir'asi lock be'all'it'asa

Form'aja:

$pic/tc.
int write_lock(lockptr)
    LOCK    *lockptr;               /* strukt'ura a h'iv'asok k:oz:otti   */
                                    /* kommunik'aci'ora                */
$eoc.

Megjegyz'es:
A strukt'ura s_name mez"oj'et a h'iv'as el"ott az adatb'azis
adatfile-j'anak nev'evel kell inicializ'alni.
A strukt'ura tartalm'at a lock felold'as'aig meg kell "orizni.

A f:uggv'eny visszat'er'esi 'ert'eke SUCCESS sikeres m"uvelet eset'en.
A d_BUSY visszat'er'esi 'ert'ek azt jelenti, hogy az adatb'azis 'ir'asra
foglalt.
A d_NETERR1 visszat'er'esi 'ert'ek a h'al'ozat hib'aj'at jelenti.
$pag/15.
$sec.
write_release
Funkci'oja:

{{{Adatb'azis 'ir'asi lock-j'anak felold'asa

Form'aja:

$pic/tc.
int write_release(lockptr)
    LOCK    *lockptr;               /* strukt'ura a h'iv'asok k:oz:otti   */
                                    /* kommunik'aci'ora                */
$eoc.

Megjegyz'es:
A f:uggv'eny visszat'er'esi 'ert'eke SUCCESS sikeres m"uvelet eset'en.
A d_LOCKERR visszat'er'esi 'ert'ek azt jelenti, hogy a kommunik'aci'ot
biztos'it'o strukt'ura tartalma megs'er:ult.
$pag/15.
$sec.
lock_record
Funkci'oja

{{{Rekord lock-ol'asa

Form'aja:

$pic/tc.
int lock_record(fname,dbfptr,recno)
    char    *fname;                 /* az adatb'azis adatfile-j'anak neve*/
    DBFFILE *dbfptr;                /* adatfile le'ir'o blokk          */
    RECNUM  recno;                  /* a lockoland'o rekord sz'ama     */
$eoc.

Megjegyz'es:
A f:uggv'eny visszat'er'esi 'ert'eke sikeres m"uvelet eset'en SUCCESS.
Az d_LOCKERR visszat'er'esi 'ert'ek azt jelenti, hogy az 'allom'as az
adatfile-b'ol m'ar tart reteszelve rekordot.
A d_BUSY visszat'er'esi 'ert'ek azt jelenti, hogy a rekord foglalt.
$pag/15.
$sec.
release_record
Funkci'oja

{{{Rekord lock felold'asa

Form'aja:

$pic/tc.
int release_record(fname,dbfptr,recno)
    char    *fname;                 /* az adatb'azis adatfile-j'anak neve*/
    DBFFILE *dbfptr;                /* adatfile le'ir'o blokk          */
    RECNUM  recno;                  /* a feloldand'o rekord sz'ama     */
$eoc.

Megjegyz'es:
A f:uggv'eny visszat'er'esi 'ert'eke sikeres m"uvelet eset'en SUCCESS.
Az d_LOCKERR visszat'er'esi 'ert'ek azt jelenti, hogy a rekordot az
'allom'as nem lock-olta.
$pag/15.
$sec.
is_network
Funkci'oja:

{{{Lockol'asi m'od 'all'it'as

Form'aja:

$pic/tc.
int is_network()
$eoc.

Megjegyz'es:
A f:uggv'enyt minden futtathat'o program elej'en egyszer meg kell h'ivni,
k:ul:onben a konkurrnes hozz'af'er'es h'al'ozat eset'en nem fog m"uk:odni.
A f:uggv'eny visszat'er'esi 'ert'eke d_COMPAT, ha a rendszer a
NOVELL NetWare 4.6 verzi'oj'u rendszerrel kompatibilis.
Ez egyben be'all'itja a h'al'ozat lock m'odj'at 'ugy, hogy a DBC
rekord szint"u lockol'asa is helyesen m"uk:odj:on.
Ha a visszat'er'esi 'ert'ek nem d_COMPAT, akkor a rendszer nem kompatibilis !
A NOVELL NetWare 4.6-tal nem kompatibilis rendszereket nem
konkurrens rendszerk'ent kezelj:uk.
$pag/15.
$sec.
init_lock
Funkci'oja:

{{{Kommunik'aci'os v'altoz'o inicializ'al'asa

Form'aja:

$pic/tc.
int init_lock(lockptr,name)
LOCK	*lockptr;		/* mutat'o a kommunik'aci'os v'altoz'ora */
char	*name;			/* az adatb'azis adatfile-j'anak neve */
$eoc.

Megjegyz'es:
Az adatfile nev'en'el c'elszer"u a teljes path specifik'aci'ot
(~server, k:otet, stb~) megadni az egy'ertelm"us'eg
biztos'it'asa v'egett.
Ellenkez"o esetben felesleges v'arakoz'asok fordulhatnak el"o,
de ez hib'at nem okoz.
$pag/15.
$sec.
dBclrbuf
Funkci'oja:

{{{Az adatfile buffer'enek kit:orl'ese

Form'aja:

$pic/tc.
int dBclrbuf(dbffile)
char	*dbffile;		/* az adatfile le'ir'oja		*/
$eoc.

Megjegyz'es:
Adatb'azis szint"u 'ir'asi 'es olvas'asi lock ut'an, a
t'enyleges 'ir'as vagy olvas'as el"ott meg kell h'ivni.
'Igy tudjuk biztos'itani azt, hogy minden olyan inform'aci'o,
mely megv'altozhatott, a lemezr"ol ker:ulj:on beolvas'asra.
$pag/15.
$sec.
dBclibuf
Funkci'oja:

{{{Az indexfile buffer'enek kit:orl'ese

Form'aja:

$pic/tc.
int dBclibuf(ndxfile)
char	*ndxfile;		/* az indexfile le'ir'oja		*/
$eoc.

Megjegyz'es:
Adatb'azis szint"u 'ir'asi 'es olvas'asi lock ut'an, a
t'enyleges 'ir'as vagy olvas'as el"ott meg kell h'ivni.
'Igy tudjuk biztos'itani azt, hogy minden olyan inform'aci'o,
mely megv'altozhatott, a lemezr"ol ker:ulj:on beolvas'asra.
