{ ---------------------------------------------------------------- }

   FUNCTION TDataBase.Go (P : LONGINT) : BOOLEAN;


 { ---------------------------------------------------------------- }
 { Setzt den Datensatzzeiger auf den angegebenen Datensatz - sofern }
 { vorhanden. Es wird eine Bereichs.berpr.fung vorgenommen, die     }
 { False zur.ckgibt, wenn nicht positioniert werden konnte.         }
 { ---------------------------------------------------------------- }
 { Sollte die Datenbank indiziert sein (PrimeIdx <> Nil), so wird   }
 { auf den Datensatz gesprungen, der in der Indexordnung (!) an     }
 { der p-ten Stelle steht.                                          }
 { ---------------------------------------------------------------- }
 { Bei "IdxGo" wird auf den angegebenen Satz - unabh.ngig vom "Set- }
 { Deleted"-Flag - auch dann positioniert, wenn dieser gel.scht     }
 { ist !                                                            }
 { ---------------------------------------------------------------- }
 { Das Gegenst.ck zu "IdxGo" ist "IdxRecNo", das die (logische)     }
 { Position des Satzzeigers gem.. Indexreihenfolge zur.ckgibt.      }
 { ---------------------------------------------------------------- }
 { Aus Performance-Gr.nden sollte auf "IdxGo" - ebenso auf "Go" -   }
 { in indizierten Datenbanken verzichtet werden zugunsten von Skip. }
 { Eine entsprechende Konzeption ist bereits in der Analyse / im    }
 { Entwurf von N.ten und sollte keineswegs der Bequemlichkeit hal-  }
 { ber .bergangen werden !                                          }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.IdxGo (P : LONGINT) : BOOLEAN;


 { ---------------------------------------------------------------- }
 { Bewegt den Satzzeiger auf die durch "Rel" relativ zur aktuellen  }
 { Stelle angegebene Position.                                      }
 { Ist ein Prim.rindex definiert (Instanz "PrimeIdx"), so wird die  }
 { Verschiebung gem.. der Indexreihenfolge durchgef.hrt.            }
 { ---------------------------------------------------------------- }
 { Der R.ckgabewert ist True, wenn ein Skip (0) ausgef.hrt oder bei }
 { einem "richtigen" Skip das Dateiende nicht erreicht wurde; sonst }
 { Dateiende erreicht) oder wenn ein Fehler auftrat wird das Resul- }
 { tat False.                                                       }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.Skip (Rel : LONGINT) : BOOLEAN;


 { ---------------------------------------------------------------- }
 { Setzt den Datensatzzeiger auf den n.chsten Datensatz - sofern    }
 { vorhanden. Es wird eine Bereichs.berpr.fung vorgenommen, die     }
 { False zur.ckgibt, wenn nicht positioniert werden konnte.         }
 { Wenn das Ende der Datenbank erreicht wird, so wird das EOF-Flag  }
 { gesetzt.                                                         }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.MOVE : BOOLEAN;


 { ---------------------------------------------------------------- }
 { Setzt den Datensatzzeiger auf den vorherigen Datensatz - sofern  }
 { vorhanden. Es wird eine Bereichs.berpr.fung vorgenommen, die     }
 { False zur.ckgibt, wenn nicht positioniert werden konnte.         }
 { Wenn der Anfang der Datenbank erreicht wird, so wird das BOF-    }
 { Flag gesetzt.                                                    }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.DeMove : BOOLEAN;


 { ---------------------------------------------------------------- }
 { Wenn State = Off gesetzt wird, so werden bei First, Last und     }
 { Skip auch alle gel.schten Datens.tze angezeigt (sprich nicht     }
 { unterdr.ckt; darum Off); sonst eben nicht (On = unterdr.cke ge-  }
 { gel.schte Datens.tze).                                           }
 { ---------------------------------------------------------------- }
 { Defaultwert ist "On" !!!                                         }
 { ---------------------------------------------------------------- }
 { Nach dem Setzen des Flags wird "First" aufgerufen, um einen      }
 { definierten Zustand herzustellen; der R.ckgabewert ist bei er-   }
 { folgreicher Ausf.hrung True, sonst False.                        }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.SetDeleted (State : BOOLEAN) : BOOLEAN;


 { ---------------------------------------------------------------- }
 { Setzt den Datensatzzeiger auf den ersten Datensatz - sofern      }
 { .berhaupt Daten vorhanden sind. Es wird das BOF-Flag gesetzt.    }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.First : BOOLEAN;


 { ---------------------------------------------------------------- }
 { Setzt den Datensatzzeiger auf den letzten Datensatz - sofern     }
 { .berhaupt Daten vorhanden sind. Es wird das EOF-Flag gesetzt.    }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.Last : BOOLEAN;


 { ---------------------------------------------------------------- }
 { Gibt True zur.ck, wenn das Ende der Datenbank erreicht wurde -   }
 { oder wenn diese leer ist.                                        }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.EOF : BOOLEAN;


 { ---------------------------------------------------------------- }
 { Gibt True zur.ck, wenn der Anfang der Datenbank erreicht wurde - }
 { oder wenn diese leer ist.                                        }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.BOF : BOOLEAN;


 { ---------------------------------------------------------------- }
 { Gibt die Anzahl der Datens.tze zur.ck. Diese kann zwischen 0     }
 { (Datenbank leer) und ca. 1 Milliarde liegen.                     }
 { Bei der "Count"-Methode wird - im Gegensatz zu "LastRec" - nicht }
 { einfach die Anzahl der physikalisch vorhandenen Records zur.ck-  }
 { gegeben, sondern es wird die Datenbank sequentiell (!!!) durch-  }
 { forstet und nur die Anzahl der logisch vorhandenen (i.e. nicht   }
 { gel.schten) Datens.tze zur.ckgegeben.                            }
 { Traten dabei Fehler auf (keine Datens.tze in der Datenbank etc.),}
 { so wird als Funktionsresultat -1 zur.ckgegeben.                  }
 { ---------------------------------------------------------------- }
 { Achtung: Nach dem Aufruf von "Count" steht der Satzzeiger auf    }
 { dem ersten Datensatz (entsprechend Aufruf "First") !             }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.Count : LONGINT;


 { ---------------------------------------------------------------- }
 { Gibt die momentane Position des Satzzeigers zur.ck, sprich die   }
 { Nummer des aktuellen Datensatzes.                                }
 { Ist das logische .quivalent zu "Go".                             }
 { ---------------------------------------------------------------- }
 { Die Position des Satzzeigers wird durch "RecNo" nicht ver.ndert. }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.RecNo : LONGINT;


 { ---------------------------------------------------------------- }
 { Gibt die momentane Position des Index-Satzzeigers zur.ck, sprich }
 { die Position innerhalb des Index-Baumes.                         }
 { Ist das logische .quivalent zu "IdxGo".                          }
 { ---------------------------------------------------------------- }
 { Die Position des Satzzeigers wird durch "IdxRecNo" nicht ver.n-  }
 { dert.                                                            }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.IdxRecNo : LONGINT;


 { ---------------------------------------------------------------- }
 { Gibt die Anzahl der Datens.tze zur.ck. Diese kann zwischen 0     }
 { (Datenbank leer) und ca. 1 Milliarde liegen.                     }
 { ---------------------------------------------------------------- }
 { Die Position des Satzzeigers wird durch "LastRec" nicht ver.n-   }
 { dert.                                                            }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.LastRec : LONGINT;


 { ---------------------------------------------------------------- }
 { Liest aus dem aktuellen Datensatz das Feld mit dem angegebenen   }
 { Namen und gibt den Inhalt als String (!) zur.ck - unabh.ngig vom }
 { tats.chlichen Typ des Feldes. Also z.B. bei Datumsfeldern        }
 { "19920316" oder bei Boolean "T" oder "F".                        }
 { ---------------------------------------------------------------- }
 { Bei Memofeldern wird nur der _Index_ des Memoeintrages in der    }
 { Memodatei zur.ckgegeben; der Text kann dann mittels MemoRead     }
 { gelesen werden.                                                  }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.READ (FName : TFeldStr) : STRING;


 { ---------------------------------------------------------------- }
 { H.ngt einen leeren (!) Datensatz an die Datenbank an, wobei der  }
 { Datensatz-Zeiger auf den neuen (und damit letzten) Satz gesetzt  }
 { wird. Dieser kann dann mittels "Replace" beschrieben werden.     }
 { Sollte die Operation aus irgendeinem Grund nicht durchgef.hrt    }
 { werden k.nnen, so wird False zur.ckgegeben und der Fehlerstatus  }
 { via Unit "Error" gesetzt, sonst kommt True zur.ck.               }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.APPEND : BOOLEAN;


 { ---------------------------------------------------------------- }
 { Ersetzt im aktuellen Datensatz das Feld mit dem angegebenen      }
 { Namen durch den neuen (.bergegebenen) Inhalt. Dieser ist - unab- }
 { h.ngig vom tats.chlichen Typ des Feldes - immer ein String,      }
 { wobei auch nur eine sehr oberfl.chliche Plausiblit.tspr.fung (zu }
 { lang / kurz) durchgef.hrt wird (die .brigens im Fehlerfall       }
 { wieder in Error den Fehlerstatus setzt und statt dem normalen    }
 { True False zur.ckgibt).                                          }
 { ---------------------------------------------------------------- }
 { Aufgrund der genannten Restriktionen sollte auf diese Routine im }
 { Allgemeinen zu Gunsten der spezialisierten Methoden "ReplaceL",  }
 { "ReplaceR", "ReplaceD" und "ReplaceB" verzichtet werden.         }
 { ---------------------------------------------------------------- }
 { Bei Memofeldern ist hier nur der _Index_ des Memoeintrages in    }
 { der Memodatei einzutragen, wie er ja durch ein Read erhalten     }
 { wird oder beim Anlegen eines neuen Textes von MemoAppend zur.ck- }
 { gegeben wird.                                                    }
 { ---------------------------------------------------------------- }
 { Sollte mittels "IndexOn" ein Index auf dieses Feld gelegt worden }