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