C!T ROM 2/ctrom_ii_b.zip/ctrom_ii_b/PROGRAM/BASIC/QBDBAS/TEST.DBT

dBase/FoxBase/XBase Database File | 1991-10-21 | 16KB | 373 lines

Dit is een memo.
Een memo wordt opgeslagen in een afzonderlijk bestand. Dat
bestand heeft dezelfde naam als de database file, echter met de
extensie .DBT Een memo bevat maximaal 4000 tekens en wordt in de
.DBT file opgeslagen in blokken van 512 bytes. In de database
.DBF file staat in het memo-veld een pointer naar het
bijbehorende blok in het memo-bestand...
Jan Jansen is een wereldberoemde wielrenner. In zijn vrije tijd
programmeert hij graag in QuickBasic.
Natuurlijk gebruikt hij TurboFlow! daarbij voor meer inzicht en
overzicht!
Hij is gespecialiseerd in grafische toepassingen en heeft
programma's geschreven waarmee de Tour de France op scherm te
volgen is.
bijbehorende blok in het memo-bestand...
Brainstorm is een BBS dat gespecialiseerd is in gereedschap voor
programmeurs. Naast een algemeen Quick Basic gebied, waarin
uitstekende Libraries voor zeer veel toepassingen zijn opgenomen,
verzorgen BLOKKER+BLOKKER een eigen "area" waarin Quick Basic
programma's in BRONCODE zijn opgenomen. Profiteer hiervan !
Het BBS is geopend van 0.00 uur 's nachts tot 12.00 uur 's
middags.
Bill Gates is dol op Quick Basic, dat is bekend. De volgende
anecdote doet de ronde:
Als programmeurs bij hem komen met het zoveelste verzoek om
uitstel van de oplevering van een groot programma in C of
Assembler dan dreigt hij met:
 "Als jullie het niet kunnen, dan doe ik het zelf wel even in het
 week-end, met BASIC !"
eopend van 0.00 uur 's nachts tot 12.00 uur 's
middags.
Dit is een memo.
Zoals u aan de omvang van het TEST.TBT bestand kunt zien, springt
dBaseIII niet bepaald zuinig met uw kostbare diskruimte om!
uitstel van de oplevering van een groot programma in C of
Assembler dan dreigt hij met:
 "Als jullie het niet kunnen, dan doe ik het zelf wel even in het
 week-end, met BASIC !"
eopend van 0.00 uur 's nachts tot 12.00 uur 's
middags.
Dit is een memo dat hoort bij een record, dat later ge-delete
werd.
n, springt
dBaseIII niet bepaald zuinig met uw kostbare diskruimte om!
uitstel van de oplevering van een groot programma in C of
Assembler dan dreigt hij met:
 "Als jullie het niet kunnen, dan doe ik het zelf wel even in het
 week-end, met BASIC !"
