Zeichensätze

Erweiterbarkeit

Textanalyse

Die Zend_Search_Lucene_Analysis_Analyzer Klasse wird vom Indexer verwendet, um die Textfelder der Dokumente in Abschnitte aufzuteilen.

Die Zend_Search_Lucene_Analysis_Analyzer::getDefault() und Zend_Search_Lucene_Analysis_Analyzer::setDefault() Methoden werden verwendet, um den Standardanalysator zu bekommen oder festzulegen.

Man kann einen eigenen Textanalysator zuordnen oder ihn aus den vordefinierten Analysatoren auswählen: Zend_Search_Lucene_Analysis_Analyzer_Common_Text und Zend_Search_Lucene_Analysis_Analyzer_Common_Text_CaseInsensitive (Standard). Beide interpretieren einen Abschnitt als eine Sequenz aus Buchstaben. Zend_Search_Lucene_Analysis_Analyzer_Common_Text_CaseInsensitive konvertiert alle Abschnitte in Kleinbuchstaben.

Um zwischen Analysatoren zu wechseln:

  1. Zend_Search_Lucene_Analysis_Analyzer::setDefault(
  2.     new Zend_Search_Lucene_Analysis_Analyzer_Common_Text());
  3. ...
  4. $index->addDocument($doc);

Die Zend_Search_Lucene_Analysis_Analyzer_Common Klasse wurde als Anker für alle benutzerdefinierten Analysatoren entwickelt. Benutzer sollten nur die reset() und nextToken() Methoden definieren, welche ihren String von der $_input Eigenschaft nimmt und die Abschnitte Stück für Stück zurückgibt (ein NULL Wert indiziert das Ende des Streams).

Die nextToken() Methode sollte die normalize() Methode auf jedem Token aufrufen. Das erlaubt die Verwendung von Abschnittsfiltern im eigenen Analysator.

Hier ist ein Beispiel für einen eigenen Analysator, welcher Wörter mit Ziffern als Begriffe akzeptiert:

Example #1 Eigener Textanalysator

  1. /**
  2. * Hier ist ein eigener Textanalysator, der Worte mit Ziffern
  3. * als einen Begriff behandelt
  4. */
  5.  
  6. class My_Analyzer extends Zend_Search_Lucene_Analysis_Analyzer_Common
  7. {
  8.     private $_position;
  9.  
  10.     /**
  11.      * Setzt den Token Stream zurück
  12.      */
  13.     public function reset()
  14.     {
  15.         $this->_position = 0;
  16.     }
  17.  
  18.     /**
  19.      * Tokenization stream API
  20.      * Get next token
  21.      * Returns null at the end of stream
  22.      *
  23.      * @return Zend_Search_Lucene_Analysis_Token|null
  24.      */
  25.     public function nextToken()
  26.     {
  27.         if ($this->_input === null) {
  28.             return null;
  29.         }
  30.  
  31.         while ($this->_position < strlen($this->_input)) {
  32.             // skip white space
  33.             while ($this->_position < strlen($this->_input) &&
  34.                    !ctype_alnum( $this->_input[$this->_position] )) {
  35.                 $this->_position++;
  36.             }
  37.  
  38.             $termStartPosition = $this->_position;
  39.  
  40.             // read token
  41.             while ($this->_position < strlen($this->_input) &&
  42.                    ctype_alnum( $this->_input[$this->_position] )) {
  43.                 $this->_position++;
  44.             }
  45.  
  46.             // Empty token, end of stream.
  47.             if ($this->_position == $termStartPosition) {
  48.                 return null;
  49.             }
  50.  
  51.             $token = new Zend_Search_Lucene_Analysis_Token(
  52.                                       substr($this->_input,
  53.                                              $termStartPosition,
  54.                                              $this->_position -
  55.                                              $termStartPosition),
  56.                                       $termStartPosition,
  57.                                       $this->_position);
  58.             $token = $this->normalize($token);
  59.             if ($token !== null) {
  60.                 return $token;
  61.             }
  62.             // Continue if token is skipped
  63.         }
  64.  
  65.         return null;
  66.     }
  67. }
  68.  
  69. Zend_Search_Lucene_Analysis_Analyzer::setDefault(
  70.     new My_Analyzer());

