[<<Previous Entry] [^^Up^^] [Next Entry>>] [Menu] [About The Guide]
 { als Default-Name die Feldbezeichnung + '.NTX' verwendet.         }
 { Als Standard-Typ wird NTX angenommen, als L.nge die des Feldes   }
 { plus 8 Zeichen f.r "Unique".                                     }
 { ---------------------------------------------------------------- }
 { Wenn das angegebene Feld schon indiziert ist, so wird kein neuer }
 { Index angelegt und - wie in allen anderen Fehlerf.llen - False   }
 { zur.ckgegeben, sonst True.                                       }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.SimpleIndex (Datei : PATHSTR;
                                         FName : TFeldStr) : BOOLEAN;


 { ---------------------------------------------------------------- }
 { Setzt den Prim.rindex (wie er von First, Last, Skip etc. ver-    }
 { wendet wird) auf ein benutzerdefiniertes Indexobjekt - die Stan- }
 { dardvorgabe w.re der letzte definierte Index.                    }
 { Als Wert ist auch "Nil" erlaubt, es werden dann alle Operationen }
 { auf Datensatzbasis durchgef.hrt (bitte eine Kanne Kaffee bereit- }
 { stellen ...).                                                    }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.SetPrimeIdx (Idx : PIndex) : BOOLEAN;


 { ---------------------------------------------------------------- }
 { Liefert - wenn auf dem Feld mit dem angegebenen Namen ein Index  }
 { liegt - einen Pointer auf dessen beschreibendes Objekt zur.ck,   }
 { sonst Nil.                                                       }
 { ---------------------------------------------------------------- }
 { Sollte ein Fehler auftreten, so wird - wie immer - die Unit      }
 { "Error" bem.ht und ebenfalls Nil zur.ckgegeben.                  }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.IsIndexed (FName : TFeldStr) : PIndex;


 { ---------------------------------------------------------------- }
 { Kontrolliert, was geschieht, wenn versucht wird, einen Index auf }
 { ein Feld zu legen, das bereits indiziert ist. Wenn State = Off   }
 { ist, so wird der Versuch mit einer Fehlermeldung quittiert, bei  }
 { On dagegen wird das alte Indexobjekt gel.scht und durch das neue }
 { ersetzt.                                                         }
 { Defaultwert ist Off !                                            }
 { ---------------------------------------------------------------- }
 { Nachdem keine Datenbankfehler auftreten k.nnen, ist der R.ckga-  }
 { bewert immer True.                                               }
 { ---------------------------------------------------------------- }

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


 { ---------------------------------------------------------------- }
 { Sucht im Feld (oder in den Feldern) mit dem (den) angegebenen    }
 { Namen - bzw., wenn vorhanden, im darauf gelegten Index (der      }
 { wiederum nicht unbedingt etwas mit dem Feldinhalt zu tun haben   }
 { mu.) - nach dem angegebenen Inhalt.                              }
 { N.here Beschreibung des Aufbaus des Such-Records siehe Defi-     }
 { nition desselben.                                                }
 { ---------------------------------------------------------------- }
 { Wurde ein passender Satz gefunden, so wird seine Nummer zur.ck-  }
 { gegeben, sonst -1.                                               }
 { ---------------------------------------------------------------- }
 { Search weist - im Gegensatz zu so mancher anderer dBase-Schnitt- }
 { stelle - ziemlich viel Eigenintelligenz auf. Das bedeutet, da.   }
 { automatisch auf den Typ des / der Feldes (er) Bezug genommen     }
 { und die Daten entsprechend aufbereitet werden - sofern die ent-  }
 { sprechenden Objekte (insbesonders TIndex) nicht vom Program-     }
 { mierer unzweckm..ig ver.ndert wurden ...                         }
 { ---------------------------------------------------------------- }
 { Wenn die Effizienz wichtig ist, so sollte die Art, in der die    }
 { Suche erfolgt, ber.cksichtigt werden: Der erste Suchbegriff ist  }
 { der wichtigste, mit ihm erfolgt die "Vorselektion"; nur die      }
 { Datens.tze die auf diesen "Prim.rbegriff" passen, werden weiter  }
 { examiniert.                                                      }
 { Das bedeutet, da., wenn indizierte und nicht-indizierte Felder   }
 { zur Verf.gung stehen, immer eines der indizierten als erstes in  }
 { die Suchreihe gestellt werden sollte; au.erdem ist es g.nstig,   }
 { den "unwahrscheinlicheren" Begriff zu bevorzugen.                }
 { Suchaktionen nur mit nichtindizierten Feldern sind in gr..eren   }
 { Datenbanken auf keinen Fall mehr sinnvoll.                       }
 { ---------------------------------------------------------------- }
 { Es werden zum Positionieren in nicht indizierten Feldern die     }
 { Methoden "First" und "Skip" verwendet, d.h., entsprechend dem    }
 { "DeletedOn"-Flag werden eventuell auch nur nicht-gel.schte S.tze }
 { angezeigt.                                                       }
 { ---------------------------------------------------------------- }
 { Sollte ein Fehler auftreten, so wird - wie immer - die Unit      }
 { "Error" bem.ht und ebenfalls -1 zur.ckgegeben.                   }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.Search (SR : PdbSearchRec) : LONGINT;


 { ---------------------------------------------------------------- }
 { Setzt eine mit Search begonnene Suche fort, wobei die dort ge-   }
 { setzten Parameter weiterverwendet werden.                        }
 { Wurde ein weiterer passender Satz gefunden, so wird seine Nummer }
 { zur.ckgegeben, sonst -1.                                         }
 { ---------------------------------------------------------------- }
 { Sollte ein Fehler auftreten, so wird - wie immer - die Unit      }
 { "Error" bem.ht und ebenfalls -1 zur.ckgegeben.                   }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.coNtinue : LONGINT;


 { ---------------------------------------------------------------- }
 { Nicht nur die aufwendigste, sondern auch die durch ihren Zeit-   }
 { aufwand die Nerven am .rgsten strapazierende Routine ...         }
 { ---------------------------------------------------------------- }
 { Packt die Datenbank (wodurch alle als gel.scht markierten Fehler }
 { auch physikalisch - und damit unwiederbringlich gel.scht werden),}
 { die zugeordneten Indices (die dadurch reorganisiert werden, das  }
 { hei.t, es wird versucht, einen ausgewogenen Baum zu schaffen)    }
 { und die Memodatei (in der alle nicht mehr referenzierten Felder  }
 { gel.scht werden).                                                }
 { ---------------------------------------------------------------- }
 { Sollte ein Fehler auftreten, so wird - wie immer - die Unit      }
 { "Error" bem.ht und False zur.ckgeliefert, sonst True.            }
 { ---------------------------------------------------------------- }
 { Die Vorgehensweise dabei ist folgende: Zuerst wird eine neue     }
 { Datenbank identischer Struktur unter dem Namen '*.fbd' erzeugt,  }
 { in diese werden dann alle nicht gel.schten Datens.tze kopiert.   }
 { Dann wird die urspr.ngliche Datenbank geschlossen und gel.scht   }
 { und die tempor.re Datei auf den Namen der Originaldatei          }
 { umbenannt.                                                       }
 { ---------------------------------------------------------------- }
 { Sollte auf dem Datentr.ger nicht gen.gend Speicher vorhanden     }
 { sein, so wird die Datenbank nicht gepackt und Fehler 23 gesetzt. }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.Pack : BOOLEAN;


 { ---------------------------------------------------------------- }
 { Neuaufbau der Baumstruktur aller f.r dieses Datenbankobjekt defi-}
 { nierter Indices durch Aufruf der entsprechenden Methode des      }
 { Index-Objektes.                                                  }
 { Kann die Effizienz der Suche erh.hen; f.r n.here Beschreibung    }
 { siehe Unit "LLIndex" / Methode "IdxReIndex".                     }
 { ---------------------------------------------------------------- }
 { Bei erfolgreicher Durchf.hrung wird True zur.ckgegeben, sonst    }
 { False.                                                           }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.ReIndex : BOOLEAN;


 { ---------------------------------------------------------------- }
 { Neuaufbau aller f.r dieses Datenbankobjekt definierter Indices   }
 { durch Aufruf der entsprechenden Methode des Index-Objektes.      }
 { Praktisch nur nach einem Packen der Datenbank notwendig.         }
 { ---------------------------------------------------------------- }
 { Bei erfolgreicher Durchf.hrung wird True zur.ckgegeben, sonst    }
 { False.                                                           }
 { ---------------------------------------------------------------- }

   FUNCTION TDataBase.ReBuildIndex : BOOLEAN;


 { ---------------------------------------------------------------- }
 { Setzt die Parameter eines Such-Records; Beschreibung der Felder  }
 { bei diesem. Die Funktionen k.nnen auch verschachtelt werden,     }
 { beispielsweise so:                                               }
 { SR := NewSearchRec ('VORNAME', 'Franz', cpEqual,                 }
 {         NewSearchRec ('NACHNAME', 'Maier', cpEqual,              }
 {           NewSearchRec ('PLZ', '1000', cpGreater,                }
 {             NewSearchRec ('PLZ', '1090', cpLess,                 }
 {               Nil                                                }
 {             )                                                    }
 {           )                                                      }
 {         )                                                        }
 {       );                                                         }
 { Dadurch wird die M.glichkeit geschaffen, in mehreren Feldern     }
 { gleichzeitig zu suchen, in diesem Beispiel also nach Vorname =   }
 { Franz, Nachname = Maier und 1000 < Postleitzahl < 1090).         }
 { ---------------------------------------------------------------- }

   FUNCTION NewSearchRec (FName : TFeldStr; What : STRING;
                     How : BYTE; Next : PdbSearchRec) : PdbSearchRec;


 { ---------------------------------------------------------------- }
 { Nimmt dem Programmierer die M.he ab, irgendwelche verschachtel-  }
 { ten Such-Records wieder zu l.schen und entfernt sie restlos aus  }
 { dem Speicher.                                                    }
 { ---------------------------------------------------------------- }

   PROCEDURE DisposeSearchRec (VAR SR : PdbSearchRec)

This page created by ng2html v1.05, the Norton guide to HTML conversion utility. Written by Dave Pearson