eopend van 0.00 uur 's nachts tot 12.00 uur 's
middags.
 DEMONSTRATIE PROGRAMMA QBDBASE.BAS versie 1.1
 LEES en bewerk dBaseIII en dBaseIV BESTANDEN met QuickBasic 4.5
 ----------------------------------------------------------------
 -------
 Start QuickBasic met: QB QBDBASE /AH /G /LQB.QLB
                  ===============
 ----------------------------------------------------------------
 -------
 Doel:    Het lezen van dBase III en IV data- en memofiles.
 Werking: Dit voorbeeld programma toont eerst de header structuur
      en daarna de records van een dBase file op het scherm.

      Als in de lay-out van een record ook een "memo" veld is
      opgenomen, dan wordt ook de inhoud van het memo
      getoond.
      De memo velden zijn opgeslagen in een bestand met
      dezelfde naam
      als het database bestand, echter met de extensie .DBT

      Deze routines kunnen worden gebruikt om de records van
      een dBase
      bestand in uw eigen database programma binnen te halen
      en verder
      te bewerken.

     ->   Het rechtstreeks wijzigen van een dBase bestand is
     natuurlijk
     ->   ook mogelijk; pas echter op met het veranderen van de
     sleutel-
     ->   velden van een dBase bestand. Eventueel reeds aanwezige
     indexen
     ->   kunnen daardoor corrupt worden.
 De structuur van een dBase bestand.
 --------------------------------------
 Het databestand.
 ----------------
 Het eerste gedeelte van een dBase bestand wordt de "header"
 genoemd.
 Dit gedeelte bevat onder andere informatie over het dBase versie
 nummer,
 de lengte van het headergedeelte en beschrijvingen van de
 velden. Het is
 verdeeld in blokken van 32 bytes.
 HEADER LAY-OUT.
 ---------------
 Het eerste blok van 32 bytes bevat de volgende informatie:
   Versienummer             -  1 byte
   Laatste datum bijgewerkt -  3 bytes (jaaar/maand/dag)
   Aantal records           -  4 bytes (LONG INTEGER)
   Lengte van de header     -  2 bytes (INTEGER)
   RecordLengte             -  2 bytes (INTEGER)
   Rest                     - 20 bytes
                 ---------
             TOTAAL : 32 bytes
 Versienummer.
 -------------
 De eerste byte geeft aan met welke versie van dBase het bestand
 aangemaakt en of er wel of geen memovelden aanwezig zijn.
 Hex  Decimaal  Betekenins.
 ---  --------  -------------------------------------------
 &H3      3     dBase III bestand zonder memo velden.
 &H83   131     dBase III bestand met memovelden.
 &H63    99     dBase IV  bestand zonder memovelden.
 &H8B   139     dBase IV  bestand met memo velden.
 N.B. Als deze byte aangeeft dat er memovelden zijn, dan dient er
      een .DBT bestand aanwezig te zijn, waarin die memo's zijn
      opgeslagen.
      Neem echter niet zo maar aan, dat dit .DBT bestand aanwezig
      is,
      voer eerst een kontrole uit met de funktie
      "BestandAanwezig".
 Laatste datum bijgewerkt.
 -------------------------
 De datum waarop de database het laatste is bijgewerkt staat in 3
 bytes.
 De Ascii waarden staan in de volgorde jaar/maand/dag.
 Aantal records.
 ---------------
 Het totale aantal records is opgeslagen als LONG INTEGER.
 Lengte van de header.
 ---------------------
 Omdat een database meer of minder velden kan bevatten, is de
 lengte van
 de header variabel. Deze lengte is opgeslagen als INTEGER.
 RecordLengte.
 -------------
 Alle records in een dBase bestand hebben een vaste lengte. De
 waarde
 hiervan staat in de header als INTEGER.
 Rest.
 -----
 De "rest" van 20 bytes wordt in dit programma niet gebruikt.
 Dit eerste blok van 32 bytes wordt in het programma gedefineerd
 in een
 TYPE record variabele met de naam dbHeader.
 RECORD LAYOUT.
 --------------
 Elk volgende blok van 32 bytes bevat de veldbeschrijving van een
 record.
   Veldnaam                 - 11 bytes
   VeldType                 -  1 byte
   DataAdres                -  4 bytes
   VeldLengte               -  1 byte
   Aantal decimalen         -  1 byte
   Rest                     - 14 bytes
                  --------
             TOTAAL   32 bytes
 Veldnaam.
 ---------
 De naam die de gebruiker aan een veld heeft gegeven. De naam
 wordt
 afgesloten met CHR$(0). Een veldnaam mag alleen letters, cijfers
 of "_"
 bevatten.
 Veldtype.
 ---------
 Deze byte kan de volgende inhoud hebben:
   C - Character - alfa/numeriek - veld bevat uitsluitned tekst.
   N - Numeric   - numeriek      - veld bevat een getal
   D - Date      - datum         - veld bevat een datum JJJJMMDD
   L - Logical   - logisch veld  - veld bevat T/F of Y/N; waar of
   niet waar.
   M - Memo      - aantekeningen - Memo aanwezig in *.DBT
   bestand.
 Data adres.
 -----------
 Dit veld bevat de veld offset in memory. Het veld wordt in dit
 programma niet gebruikt.
 Veld lengte.
 ------------
 De Ascii waarde is de lengte van het veld. Voor een Numeriek
 veld is
 het de lengte, inclusief de decimale punt.
 Aantal decimalen.
 -----------------
 De Ascii waarde is het aantal decimalen van een decimaal veld.
 Rest.
 -----
 De "rest" van 14 bytes wordt in dit programma niet gebruikt.
 AANTAL VELDEN.
 --------------
 Het aantal gedefinieerde velden is gelijk aan de lengte van de
 header
 gedeeld door 32. De uitkomst moet met 1 worden verminderd, omdat
 eerste blok van 32 bytes de header omschrijving bevat.
   AantalVelden% = (Header.HeaderLengte \ 32) - 1
 WERKELIJKE RECORDLENGTE.
 ------------------------
 Als dit programma wordt gestart, dan verschijnt eerst een
 overzicht
 met de gegevens uit de header en vervolgens de veld
 beschrijvingen.
 Als u de lengten van elk veld bij elkaar optelt, dat zult u
 merken, dat
 de som van de veldlengten steeds 1 byte minder is dan de
 recordlengte
 die in de header informatie staat.
 Die extra byte wordt steeds vooraan in elk record geplaatst en
 geeft aan
 of een record geldig is of niet. Als de gebruiker een record
 heeft gedelete,
 dan wordt in dat veld een "*" teken geplaatst.
 DE RECORDS.
 -----------
 Na het header gedeelte met algemene- en veldinformatie worden de
 records
 geplaatst. Daarbij is de volgende informatie van belang.
   STATUS VELD   - De eerste positie van elk record geeft de
   status van het
           record weer. Indien het veld gevuld is met een
           "*" dan
           is het record ongeldig gemaakt.
   TEKST VELD    - Een tekst wordt aangevuld met spaties tot het
   einde
           van het veld.
   NUMERIEK VELD - Een numeriek veld is een getal of een bedrag.
   In het
           record wordt het precies zo weggeschreven als
           het
           op het scherm wordt ingevoerd. Let op de
           deciamle punt.
           Uit de header informatie kan worden afgeleid
           met hoeveel
           decimalen moet worden gewerkt. Vertaal een
           veld met
              N! = VAL(Veld$) of met N# = VAL(Veld$)
           naar een singel of double precision numerieke
           variabele.
           Als het aantal decimalen nul is, dan kan -
           afhankelijk
           van de lengte van het veld - een omzetting
           naar een
           integer of long integer plaatsvinden met :
              N% = VAL(Veld$) of met N& = VAL(Veld$)
   DATUM VELD    - Een datum veld is altijd 8 bytes lang. De
   datum wordt
           op disk opgeslagen in het formaat JJJJMMDD.
           Dus 31 december
           1991 wordt als 19911231 in het record
           geplaatst.
   LOGISCH VELD  - Dit veld kan "Y" of "T" bevatten. in beide
   gevallen
           is de betekenis "Ja", "Waar" of True. Het is
           een Boolean
           waarde. Als er iets anders dan "T" of "Y" is
           vermeld,
           dan is de betekenis "Nee", "Niet waar" cq
           "False".
           Als u een INTEGER de waarde -1 = True of 0 =
           False wilt
           geven, doe dat dan als volgt:
           IF INSTR("YT",LogischVeld$) > 0 THEN
             Betaald% = -1
           ELSE
             Betaald% = 0
           END IF
   MEMO VELD     - In het record zelf is de veldlengte van een
   memo altijd
           10 bytes. Als er bij een record ook
           daadwerkelijk
           aantekeningen in een memo zijn gemaakt, dan
           bevat dat veld
           een getal. Ook dit getal staat in een STRING
           formaat en kan
           met de funktie Pointer& = VAL(Veld$) naar een
           LONG INTEGER
           variabele worden overgezet. Dit getal wijst
           naar een blok
           tekst in een .DBT bestand, dat door dBase zelf
           wordt aangemaakt.
 MEMO BESTAND
 ------------
 Als in de structuur van een record een Memo veld is
 gedefinieerd, dan wordt
 de eerste keer, dat er daadwerkelijk een aantekening gemaakt
 wordt, een
 nieuw bestand aangemaakt. Dat bestand krijgt dezelfde naam als
 het data-
 base bestand, echter met de extensie .DBT.
 In dat bestand worden de aantekeningen geplaatst IN BLOKKEN VAN
 512 BYTES.
 De memo-pointer in het database record wijst naar het blok
 waarin een stuk
 memotekst start. Daarbij wordt het eerste blok van 512 bytes
 door dBase
 zelf gebruikt. Als een memo-pointer de waarde "1" bevat dan
 start de memo-
 tekst op de 513e byte - dus het 2e blok - in het .DBT bestand.
 De memo-
 pointer moet dus met 1 worden verhoogd om het juiste blok te
 berekenen.
 De formule is dan ook : Startbyte = (MemoPointer * 512) + 1.
 dBase III plaatst vanaf StartByte de memo tekst. Het einde van
 de tekst
 wordt aangegeven met &H1A &H1A. De tekst kan dus eenvoudig in
 blokken
 van 512 bytes worden binnen gehaald, waarbij er steeds op getest
 moet worden
 of die twee "einde tekst" bytes 1A 1A in de string voorkomen.
 Een memo-tekst in dBase III is maximaal 4000 bytes lang. Dat is
 tevens het
 maximale aantal bytes dat met de dBase III tekstverwerker MODIFY
 COMMAND
 kan worden bewerkt.
 dBase IV behandelt de memo-teksten in het .DBT bestand op een
 andere manier.
 De eerste 8 bytes van het startblok zijn gereserveerd. De bytes
 1 t/m 4
 bevatten FF FF 00 08 hex. De volgende 4 bytes bevatten de lengte
 van de
 memotekst als LONG INTEGER. De memotekst zelf start op de 9e
 byte.
 Als uw programma heeft geconstateerd, dat er sprake is van een
 dBase IV
 bestand, dan moet na het inlezen van het eerste blok tekst van
 512 bytes
 dus gekontroleerd worden of de eerste twee bytes FF FF hex
 bevatten.
 Is dat het geval, dan moeten byte 5 t/m 8 omgezet worden naar
 een LONG
 INTEGER waarde, die de tekstlengte aangeeft. De tekst begint dan
 vanaf
 byte 9.
 Maar helaas... daarmee zijn we er nog niet. dBase IV bewerkt
 zonder
 problemen database bestanden, die met dBase III zijn aangemaakt.
 En ook
 de bijbehorende .DBT memobestanden worden probleemloos
 behandeld. Maar
 het kan zijn, dat een .DBT memobestand, dat onder dBase III is
 aangemaakt
 nog niet door dBase IV is behandeld. Dan kan het voorkomen, dat
 het data-
 base bestand wel al naar dBase IV formaat is omgezet, maar het
 erbij horende
 .DBT memobestand nog het oude dBase III formaat heeft.
 Om het nog erger te maken: Als met dBase IV een memobestand
 wordt bewerkt
 dat onder dBase III is aangemaakt, dan zal dBase IV elk
 gewijzigde memo
 in het nieuwe formaat met FFh FFh aan het begin ervan
 wegschrijven. Zo
 kan het dus gebeuren, dat in een en hetzelfde .DBT bestand
 memo's voor-
 komen met zowel het oude als het nieuwe formaat!
 Dit probleem is simpel op te lossen. Tijdens het inlezen van het
 eerste
 blok memotekst moet worden gekontroleerd of de eerste twee
 posities de
 tekens FF FF hex bevatten. Is dat het geval, dan heeft ook de
 memo het
 dBase IV formaat en de tekstlengte staat in byte 5 t/m 9. Zo
 niet, dan
 heeft de memo nog het oude formaat en start op byte 1. Er moet
 dan
 worden gezocht naar de opeenvolgende tekens 1A 1A hex om de
 lengte van
 de mometekst te kunnen bepalen.
                -o-o-o-o-o-
eem is simpel op te lossen. Tijdens het inlezen van het
 eerste
 blok memotekst moet worden gekontroleerd of de eerste twe