[<<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