Filtern von Tokens

Der Zend_Search_Lucene_Analysis_Analyzer_Common Analisator bietet auch einen Mechanismus zum Filtern von Tokens.

Die Zend_Search_Lucene_Analysis_TokenFilter Klasse bietet ein abstraktes Interface für solche Filter. Eigene Filter sollten diese Klasse direkt oder indirekt erweitern.

Alle eigenen Filter müssen die normalize() Methode implementieren, welche den Eingabe Token verändern oder signalisieren, dass der Token übersprungen werden sollte.

Es gibt bereits drei Filter die im Analyse Unterpaket definierte sind:

  • Zend_Search_Lucene_Analysis_TokenFilter_LowerCase

  • Zend_Search_Lucene_Analysis_TokenFilter_ShortWords

  • Zend_Search_Lucene_Analysis_TokenFilter_StopWords

Der LowerCase Filter wird bereits standardmäßig für den Zend_Search_Lucene_Analysis_Analyzer_Common_Text_CaseInsensitive Analysator verwendet.

Die ShortWords und StopWords Filter können mit bereits definierten oder eigenen Analysatoren wie folgt verwendet werden:

  1. $stopWords = array('a', 'an', 'at', 'the', 'and', 'or', 'is', 'am');
  2. $stopWordsFilter =
  3.     new Zend_Search_Lucene_Analysis_TokenFilter_StopWords($stopWords);
  4.  
  5. $analyzer =
  6.     new Zend_Search_Lucene_Analysis_Analyzer_Common_TextNum_CaseInsensitive();
  7. $analyzer->addFilter($stopWordsFilter);
  8.  
  9. Zend_Search_Lucene_Analysis_Analyzer::setDefault($analyzer);
  1. $shortWordsFilter = new Zend_Search_Lucene_Analysis_TokenFilter_ShortWords();
  2.  
  3. $analyzer =
  4.     new Zend_Search_Lucene_Analysis_Analyzer_Common_TextNum_CaseInsensitive();
  5. $analyzer->addFilter($shortWordsFilter);
  6.  
  7. Zend_Search_Lucene_Analysis_Analyzer::setDefault($analyzer);

Der Zend_Search_Lucene_Analysis_TokenFilter_StopWords Konstruktor nimmt ein Array mit Stopwörtern als Eingabe entgegen. Aber Stopwörter können auch aus einer Datei geladen werden:

  1. $stopWordsFilter = new Zend_Search_Lucene_Analysis_TokenFilter_StopWords();
  2. $stopWordsFilter->loadFromFile($my_stopwords_file);
  3.  
  4. $analyzer =
  5.     new Zend_Search_Lucene_Analysis_Analyzer_Common_TextNum_CaseInsensitive();
  6. $analyzer->addFilter($stopWordsFilter);
  7.  
  8. Zend_Search_Lucene_Analysis_Analyzer::setDefault($analyzer);

Die Datei sollte eine normale Textdatei mit einem Wort pro Zeile sein. Das '#' Zeichen markiert eine Zeile als Kommentar.

Der Zend_Search_Lucene_Analysis_TokenFilter_ShortWords Konstruktor hat ein optionales Argument. Es ist das Limit für die Wortlänge, der standardmäßig 2 ist.

Algorithmen für Punktwertermittlung

Der Punktwert einer Abfrage q für das Dokument d ist wie folgt definiert:

score(q,d) = sum( tf(t in d) * idf(t) * getBoost(t.field in d) * lengthNorm(t.field in d) ) * coord(q,d) * queryNorm(q)

tf(t in d) - Zend_Search_Lucene_Search_Similarity::tf($freq) - ein Punktwertfaktor, der auf der Häufigkeit des Begriffes oder der Phrase innerhalb des Dokuments basiert.

idf(t) - Zend_Search_Lucene_Search_Similarity::idf($input, $reader) - ein Punktwertfaktor für einen einfachen Begriff mit dem spezifischen Index.

getBoost(t.field in d) - der Verstärkungsfaktor für das Begriffsfeld.

