sorgalla.com » Sphinx

Sphinx und SphinxSE ins Zend Framework integrieren

jan — Mon, 18 Jan 2010 10:58:05 +0000

Nachdem Sphinx und SphinxSE installiert ist, geht es diesmal um die Integration in ein Zend Framework-Projekt. Dazu gehört die Erstellung einer Konfigurationsdatei und ein Kommandozeilen-Skript zum Starten und Stoppen des Sphinx-Suchdämons und zum Generieren des Suchindexes.

Den Code zum Artikel gibts auf github.

Das Zend Framework ist nicht enthalten und muss noch nachinstalliert werden. Entweder man lädt sich die aktuelle Version herunter und kopiert oder linkt den Zend-Ordner ins library-Verzeichnis oder man installiert es per PEAR. Den (inoffiziellen) PEAR Channel gibts unter http://pear.zfcampus.org.

Die Konfigurationsdatei

Die Konfigurationsdatei von Sphinx ist die Schaltzentrale und enthält alle Optionen für den Dämon, den Indexer, die Indizes und deren Datenquellen. Für unser Beispielprojekt nutzen wir eine einfache Variante mit Grundeinstellungen. Der Clou ist, dass die Konfigurationsdateien von jeder beliebigen Skriptsprachen verarbeitet werden kann. Einfach am Anfang der Datei den entsprechenden Shebang setzen.

Die Datei liegt in application/configs/sphinx.conf:

#!/usr/bin/env php

 
// Define path to application directory
defined('APPLICATION_PATH')
    || define('APPLICATION_PATH', realpath(dirname(__FILE__) . '/..'));
 
