[<<Previous Entry] [^^Up^^] [Next Entry>>] [Menu] [About The Guide]
 { aktuellen Eintrages, sondern den kompletten Record zur.ck.       }
 { ---------------------------------------------------------------- }

   FUNCTION IdxGetEintrag (F : PIdx; VAR Eintrag : TEintrag) : LONGINT;


 { ---------------------------------------------------------------- }
 { Sucht nach dem Indexeintrag, dessen Schl.sseleintrag n.chst-     }
 { kleiner ist, als der angegebene. Sollte ein solcher Schl.ssel    }
 { gefunden werden, so wird True zur.ckgegeben, sonst False.        }
 { Im ersten Fall enth.lt DSNr die Position des Indexeintrages      }
 { sonst ist der Wert von DSNr undefiniert.                         }
 { ---------------------------------------------------------------- }

   FUNCTION IdxFindSmaller (F : PIdx;Key : STRING;VAR DSNr : LONGINT) : BOOLE
 AN;

 { ---------------------------------------------------------------- }
 { Sucht nach dem Indexeintrag, dessen Schl.sseleintrag n.chst-     }
 { gr..er ist, als der angegebene. Sollte ein solcher Schl.ssel     }
 { gefunden werden, so wird True zur.ckgegeben, sonst False.        }
 { Im ersten Fall enth.lt DSNr die Position des Indexeintrages,     }
 { sonst ist der Wert von DSNr undefiniert.                         }
 { ---------------------------------------------------------------- }

   FUNCTION IdxFindBigger (F : PIdx;Key : STRING;VAR DSNr : LONGINT) : BOOLEA
 N;

 { ---------------------------------------------------------------- }
 { Gibt die Anzahl der gespeicherten Indexeintr.ge zur.ck - sollte  }
 { mit der Anzahl der Datens.tze in der Datenbank .bereinstimmen.   }
 { ---------------------------------------------------------------- }

   FUNCTION IdxCount (F : PIdx) : LONGINT;

 { ---------------------------------------------------------------- }
 { Packt die angegebene Indexdatei, wodurch ein m.glichst ausge-    }
 { wogener Baum erzeugt wird. Au.erdem werden bei der Gelegenheit   }
 { auch noch "tote Bl.tter" entdeckt und  entfernt.                 }
 { Die Vorgehensweise dabei ist folgende: Zuerst wird eine neue     }
 { Index-Datei identischer Struktur unter dem Namen '$$$temp.ntx'   }
 { bzw. '$$$temp.ndx' erzeugt.                                      }
 { Dann wird die urspr.ngliche Datenbank geschlossen und gel.scht   }
 { und die tempor.re Datei auf den Namen der Originaldatei          }
 { umbenannt.                                                       }
 { Au.erdem mu. bei Aufruf der Prozedur der Auslastungsfaktor       }
 { gesetzt werden. Dieser Faktor gibt an, wie stark die einzelnen   }
 { Pages ausgelastet (gef.llt) werden.                              }
 { Dieser Faktor m mu. im Bereich 0.55 <= m <= 0.95 liegen.         }
 { Gro.er Indizierungsfaktor :                                      }
 { =========================                                        }
 { Vorteile : o) Schnelles Suchen                                   }
 { --------   o) kleines File (wenig Datenspeicherbedarf)           }
 {            o) weniger Zeitbeanspruchung beim Reindizieren        }
 {            o) Schnelles L.schen                                  }
 { Nachteile: o) Eintragen langsam, da sehr bald gesplittet         }
 { ---------     werden mu.                                         }
 {            o) schlechtere Ausgewogenheit                         }
 { Kleiner Indizierungsfaktor :                                     }
 { ==========================                                       }
 { Vorteile : o) Schnelles Eintragen                                }
 { --------   o) Bessere Ausgewogenheit                             }
 { Nachteile: o) Langsameres Suchen                                 }
 { ---------  o) gr..ere Files                                      }
 {            o) langsames L.schen                                  }
 {            o) mehr Zeitbeanspruchung beim Reindizieren           }
 {                                                                  }
 { Empfohlener Indizierungsfaktor f.r beste Ausnutzung : 0.8        }
 { ---------------------------------------------------------------- }
 { Sollte auf dem Datentr.ger nicht gen.gend Speicher vorhanden     }
 { sein, so wird die Indexdatei nicht reindiziert und Fehler 51     }
 { gesetzt.                                                         }
 { Ist der Reindezierungsfaktor zu gro., wird der Fehler 54 gesetzt.}
 { Ist der Reindezierungsfaktor zu klein, wird der F. 55 gesetzt.   }
 { ---------------------------------------------------------------- }

   PROCEDURE IdxReIndex (F : PIdx;Factor : REAL);

 { Etwas langsamer, aber sch.ner programmiert. }

   PROCEDURE IdxReIndex2 (F : PIdx);

 { ---------------------------------------------------------------- }
 { Initialisiert eine neue Indexdatei-Variable: Reservieren des     }
 { ben.tigten Heaps, Inhalt l.schen, "Opened"-Flag auf False setzen.}
 { ---------------------------------------------------------------- }
 { Diese Funktion mu. immer vor Verwendung einer Indexvariable      }
 { (sprich: vor (!) dem .ffnen !) angewendet werden.                }
 { ---------------------------------------------------------------- }

   PROCEDURE InitIdxRec (VAR F : PIdx);

 { ---------------------------------------------------------------- }
 { L.scht eine alte Indexdatei-Variable: Freigeben des ben.tigten   }
 { Heaps, Inhalt l.schen                                            }
 { ---------------------------------------------------------------- }
 { Diese Funktion mu. immer nach Verwendung einer Indexvariable     }
 { (sprich: nach (!) dem Schlie.en (!) ) angewendet  werden.        }
 { ---------------------------------------------------------------- }

   PROCEDURE DoneIdxRec (VAR F : PIdx);

 { ---------------------------------------------------------------- }
 { Da in TDB die Sortierreihenfolge bei alle Stringvergleichen      }
 { beliebig festgelegt werden kann, gibt es ein Vergleichsarray     }
 { (CompArrayTyp = Array [0..255] of Byte) in dem die Wertigkeiten  }
 { der entsprechenden ASCII- Zeichen stehen.                        }
 { Z.B.: arraywert[66]:= 2 bedeutet, da. 'B' die Wertigkeit         }
 {       von 2 bekommt.                                             }
 { ---------------------------------------------------------------- }
 { Folgende Sortierreihenfolge ist standardm..og eingestellt :      }
 { ' ',0..9,aA..,bB,...,nN,oO..,pP,qQ,rR,sS.,tT,uU..,...,zZ         }
 { die restlichen Zeichen sind mit 255 initialisiert                }
 { Alle Zeichen, zwischen denen sich kein Beistrich befindet        }
 { besitzen gleiche Wertigkeit ; d.h :                              }
 { CompArray[ord('o')] = CompArray[ord('O')] =                      }
 { = CompArray[ord('.')] = CompArray[ord('.')]                      }
 { ---------------------------------------------------------------- }
 { S.mtliche in TPDB verwendeten Vergleichsroutinen greifen auf     }
 { dieses Array zu.                                                 }
 { Die Prozedur SetCompArray kann zum .berschreiben dieses Arrays   }
 { verwendet werden.                                                }
 { ---------------------------------------------------------------- }

   PROCEDURE SetCompArray (F : PIdx; NewCompArray : coMpArrayTyp)

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