lengthNorm($term) - der Normalisierungswert für ein Feld, der die Gesamtzahl der Begriffe innerhalb eines Fields enthält. Dieser Wert wird im Index abgelegt. Diese Wert werden zusammen mit dem Verstärkungsfaktor im Index abgelegt und vom Suchcode für alle Treffer eines Feldes zu Punktwerten multipliziert.

Treffer in längeren Feldern sind weniger präzise, so dass Implementierungen dieser Methode normalerweise kleinere Werte zurückgeben, wenn numTokens groß ist, und größere Werte, wenn numTokens klein ist.

coord(q,d) - Zend_Search_Lucene_Search_Similarity::coord($overlap, $maxOverlap) - ein Punktwertfaktor, der auf dem Anteil aller Abfragebegriffe basiert, die ein Dokument enthält.

Das Vorhandensein eines grossen Teils der Abfragebegriffe gibt einen besseren Treffer für die Abfrage an, so dass Implementierungen dieser Methode normalerweise größere Werte zurückgeben, wenn das Verhältnis zwischen diesen Parametern groß ist, und kleinere Werte, wenn es klein ist.

queryNorm(q) - der Normalisierungswert für eine Abfrage, welcher die Summe der quadrierten Gewichtungen jedes Begriffes eine Abfrage enthält. Dieser Wert wird für das Gewicht jedes Abfragebegriffes multipliziert. term.

Dieses wirkt sich nicht auf die Reihenfolge ist, versucht aber, die Punktwerte für verschiedenen Abfragen vergleichbar zu machen.

Der Algorithmen für die Punktwertermittlung kann durch die Definition einer eigenen Ähnlichkeitsklasse angepasst werden. Hierfür muss die Zend_Search_Lucene_Search_Similarity Klasse wie unten angegeben erweitert und anschließend die Zend_Search_Lucene_Search_Similarity::setDefault($similarity); Methode verwendet werden um Sie als Standard zu setzen.

  1. class MySimilarity extends Zend_Search_Lucene_Search_Similarity {
  2.     public function lengthNorm($fieldName, $numTerms) {
  3.         return 1.0/sqrt($numTerms);
  4.     }
  5.  
  6.     public function queryNorm($sumOfSquaredWeights) {
  7.         return 1.0/sqrt($sumOfSquaredWeights);
  8.     }
  9.  
  10.     public function tf($freq) {
  11.         return sqrt($freq);
  12.     }
  13.  
  14.     /**
  15.      * Es wird jetzt nicht verwendet. Berechnet den Wert eines Treffers
  16.      * für eine ungenauen Phrasenanfrage.
  17.      */
  18.     public function sloppyFreq($distance) {
  19.         return 1.0;
  20.     }
  21.  
  22.     public function idfFreq($docFreq, $numDocs) {
  23.         return log($numDocs/(float)($docFreq+1)) + 1.0;
  24.     }
  25.  
  26.     public function coord($overlap, $maxOverlap) {
  27.         return $overlap/(float)$maxOverlap;
  28.     }
  29. }
  30.  
  31. $mySimilarity = new MySimilarity();
  32. Zend_Search_Lucene_Search_Similarity::setDefault($mySimilarity);

Storage Container

Die abstrakte Klasse Zend_Search_Lucene_Storage_Directory definiert Funktionalitäten für Verzeichnisse.

Der Zend_Search_Lucene Konstruktur verwendet als Eingabe entweder einen String oder ein Zend_Search_Lucene_Storage_Directory Objekt.

Die Zend_Search_Lucene_Storage_Directory_Filesystem Klasse implementiert Verzeichnisfunktionalitäten für ein Dateisystem.

Wenn ein String als Eingabe für den Zend_Search_Lucene Konstruktur verwendet wird, behandelt der Indexleser (das Zend_Search_Lucene Objekt) es wie einen Dateipfad und instanziiert das Zend_Search_Lucene_Storage_Directory_Filesystem Objekt.

Du kannst deinen eigenen Verzeichnisimplementation durch die Erweiterung der Zend_Search_Lucene_Storage_Directory Klasse definieren.