// Define application environment
//
// Use `export APPLICATION_ENV=development` or edit /etc/environment
// to change the application environment
defined('APPLICATION_ENV')
    || define('APPLICATION_ENV', (getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV') : 'production'));
 
// Ensure library/ is on include_path
set_include_path(implode(PATH_SEPARATOR, array(
    realpath(APPLICATION_PATH . '/../../library'),
    get_include_path(),
)));
 
/** Zend_Application */
require_once 'Zend/Application.php';
 
// Create application, bootstrap, and run
$application = new Zend_Application(
    APPLICATION_ENV,
    APPLICATION_PATH . '/configs/application.ini'
);
$config = $application->getOptions();
?>
source posts
{
    type                    = mysql
 
    sql_host                =  echo $config['resources']['db']['params']['host'] . "\n"; ?>
    sql_user                =  echo $config['resources']['db']['params']['username'] . "\n"; ?>
    sql_pass                =  echo $config['resources']['db']['params']['password'] . "\n"; ?>
    sql_db                  =  echo $config['resources']['db']['params']['dbname'] . "\n"; ?>
    # sql_port               = 3306    # optional, default is 3306
 
    sql_query_pre           = SET NAMES utf8
 
    sql_query               = \
        SELECT posts.id, posts.category_id, posts.title, posts.content, UNIX_TIMESTAMP(posts.created) AS created, \
               categories.name AS category_name, \
               GROUP_CONCAT(tags.tag SEPARATOR ', ') AS tags \
          FROM posts \
          JOIN categories ON (categories.id = posts.category_id) \
     LEFT JOIN posts_tags ON (posts_tags.post_id = posts.id) \
     LEFT JOIN tags ON (tags.id = posts_tags.tag_id) \
      GROUP BY posts.id
 
    sql_attr_uint           = category_id
    sql_attr_timestamp      = created
 
    sql_query_info          = \
        SELECT posts.id, posts.category_id, posts.title, posts.content, posts.created, \
               categories.name AS category_name, \
               GROUP_CONCAT(tags.tag SEPARATOR ', ') AS tags \
          FROM posts \
          JOIN categories ON (categories.id = posts.category_id) \
     LEFT JOIN posts_tags ON (posts_tags.post_id = posts.id) \
     LEFT JOIN tags ON (tags.id = posts_tags.tag_id) \
         WHERE posts.id=$id
}
 
index posts
{
    source                  = posts
    path                    =  echo $config['sphinx']['index']['path']; ?>/posts
    docinfo                 = extern
    html_strip              = 1
    charset_type            = utf-8
    # Character table for german (from http://www.sphinxsearch.com/forum/view.html?id=19)
    charset_table           = 0..9, A..Z->a..z, _, a..z, U+C4->U+E4, U+D6->U+F6, U+DC->U+FC, U+DF, U+E4, U+F6, U+FC
}
 
indexer
{
    mem_limit               = 32M
}
 
searchd
{
    listen                  =  echo $config['sphinx']['searchd']['listen'] . "\n"; ?>
    log                     =  echo $config['sphinx']['searchd']['log'] . "\n"; ?>
    query_log               =  echo $config['sphinx']['searchd']['query_log'] . "\n"; ?>
    read_timeout            = 5
    max_children            = 30
    pid_file                =  echo $config['sphinx']['searchd']['pid_file'] . "\n"; ?>
    max_matches             = 1000
    seamless_rotate         = 1
    preopen_indexes         = 0
    unlink_old              = 1
}

Was die einzelnen Optionen bedeuten, kann man in der Dokumentation gut nachlesen. Ich will hier nur auf paar Besonderheiten eingehen:

Der PHP-Abschnitt am Anfang der Datei nutzt Zend_Application um die application.ini zu laden.
Im Abschnitt source posts nutzen wir die ausgelesenen Optionen um die Zugangsdaten für die Datenbank zu setzen. Diese können dann global in der application.ini verwaltet werden.
Im Abschnitt index posts und searchd verwenden wir ebenfalls Optionen aus der application.ini. Das sind vor allem Pfadangaben für den Suchindex und Logdateien und an welcher IP und/oder Port der Suchdämon lauschen soll. Diese Angaben können wir somit pro APPLICATION_ENV anpassen.

Das Kommandozeilen-Skript für Sphinx

Um den Suchindex zu erstellen und den Suchdämon zu starten und zu stoppen, enthält das Projekt das Kommandozeilen-Skript in scripts/sphinx. Der Aufruf erfolgt so:

$ ./scripts/sphinx COMMAND ENVIRONMENT

COMMAND

Folgende Kommandos sind möglich:
start	Startet den Suchdämon.
stop	Stoppt den Suchdämon.
restart	Startet den Suchdämon neu.
index-all	Erstellt alle in `application/configs/sphinx.conf` definierten Suchindizes.

ENVIRONMENT

Gibt APPLICATION_ENV an, entspricht also define('APPLICATION_ENV', 'production'); in z. B. der index.php. Somit wird der entsprechende Abschnitt in application/configs/application.ini genutzt. Wenn nicht angegeben, wird standardmäßig production verwendet.

Beispiele

Startet den Suchdämon mit APPLICATION_ENV=production:

$ ./scripts/sphinx start production

Erstellt alle Suchindizes mit APPLICATION_ENV=development:

$ ./scripts/sphinx index-all development

Somit haben wir nun unser Zend Framework-Projekt präpariert um mit Sphinx zu arbeiten. Auf den Suchindex lässt sich nun ganz einfach, z. B. per Zend_Db_Select, zugreifen:

$query = 'Mein Suchbegriff';
$select = $db->select();
$select->from('posts')
       ->joinInner('sphinx', 'sphinx.id = posts.id')
       ->where('sphinx.query = ?', $query . ';mode=any;sort=extended:@weight desc, @id asc;limit=10;offset=0;index=posts');
$result = $select->query()->fetchAll();

Links zum Thema

Sphinx und SphinxSE unter Ubuntu installieren

jan — Tue, 15 Dec 2009 18:18:27 +0000

Wer Projekte mit MySQL als Datenbank-Backend realisiert, wird die Erfahrung schon gemacht haben, dass er bei der Implementierung einer Suchfunktion an Grenzen stößt. Der Fulltext-Index ist nicht der Wahrheit letzter Schluss und andere Lösungen oft nur unbefriedigende Workarounds.

Hier kann Sphinx Abhilfe schaffen. Besonders die nahtlose Integration in MySQL sticht hier als Pluspunkt heraus. So kann man den Suchindex direkt über SQL-Abfragen ansprechen und andere Tabellen hinzu-”joinen”. In diesem Artikel wollen wir uns mit der Installation von Sphinx und SphinxSE, der Storage-Engine für MySQL, beschäftigen.

Die Installationsanleitung bezieht sich auf Ubuntu 9.10 als Betriebssystem, lässt sich aber im Prinzip auch für andere Systeme/Versionen nachvollziehen. Folgende Versionen waren zum Zeitpunkt der Erstellung dieses Artikels aktuell:

MySQL 5.1.37
Sphinx 0.9.9

Wir gehen davon aus, dass MySQL bereits installiert ist, falls nicht, schnell nachholen:

$ sudo apt-get install mysql-server-5.1

Sphinx installieren

Zuerst holen wir uns die Quellen von Sphinx und entpacken Sie:

$ wget http://www.sphinxsearch.com/downloads/sphinx-0.9.9.tar.gz
$ tar -xvzf sphinx-0.9.9.tar.gz
$ cd sphinx-0.9.9/

Da wir mit libstemmer-Support kompilieren wollen, um deutsches Stemming nutzen zu können (Standardmäßig unterstützt Sphinx nur Englisch und Russisch), holen und entpacken wir uns noch das entprechende Archiv:

$ wget http://snowball.tartarus.org/dist/libstemmer_c.tgz
$ tar -xvzf libstemmer_c.tgz

Nun installieren:

$ ./configure --with-libstemmer
$ make
$ sudo make install

Für die weitere Konfiguration verweise ich jetzt einfach mal auf die Dokumentation und den Quickstart von Sphinx.

SphinxSE installieren

Wir wechseln zuerst ins Elternverzeichnis und holen uns die Quellen von MySQL:

$ cd ../
$ apt-get source mysql-server-5.1
$ cd mysql-dfsg-5.1-5.1.37/

Nun kopieren wir die Dateien für die Storage-Engine in das entsprechende Verzeichnis:

$ cp -R ../sphinx-0.9.9/mysqlse storage/sphinx

./configure beschwert sich wegen eines fehlenden Docs/-Ordners. Also schnell das Archiv von der MySQL-Seite holen und den entsprechenden Ordner ins Installationsverzeichnis kopieren:

$ wget http://downloads.mysql.com/archives/mysql-5.1/mysql-5.1.37.tar.gz
$ mkdir temp
$ tar -xzvf mysql-5.1.37.tar.gz -C temp
$ mv temp/mysql-5.1.37/Docs .
$ rm -rf temp
$ rm mysql-5.1.37.tar.gz

Nun gehts ans Bauen. Die configure-Flags kommen aus debian/rules und sollten denen entprechen, mit denen die Original-Installation von MySQL gebaut wurde:

$ BUILD/autorun.sh
$ ./configure --prefix=/usr \
              --exec-prefix=/usr \
              --libexecdir=/usr/sbin \
              --datadir=/usr/share \
              --localstatedir=/var/lib/mysql \
              --includedir=/usr/include \
              --infodir=/usr/share/info \
              --mandir=/usr/share/man \
              --enable-thread-safe-client \
              --enable-local-infile \
              --with-pstack \
              --with-fast-mutexes \
              --with-big-tables \
              --with-unix-socket-path=/var/run/mysqld/mysqld.sock \
              --with-mysqld-user=mysql \
              --with-libwrap \
              --with-ssl \
              --without-docs \
              --with-extra-charsets=all \
              --with-embedded-server \
              --with-embedded-privilege-control
$ make

Danach finden wir im Verzeichnis storage/sphinx/.libs die ladbaren .so-Dateien für MySQL. Diese speichern wir nun in /usr/lib/mysql/plugin

$ sudo mkdir /usr/lib/mysql/plugin
$ sudo cp storage/sphinx/.libs/ha_sphinx.so* /usr/lib/mysql/plugin/
$ sudo chown -R mysql:mysql /usr/lib/mysql/plugin

Den Ort müssen wir nun noch MySQL mitteilen. Wir editieren /etc/mysql/my.cnf:

$ sudo vi /etc/mysql/my.cnf

Im Abschnitt [mysqld] fügen wir folgende Zeile ein:

plugin_dir = /usr/lib/mysql/plugin

Ubuntu nutzt AppArmor um zu regeln, welche Programme ausgeführt bzw. geladen werden dürfen. Also müssen wir AppArmor über den neuen Plugin-Ordner informieren:

$ sudo vi /etc/apparmor.d/usr.sbin.mysqld

Wir fügen folgende Zeile hinzu:

/usr/lib/mysql/plugin/* mr,

Danach AppArmor und MySQL neu starten:

$ sudo /etc/init.d/apparmor restart
$ sudo /etc/init.d/mysql restart

Zu guter Letzt installieren wir das Plugin:

$ mysql -u root -p
mysql> INSTALL PLUGIN sphinx SONAME 'ha_sphinx.so';
Query OK, 0 rows affected (0.00 sec)

Danach sollte Sphinx als Engine auftauchen und die “Support”-Spalte sollte “YES” enthalten:

mysql> show engines;
+------------+----------+---------------------------------------------------------+
| Engine     | Support  | Comment                                                 |
+------------+----------+---------------------------------------------------------+
| MyISAM     | DEFAULT  | Default engine as of MySQL 3.23 with great performance  |
  ...
| SPHINX     | YES      | Sphinx storage engine 0.9.9                             |
  ...
+------------+----------+---------------------------------------------------------+
13 rows in set (0.00 sec)