[<<Previous Entry]
[^^Up^^]
[Next Entry>>]
[Menu]
[About The Guide]
{ sein, so wird bei einem Replace zuerst .berpr.ft, ob der neue }
{ Inhalt auch wirklich unterschiedlich ist vom alten; wenn ja, so }
{ wird automatisch auch die Indexdatei aktualisiert. }
{ Dies gilt auch f.r Memofelder, denn schlie.lich k.nnte ja }
{ jemand auf die Idee kommen, einen (zusammengesetzten) Index aus }
{ "Platzmangel" auf ein Memofeld zu legen. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.Replace (FName : TFeldStr; Inhalt : STRING) :
BOOLEAN;
{ ---------------------------------------------------------------- }
{ Liest aus dem aktuellen Datensatz das Feld mit dem angegebenen }
{ Namen - sofern es sich dabei wirklich um ein numerisches Feld }
{ ohne Nachkommastellen handelt, was nat.rlich zuerst .berpr.ft }
{ wird. }
{ ---------------------------------------------------------------- }
{ Bei einem ung.ltigen Feldtyp wird der entsprechende Fehler in }
{ "Error" gesetzt und 0 zur.ckgegeben. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.ReadL (FName : TFeldStr) : LONGINT;
{ ---------------------------------------------------------------- }
{ Liest aus dem aktuellen Datensatz das Feld mit dem angegebenen }
{ Namen - sofern es sich dabei wirklich um ein numerisches Feld }
{ (mit oder ohne Nachkommastellen) handelt, was nat.rlich zuerst }
{ .berpr.ft wird. }
{ ---------------------------------------------------------------- }
{ Bei einem ung.ltigen Feldtyp wird der entsprechende Fehler in }
{ "Error" gesetzt und 0 zur.ckgegeben. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.ReadR (FName : TFeldStr) : REAL;
{ ---------------------------------------------------------------- }
{ Liest aus dem aktuellen Datensatz das Feld mit dem angegebenen }
{ Namen - sofern es sich dabei wirklich um ein Datumsfeld handelt, }
{ was nat.rlich zuerst .berpr.ft wird. }
{ ---------------------------------------------------------------- }
{ Der Typ des angegebenen Records stammt aus ADatum - woher auch }
{ die Scanner-Prozeduren f.r Datumsangaben kommen. Als Alternative }
{ steht "ReadD_" zur Verf.gung, das einen String mit dem (bereits }
{ formatierten) Datum zur.ckgibt. }
{ ---------------------------------------------------------------- }
{ Bei einem ung.ltigen Feldtyp wird der entsprechende Fehler in }
{ "Error" gesetzt und False zur.ckgegeben und der Datums-Record }
{ enth.lt das aktuelle Datum (sofern richtig gesetzt). }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.ReadD (FName : TFeldStr; VAR D : TDate) :
BOOLEAN;
{ ---------------------------------------------------------------- }
{ Liest aus dem aktuellen Datensatz das Feld mit dem angegebenen }
{ Namen - sofern es sich dabei wirklich um ein Datumsfeld handelt, }
{ was nat.rlich zuerst .berpr.ft wird. }
{ ---------------------------------------------------------------- }
{ Die Form des dabei zur.ckgegebenen Datum-Strings ist dabei }
{ "TT.MM.JJJJ", wobei nicht vorhandene Ziffern durch Leerzeichen }
{ ersetzt werden. }
{ ---------------------------------------------------------------- }
{ Bei einem ung.ltigen Feldtyp wird der entsprechende Fehler in }
{ "Error" gesetzt und ein Leerstring zur.ckgegeben. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.ReadD_ (FName : TFeldStr) : STRING;
{ ---------------------------------------------------------------- }
{ Liest aus dem aktuellen Datensatz das Feld mit dem angegebenen }
{ Namen - sofern es sich dabei wirklich um ein logisches Feld }
{ handelt, was nat.rlich zuerst .berpr.ft wird. }
{ ---------------------------------------------------------------- }
{ Bei einem ung.ltigen Feldtyp wird der entsprechende Fehler in }
{ "Error" gesetzt und False zur.ckgegeben. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.ReadB (FName : TFeldStr) : BOOLEAN;
{ ---------------------------------------------------------------- }
{ Holt aus dem angegebenen Feld der Datenbank - sofern dieses auch }
{ wirklich ein Memofeld ist - die Memo-Nummer. Ist diese defi- }
{ niert, so wird aus der Memodatei das entsprechende Memo gelesen }
{ und zur.ckgegeben (PChar wird dabei automatisch initialisiert); }
{ sollte kein zugeh.riges Memo existieren, so wird ebenfalls Nil }
{ zur.ckgegeben. }
{ ---------------------------------------------------------------- }
{ Bei eventuellen Fehlern wird - wie .blich - die Unit "Error" be- }
{ m.ht und der PChar nicht (!) initialisiert (R.ckgabewert Nil). }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.ReadM (FName : TFeldStr) : PChar;
{ ---------------------------------------------------------------- }
{ Setzt im aktuellen Datensatz das Feld mit dem angegebenen Namen }
{ auf den .bergegebenen Wert - sofern es sich dabei wirklich um }
{ ein numerisches Feld ohne Nachkommastellen handelt, was nat.r- }
{ lich zuerst .berpr.ft wird. }
{ Ebenfalls wird der Wert selbst .berpr.ft: Pa.t er .berhaupt in }
{ das angegebene Feld, enth.lt er ung.ltige Zeichen etc. }
{ ---------------------------------------------------------------- }
{ Bei einem ung.ltigen Feldtyp oder einem nicht g.ltigen Datum }
{ (Einzahl von Daten ...) wird der entsprechende Fehler in "Error" }
{ gesetzt, aber trotzdem versucht einen "m.glichst richtigen" Wert }
{ in die Datenbank zu schreiben. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.ReplaceL (FName : TFeldStr; L : LONGINT) :
BOOLEAN;
{ ---------------------------------------------------------------- }
{ Setzt im aktuellen Datensatz das Feld mit dem angegebenen Namen }
{ auf den .bergegebenen Wert - sofern es sich dabei wirklich um }
{ ein numerisches Feld mit Nachkommastellen handelt, was nat.r- }
{ lich zuerst .berpr.ft wird. }
{ Ebenfalls wird der Wert selbst .berpr.ft: Pa.t er .berhaupt in }
{ das angegebene Feld, enth.lt er ung.ltige Zeichen etc. }
{ ---------------------------------------------------------------- }
{ Bei einem ung.ltigen Feldtyp oder einem nicht g.ltigen Datum }
{ (Einzahl von Daten ...) wird der entsprechende Fehler in "Error" }
{ gesetzt, aber trotzdem versucht einen "m.glichst richtigen" Wert }
{ in die Datenbank zu schreiben. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.ReplaceR (FName : TFeldStr; R : REAL) : BOOLEAN;
{ ---------------------------------------------------------------- }
{ Setzt im aktuellen Datensatz das Feld mit dem angegebenen Namen }
{ auf den .bergegebenen Wert - sofern es sich dabei wirklich um }
{ ein Datumsfeld handelt, was nat.rlich zuerst .berpr.ft wird. }
{ Ebenfalls wird der Wert selbst .berpr.ft: Pa.t er .berhaupt in }
{ das angegebene Feld, enth.lt er ung.ltige Zeichen etc. }
{ ---------------------------------------------------------------- }
{ Bei einem ung.ltigen Feldtyp oder einem nicht g.ltigen Datum }
{ (Einzahl von Daten ...) wird der entsprechende Fehler in "Error" }
{ gesetzt, aber trotzdem versucht einen "m.glichst richtigen" Wert }
{ in die Datenbank zu schreiben. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.ReplaceD (FName : TFeldStr; D : TDate) :
BOOLEAN;
{ ---------------------------------------------------------------- }
{ Setzt im aktuellen Datensatz das Feld mit dem angegebenen Namen }
{ auf den .bergegebenen Wert - sofern es sich dabei wirklich um }
{ ein Datumsfeld handelt, was nat.rlich zuerst .berpr.ft wird. }
{ Ebenfalls wird der Wert selbst .berpr.ft: Pa.t er .berhaupt in }
{ das angegebene Feld, enth.lt er ung.ltige Zeichen etc. }
{ ---------------------------------------------------------------- }
{ Bei einem ung.ltigen Feldtyp oder einem nicht g.ltigen Datum }
{ (Einzahl von Daten ...) wird der entsprechende Fehler in "Error" }
{ gesetzt, aber trotzdem versucht einen "m.glichst richtigen" Wert }
{ in die Datenbank zu schreiben. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.ReplaceD_ (FName : TFeldStr; D : STRING) :
BOOLEAN;
{ ---------------------------------------------------------------- }
{ Setzt im aktuellen Datensatz das Feld mit dem angegebenen Namen }
{ auf den .bergegebenen Wert - sofern es sich dabei wirklich um }
{ ein logisches Feld handelt, was nat.rlich zuerst .berpr.ft wird. }
{ Ebenfalls wird der Wert selbst .berpr.ft: Pa.t er .berhaupt in }
{ das angegebene Feld, enth.lt er ung.ltige Zeichen etc. }
{ ---------------------------------------------------------------- }
{ Als "True" gelten dabei die Zeichen [t, T, j, J, y, Y, m, M], }
{ als False alles andere. }
{ ---------------------------------------------------------------- }
{ Bei einem ung.ltigen Feldtyp oder einem nicht g.ltigen Datum }
{ (Einzahl von Daten ...) wird der entsprechende Fehler in "Error" }
{ gesetzt, aber trotzdem versucht einen "m.glichst richtigen" Wert }
{ in die Datenbank zu schreiben. }
{ ---------------------------------------------------------------- }
{ Sollte mittels "IndexOn" ein Index auf dieses Feld gelegt worden }
{ sein, so wird bei einem Replace zuerst .berpr.ft, ob der neue }
{ Inhalt auch wirklich unterschiedlich ist vom alten; wenn ja, so }
{ wird automatisch auch die Indexdatei aktualisiert. }
{ ---------------------------------------------------------------- }
FUNCTION TDataBase.ReplaceB (FName : TFeldStr; B : BOOLEAN) :
BOOLEAN;
{ ---------------------------------------------------------------- }
{ .berpr.ft, ob das angegebene Feld wirklich ein Memofeld ist und }
{ die dort gespeicherte Zahl ein existierender Memoeintrag ist; }
This page created by ng2html v1.05, the Norton guide to HTML conversion utility.
Written by Dave Pearson