[<<Previous Entry] [^^Up^^] [Next Entry>>] [Menu] [About The Guide]
                                                    BOOLEAN; VIRTUAL;

       FUNCTION    DELETE  : BOOLEAN; VIRTUAL;
       FUNCTION    Recover : BOOLEAN; VIRTUAL;
       FUNCTION    Deleted : BOOLEAN; VIRTUAL;

       FUNCTION    IndexOn (FName : TFeldStr; Idx : PIndex) :
                                                    BOOLEAN; VIRTUAL;
       FUNCTION    SimpleIndex (Datei : PATHSTR; FName : TFeldStr) :
                                                    BOOLEAN; VIRTUAL;
       FUNCTION    SetPrimeIdx (Idx : PIndex) : BOOLEAN; VIRTUAL;
       FUNCTION    IsIndexed (FName : TFeldStr) : PIndex; VIRTUAL;

       FUNCTION    SetReplaceIdx (State : BOOLEAN) : BOOLEAN; VIRTUAL;

       FUNCTION    Search (SR : PdbSearchRec) : LONGINT; VIRTUAL;
       FUNCTION    coNtinue : LONGINT; VIRTUAL;

       FUNCTION    Pack : BOOLEAN; VIRTUAL;
       FUNCTION    ReIndex : BOOLEAN; VIRTUAL;
       FUNCTION    ReBuildIndex : BOOLEAN; VIRTUAL;

       FUNCTION    AnzahlFelder : BYTE; VIRTUAL;
       FUNCTION    FeldName (Nr : BYTE) : TFeldStr; VIRTUAL;
       FUNCTION    FeldNummer (FName : TFeldStr) : BYTE; VIRTUAL;
       FUNCTION    FeldTyp (FName : TFeldStr; VAR Typ : CHAR;
                             VAR Size,  NK : BYTE) : BOOLEAN; VIRTUAL;
       FUNCTION    coNtainsMemos : BOOLEAN; VIRTUAL;

       FUNCTION    HeaderSize : LONGINT; VIRTUAL;
       FUNCTION    RecordSize : LONGINT; VIRTUAL;
       FUNCTION    FILESIZE : LONGINT; VIRTUAL;
       FUNCTION    LastUpDate (VAR Date : TDate) : BOOLEAN; VIRTUAL;
       FUNCTION    IsModified : BOOLEAN; VIRTUAL;
       FUNCTION    DbVersion : BYTE; VIRTUAL;
       FUNCTION    FileName : PATHSTR; VIRTUAL;
     PRIVATE

     END; { OBJECT TDataBase }


 { ---------------------------------------------------------------- }
 { 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);


 { ---------------------------------------------------------------- }
 {                         T I N D E X                              }
 { ---------------------------------------------------------------- }

 { ---------------------------------------------------------------- }
 { Initialisiert das Indexobjekt. "Name" gibt den Dateinamen des    }
 { Indexfiles an, AField das Feld, auf das der Index gelegt werden  }
 { soll. Aus Adb wird der Datenbankdeskriptor f geholt, der nicht   }
 { (!) noch einmal initialisiert wird, sondern halt einfach von     }
 { einem zweiten Pointer referenziert wird.                         }
 { Init .bergibt die Hauptarbeit der Low-Level-Routine IdxUse aus   }
 { LLIndex.                                                         }
 { ---------------------------------------------------------------- }
 { Vor dem eigentlichen .ffnen wird .berpr.ft, ob die Indexdatei    }
 { .lter ist als die dBase-Datei (beispielsweise .nderung derselben }
 { durch ein Programm ohne Index-Unterst.tzung); wenn ja, so wird   }
 { die Indexdatei automatisch neu initialisiert ("IdxCreate").      }
 { ---------------------------------------------------------------- }
 { Sollte es das angegebene Feld gar nicht geben, so wird Fehler    }
 { Nummer 65 gesetzt und der Constructor endet mit FAIL (Objekt     }
 { wird nicht initialisiert).                                       }
 { Sollte die Datenbank noch gar nicht ge.ffnet sein, so wird       }
 { Fehler 15 gesetzt und ebenfalls geFAILt.                         }
 { ---------------------------------------------------------------- }

   CONSTRUCTOR TIndex.Use (Name : PATHSTR; AField : TFeldStr;
                                                      Adb : POINTER);


 { ---------------------------------------------------------------- }
 { Initialisiert das Indexobjekt. Im Unterschied zum normalen Use   }
 { ist es hier allerdings nicht notwendig, das Feld anzugeben,      }
 { dieses wird automatisch aus dem Header der Indexdatei ermittelt. }
 { Problem daran: Der Index darf nur mit einer Standard-Index-      }
 { funktion (keine zusammengesetzten Indices, keine Funktionen ...) }
 { erstellt worden sein !                                           }
 { ---------------------------------------------------------------- }

   CONSTRUCTOR TIndex.AutoUse (Name : PATHSTR; Adb : POINTER);


 { ---------------------------------------------------------------- }
 { Initialisiert das Indexobjekt und legt eine neue Indexdatei an.  }
 { "Name" gibt den Dateinamen des Indexfiles an, AField das Feld,   }
 { auf das der Index gelegt werden soll. Aus Adb wird der Daten-    }
 { bankdeskriptor f geholt, der nicht (!) noch einmal initialisiert }
 { wird, sondern halt einfach von einem zweiten Pointer referen-    }
 { ziert wird.                                                      }
 { ---------------------------------------------------------------- }
 { Das Erzeugen der Index-Datei und des Headers .bernimmt die Low-  }
 { Level-Routine IdxCreate aus LLIndex; danach wird der Baum aufge- }
 { baut.                                                            }
 { ---------------------------------------------------------------- }

   CONSTRUCTOR TIndex.Create (Name : PATHSTR; CI : TIdxCreateInfo;
                                                      Adb : POINTER);


 { ---------------------------------------------------------------- }
 { Die Indexfunktion kann .berschrieben werden; standardm..ig wird  }
 { hier einfach der Inhalt des indizierten Feldes auf die ent-      }
 { sprechende Feldl.nge abgeschnitten bzw. mit Leerzeichen aufge-   }
 { f.llt.                                                           }
 { ---------------------------------------------------------------- }
 { Denkbar sind hier alle m.glichen Kombinationen von Feldern mit-  }
 { tels "GetField"; folgendes mu. aber beachtet werden:             }
 { - Wenn der Datenbankinhalt f.r die angegebene Feldkombination    }
 {   nicht eindeutig ist, dann mu. es die Indexfunktion sein - es   }
 {   bietet sich die Verwendung von "Unique" an.                    }
 { - Der Indexausdruck mu. immer genau (!) "FieldLength" Zeichen    }
 {   lang sein - die Formatierung kann ja leicht beispielsweise     }
 {   mittels "LFormat" aus der Unit "AStrTool" erfolgen.            }
 { Ein (korrektes) Beispiel:                                        }
 {   IndexFunction := LFormat (GetField ('1') + GetField ('2'),     }
 {                             FieldLength - LENGTH (Unique)) +     }
 {                    Unique;                                       }
 { ---------------------------------------------------------------- }

   FUNCTION TIndex.IndexFunction : STRING;


 { ---------------------------------------------------------------- }
 { Zum "Bauen" eigener Indexfunktionen: Liefert den Inhalt des an-  }
 { gegebenen Feldes des aktuellen Satzes als Simpel-String, wobei   }
 { numerische und Datums-Felder gleich in die richtige Form ge-     }
 { bracht werden (b.ndiges Komma bzw. Format Jahr-Monat-Tag ohne    }
 { Trennzeichen).                                                   }
 { ---------------------------------------------------------------- }

   FUNCTION TIndex.GetField (WhichField : TFeldStr) : STRING;


 { ---------------------------------------------------------------- }
 { Gibt die vorgeschriebene L.nge des Indexausdruckes zur.ck; diese }
 { mu. _exakt_ (!) eingehalten werden - vergleiche auch die Methode }
 { "IndexFunction".                                                 }
 { ---------------------------------------------------------------- }

   FUNCTION TIndex.FieldLength : BYTE;


 { ---------------------------------------------------------------- }
 { Gibt einen f.r jeden Datensatz eindeutigen String der L.nge 8    }
 { zur.ck (n.mlich die rechtsb.ndig formatierte Satznummer);        }
 { kann verwendet werden, wenn in einem Schl.sselfeld einer Daten-  }
 { bank auch gleiche Schl.ssel zugelassen werden sollen (was ja     }
 { sonst beim Aufbau des Indices nicht zul.ssig ist).               }
 { ---------------------------------------------------------------- }
 { Warum 8 Stellen: 100 Millionen Datens.tze sind wohl reichlich    }
 { genug ...                                                        }
 { ---------------------------------------------------------------- }

   FUNCTION TIndex.Unique : STRING;


 { ---------------------------------------------------------------- }
 { Bereitet eine Anpassung des Indexfiles mittel "UpDateIndex" vor, }
 { indem es den alten (jetzt noch aktuellen) Schl.sselausdruck in   }
 { "OldKey" speichert.                                              }
 { ---------------------------------------------------------------- }
 { Diese Vorgangsweise ist notwendig, da ja Indexfiles nach dem     }
 { Schl.sselausdruck sortiert sind und nicht nach der Satznummer;   }
 { .ber diese w.re ein Zugriff also (fast) nicht m.glich (sehr ho-  }
 { her Zeitaufwand).                                                }
 { Andererseits "wei." aber "UpDateIndex" (ohne "UpDatePrepare")    }
 { nicht mehr, wie der alte Schl.ssel aufgebaut war - und kann ihn  }
 { somit nicht mehr finden.                                         }
 { ---------------------------------------------------------------- }

   PROCEDURE TIndex.UpDatePrepare;


 { ---------------------------------------------------------------- }
 { Wenn ein Datensatz ver.ndert wurde, so m.ssen alle Indices .ber  }
 { diese Methode auf den neuesten Stand gebracht werden (wird von   }

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