Zend_Search_Lucene_Storage_Directory Methoden:

  1. abstract class Zend_Search_Lucene_Storage_Directory {
  2. /**
  3. * Schließt den Speicher
  4. *
  5. * @return void
  6. */
  7. abstract function close();
  8.  
  9. /**
  10. * Erstellt im Verzeichnis eine neue, leere Datei mit dem übergebenen Dateinamen $filename.
  11. *
  12. * @param string $name
  13. * @return void
  14. */
  15. abstract function createFile($filename);
  16.  
  17. /**
  18. * Entfernt eine vorhande Datei $filename aus dem Verzeichnis.
  19. *
  20. * @param string $filename
  21. * @return void
  22. */
  23. abstract function deleteFile($filename);
  24.  
  25. /**
  26. * Gibt true zurück, wenn eine Datei mit dem übergebenen Dateinamen $filename existiert
  27. *
  28. * @param string $filename
  29. * @return boolean
  30. */
  31. abstract function fileExists($filename);
  32.  
  33. /**
  34. * Gibt die länge eine Datei $filename im Verzeichnis zurück
  35. *
  36. * @param string $filename
  37. * @return integer
  38. */
  39. abstract function fileLength($filename);
  40.  
  41. /**
  42. * Gibt den UNIX Zeitstempel für die letzte Änderung der Datei $filename zurück.
  43. *
  44. * @param string $filename
  45. * @return integer
  46. */
  47. abstract function fileModified($filename);
  48.  
  49. /**
  50. * Benennt eine vorhandene Datei im Verzeichnis um.
  51. *
  52. * @param string $from
  53. * @param string $to
  54. * @return void
  55. */
  56. abstract function renameFile($from, $to);
  57.  
  58. /**
  59. * Ändert die Änderungstzeit der Datei $filename auf jetzt um
  60. *
  61. * @param string $filename
  62. * @return void
  63. */
  64. abstract function touchFile($filename);
  65.  
  66. /**
  67. * Gibt ein Zend_Search_Lucene_Storage_File Objekt für den^
  68. * Dateinamen $filename aus dem Verzeichnis zurück.
  69. *
  70. * @param string $filename
  71. * @return Zend_Search_Lucene_Storage_File
  72. */
  73. abstract function getFileObject($filename);
  74.  
  75. }

Die getFileObject($filename) Methode einer Zend_Search_Lucene_Storage_Directory Instanz gibt ein Zend_Search_Lucene_Storage_File Objekt zurück.

Die abstrakte Klasse Zend_Search_Lucene_Storage_File implementiert einfache Funktionen für Dateiabstraktion und das Lesen von Indexdateien.

Es muß außerdem Zend_Search_Lucene_Storage_File für eine eigene Verzeichnisimplementation erweitert werden.

Nur zwei Methoden der Zend_Search_Lucene_Storage_File Klasse müssen in der eigenen Implementation überschrieben werden:

  1. class MyFile extends Zend_Search_Lucene_Storage_File {
  2.     /**
  3.      * Setzt den Indikator für die Dateiposition rückt den Dateizeiger
  4.      * voran. Die neue Position, gemessen in Bytes vom Dateianfangm
  5.      * wird erreicht durch das Hinzufügen eines Versatzes zu der
  6.      * angegebenen Position. Dessen Werte sind wie folgt definiert:
  7.      * SEEK_SET - Setze die Position auf den Versatz.
  8.      * SEEK_CUR - Setze die Position auf die aktuelle Position plus Versatz.
  9.      * SEEK_END - Setze die Position aufs Dateisende plus Versatz. (Um den
  10.      * Zeiger auf eine Position vor dem Dateiende zu bewegen, übergebe einen
  11.      * negativen Wert als Versatz.)
  12.      * Bei Erfolg wird 0, andernfalls -1 zurückgegeben
  13.      *
  14.      * @param integer $offset
  15.      * @param integer $whence
  16.      * @return integer
  17.      */
  18.     public function seek($offset, $whence=SEEK_SET) {
  19.         ...
  20.     }
  21.  
  22.     /**
  23.      * Lese $length Bytes aus der Datei und setze den Dateizeiger vor.
  24.      *
  25.      * @param integer $length
  26.      * @return string
  27.      */
  28.     protected function _fread($length=1) {
  29.         ...
  30.     }
  31. }

Zeichensätze