[<<Previous Entry]
[^^Up^^]
[Next Entry>>]
[Menu]
[About The Guide]
{ wenn ja, so wird versucht, das alte Memo mit dem neuen Eintrag }
{ zu .berschreiben, sonst - oder wenn das neue Memo nicht in den }
{ vom alten Text eingenommenen Bereich pa.t - wird es an die Memo- }
{ Datei angeh.ngt und der neue Memo-Satz-Zeiger in das entsprech- }
{ ende Datenbankfeld zur.ck.bertragen. }
{ ---------------------------------------------------------------- }
{ Der Text (sprich das PChar-Array) wird nicht (!) gel.scht - das }
{ w.rde dem Prinzip der Objektkapselung (Verbot des Ver.nderns / }
{ L.schens von au.erhalb des Objektes liegenden Instanzen) wider- }
{ sprechen. }
{ ---------------------------------------------------------------- }
{ Bei eventuellen Fehlern wird - wie .blich - die Unit "Error" be- }
{ m.ht und False zur.ckgegeben, sonst True. }
{ ---------------------------------------------------------------- }
{ Nachdem es bei Memofeldern auch keine Indices geben kann, werden }
{ diese hier logischerweise auch keinem Update unterzogen. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.ReplaceM (FName : TFeldStr; PC : PChar) :
BOOLEAN;
{ ---------------------------------------------------------------- }
{ L.scht den aktuellen Datensatz - allerdings nur logisch, das }
{ hei.t, es wird nur ein Flag gesetzt und sie k.nnen weiter }
{ gelesen und geschrieben werden und es ist ein Wiederherstellen }
{ mit Recover jederzeit m.glich. Einziger wirklicher Effekt: Die }
{ Methode Deleted liefert f.r diesen Satz True - und mit Pack wird }
{ er dann wirklich auch physikalisch (und damit unwiederbringlich) }
{ gel.scht. }
{ ---------------------------------------------------------------- }
{ Alle f.r die Datenbank momentan aktivierten Indices werden an }
{ die neuen Umst.nde angepa.t, sprich, es wird der Indexeintrag }
{ f.r den aktuellen Datensatz gel.scht. }
{ ---------------------------------------------------------------- }
{ Sollte die Datenbank leer sein oder ein anderer (allgemeiner) }
{ Fehler auftreten, so liefert die Methode False zur.ck und es }
{ wird der Fehlercode in der Unit "Error" gesetzt. }
{ War der Satz schon gel.scht, so wird zwar keine Fehlermeldung }
{ gesetzt, aber es passiert auch nichts. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.DELETE : BOOLEAN;
{ ---------------------------------------------------------------- }
{ Stellt einen zuvor gel.schten Datensatz wieder her. N.here Be- }
{ schreibung des Verfahrens bei "Delete". }
{ ---------------------------------------------------------------- }
{ Sollte die Datenbank leer sein oder ein anderer (allgemeiner) }
{ Fehler auftreten, so liefert die Methode False zur.ck und es }
{ wird der Fehlercode in der Unit "Error" gesetzt. }
{ War der Satz gar nicht gel.scht, so wird zwar keine Fehler- }
{ meldung gesetzt, aber es passiert auch nichts. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.Recover : BOOLEAN;
{ ---------------------------------------------------------------- }
{ Gibt True zur.ck, wenn der aktuelle Datensatz als gel.scht }
{ markiert ist, sonst False. N.here Beschreibung des Verfahrens }
{ bei "Delete". }
{ ---------------------------------------------------------------- }
{ Sollte die Datenbank leer sein oder ein anderer (allgemeiner) }
{ Fehler auftreten, so liefert die Methode als Defaultwert False }
{ zur.ck und es wird der Fehlercode in der Unit "Error" gesetzt. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.Deleted : BOOLEAN;
{ ---------------------------------------------------------------- }
{ Liefert - zur Erleichterung der Analyse unbekannter Datenbanken -}
{ die Anzahl der Felder zur.ck. }
{ ---------------------------------------------------------------- }
{ Sollte ein Fehler auftreten, so wird - wie immer - die Unit }
{ "Error" bem.ht und 0 zur.ckgegeben. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.AnzahlFelder : BYTE;
{ ---------------------------------------------------------------- }
{ Liefert - zur Erleichterung der Analyse unbekannter Datenbanken -}
{ die Bezeichnung des angegebenen Feldes zur.ck. }
{ ---------------------------------------------------------------- }
{ Sollte ein Fehler auftreten, so wird - wie immer - die Unit }
{ "Error" bem.ht und ein Leerstring zur.ckgegeben. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.FeldName (Nr : BYTE) : TFeldStr;
{ ---------------------------------------------------------------- }
{ Liefert die Nummer des Feldes mit der angegebenen Nummer zur.ck. }
{ ---------------------------------------------------------------- }
{ Sollte ein Fehler auftreten, so wird - wie immer - die Unit }
{ "Error" bem.ht und 0 zur.ckgegeben. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.FeldNummer (FName : TFeldStr) : BYTE;
{ ---------------------------------------------------------------- }
{ Liefert - zur Erleichterung der Analyse unbekannter Datenbanken -}
{ den Typ des angegebenen Feldes ('C', 'N', 'L' oder 'D') und }
{ seine Gr..e - sowie, wenn es sich um ein numerisches Feld }
{ handelt, die Anzahl der Nachkommastellen - zur.ck. }
{ ---------------------------------------------------------------- }
{ Sollte ein Fehler auftreten, so wird - wie immer - die Unit }
{ "Error" bem.ht und False zur.ckgeliefert, sonst True. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.FeldTyp (FName : TFeldStr; VAR Typ : CHAR;
VAR Size, NK : BYTE) : BOOLEAN;
{ ---------------------------------------------------------------- }
{ Gibt True zur.ck, wenn die Datenbank ein oder mehrere Memofelder }
{ enth.lt, sonst False. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.coNtainsMemos : BOOLEAN;
{ ---------------------------------------------------------------- }
{ Gibt die (reelle) Gr..e eines Datensatzes auf Festplatte zur.ck. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.RecordSize : LONGINT;
{ ---------------------------------------------------------------- }
{ Gibt die Gr..e des Dateiheaders in Byte zur.ck. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.HeaderSize : LONGINT;
{ ---------------------------------------------------------------- }
{ Gibt die Gr..e der gesamten Datenbankdatei in Byte zur.ck. }
{ Die omin.sen zwei Byte sind die Dateiendekennung von dBase (n.m- }
{ lich #13/#26 = $0D/$1a = CR/EOF). }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.FILESIZE : LONGINT;
{ ---------------------------------------------------------------- }
{ Wann wurde die Datenbank zuletzt - also vor dem momentanen Ver- }
{ wenden - modifiziert bzw., wenn leer, wann wurde sie erzeugt ? }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.LastUpDate (VAR Date : TDate) : BOOLEAN;
{ ---------------------------------------------------------------- }
{ Wurde die Datenbank schon ver.ndert ? }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.IsModified : BOOLEAN;
{ ---------------------------------------------------------------- }
{ Gibt die Nummer der dBase-Version, mit der die Datenbankdatei }
{ erstellt wurde, zur.ck. TDB selbst gibt sich immer als Version }
{ III zu erkennen; m.gliche Werte sind 2, 3 oder 4. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.DbVersion : BYTE;
{ ---------------------------------------------------------------- }
{ Liefert den Namen der Datenbankdatei - inklusive Laufwerk und }
{ Pfad - zur.ck. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.FileName : PATHSTR;
{ ---------------------------------------------------------------- }
{ Legt einen Index auf das Feld mit dem angegebenen Namen. Idx ist }
{ dabei ein Objekt des Typs TIndex (oder davon abgeleitet) und mu. }
{ bereits initialisiert sein, gel.scht wird es automatisch beim }
{ Schlie.en der Datenbank. }
{ ---------------------------------------------------------------- }
{ TDB sieht maximal einen Index pro Datenbank-Feld vor (sonst wei. }
{ man ja nicht, welchen man nehmen soll); dieser kann allerdings }
{ (fast) beliebig aufgebaut sein. }
{ ---------------------------------------------------------------- }
{ Der hier gesetzte Index wird automatisch als Prim.rindex ver- }
{ wendet (d.h., wenn mehrere Indices gesetzt werden, so ist der }
{ zuletzt deklarierte der Prim.rindex !!!) und es erfolgt ein Auf- }
{ ruf von "First". }
{ ---------------------------------------------------------------- }
{ Sollte ein Fehler auftreten, so wird - wie immer - die Unit }
{ "Error" bem.ht und False zur.ckgeliefert, sonst True. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.IndexOn (FName : TFeldStr; Idx : PIndex) :
BOOLEAN;
{ ---------------------------------------------------------------- }
{ Vereinfachung der standardm..igen Indizierung von Feldern; es }
{ ist nicht mehr notwendig, zuerst das Indexobjekt (mit haufenwei- }
{ seweise Parametern) zu initialisieren und dann den Index einzu- }
{ f.gen, sondern es reicht, hier den Namen der Indexdatei und das }
{ zu indizierende Feld anzugeben. }
{ Es wird zuerst untersucht, ob die Indexdatei mit dem angegebenen }
{ Namen schon existiert, dann wird das Objekt entweder mit "Use" }
{ oder mit "Create" erzeugt und f.r das angegebene Feld eingef.gt. }
{ ---------------------------------------------------------------- }
{ Sollte die Angabe des Dateinamens ein Leerstring sein, so wird }
This page created by ng2html v1.05, the Norton guide to HTML conversion utility.
Written by Dave Pearson