Skip navigation links
15.5 Die Erzeugung von Handlern »
Section Navigation      [Toggle]

15.4. Erstellung des Handlerton

Der Handlerton (eine Abkürzung für „Handler Singleton“) definiert die Speicher-Engine und enthält Funktionszeiger auf diejenigen Funktionen, die für die Speicher-Engine als Ganzes gelten, im Gegensatz zu jenen Funktionen, die auf Tabellenebene arbeiten. Dazu gehören beispielsweise die Transaktionsfunktionen für Commits und Rollbacks.

Hier sehen Sie ein Beispiel aus der Speicher-Engine EXAMPLE. 

handlerton example_hton= {
  "EXAMPLE",
  SHOW_OPTION_YES,
  "Example storage engine", 
  DB_TYPE_EXAMPLE_DB,
  NULL,    /* Initialisierung */
  0,       /* Slot */
  0,       /* Savepoint-Größe */
  NULL,    /* close_connection */
  NULL,    /* Savepoint */
  NULL,    /* Rollback zum Savepoint */
  NULL,    /* Savepoint freigeben */
  NULL,    /* Commit */
  NULL,    /* Rollback */
  NULL,    /* Prepare */
  NULL,    /* Recover */
  NULL,    /* commit_by_xid */
  NULL,    /* rollback_by_xid */
  NULL,    /* create_cursor_read_view */
  NULL,    /* set_cursor_read_view */
  NULL,    /* close_cursor_read_view */
  example_create_handler,    /* Neuen Handler anlegen */
  NULL,    /* Eine Datenbank löschen */
  NULL,    /* Panik-Aufruf */
  NULL,    /* Temporäre Latches freigeben */
  NULL,    /* Statistik aktualisieren */
  NULL,    /* Konsistenten Snapshot starten */
  NULL,    /* Logs auf die Platte schreiben */
  NULL,    /* Status anzeigen */
  NULL,    /* Replication Report Sent Binlog */
  HTON_CAN_RECREATE
};

Es folgt die Definition des Handlerton aus handler.h: 

typedef struct
  {
    const char *name;
    SHOW_COMP_OPTION state;
    const char *comment;
    enum db_type db_type;
    bool (*init)();
    uint slot;
    uint savepoint_offset;
    int  (*close_connection)(THD *thd);
    int  (*savepoint_set)(THD *thd, void *sv);
    int  (*savepoint_rollback)(THD *thd, void *sv);
    int  (*savepoint_release)(THD *thd, void *sv);
    int  (*commit)(THD *thd, bool all);
    int  (*rollback)(THD *thd, bool all);
    int  (*prepare)(THD *thd, bool all);
    int  (*recover)(XID *xid_list, uint len);
    int  (*commit_by_xid)(XID *xid);
    int  (*rollback_by_xid)(XID *xid);
    void *(*create_cursor_read_view)();
    void (*set_cursor_read_view)(void *);
    void (*close_cursor_read_view)(void *);
    handler *(*create)(TABLE *table);
    void (*drop_database)(char* path);
    int (*panic)(enum ha_panic_function flag);
    int (*release_temporary_latches)(THD *thd);
    int (*update_statistics)();
    int (*start_consistent_snapshot)(THD *thd);
    bool (*flush_logs)();
    bool (*show_status)(THD *thd, stat_print_fn *print, enum ha_stat_type stat);
    int (*repl_report_sent_binlog)(THD *thd, char *log_file_name, my_off_t end_offset);
    uint32 flags;                                
  } handlerton;

Es gibt insgesamt 30 Handlerton-Elemente, von denen aber nur wenige obligatorisch sind (insbesondere die ersten vier Elemente und die create()-Funktion).

  1. Der Name der Speicher-Engine. Dieser Name wird beim Anlegen von Tabellen verwendet (CREATE TABLE ... ENGINE = FOO;).

  2. Der Wert, der im Status-Feld angezeigt wird, wenn ein Benutzer den Befehl SHOW STORAGE ENGINES eingibt.

  3. Der Kommentar zur Speicher-Engine, eine Beschreibung, die durch den Befehl SHOW STORAGE ENGINES angezeigt wird.

  4. Ein Integer, der die Speicher-Engine im MySQL Server eindeutig bezeichnet. Die von den eingebauten Speicher-Engines benutzten Konstanten werden in der Datei handler.h definiert. Selbst erstellte Engines sollten DB_TYPE_CUSTOM verwenden.

  5. Ein Funktionszeiger auf die Initialisierungsfunktion der Speicher-Engine. Diese Funktion wird nur ein einziges Mal beim Starten des Servers aufgerufen, damit die Speicher-Engine-Klasse vor der Instanziierung der Handler die notwendigen Aufräumarbeiten erledigen kann.

  6. Der Slot. Jede Speicher-Engine hat ihren eigenen Speicherbereich (in Wirklichkeit ein Zeiger) im thd zur Speicherung von Verbindungsdaten für jede Verbindung. Angesprochen wird er mit thd->ha_data[foo_hton.slot]. Die Slot-Nummer wird von MySQL nach dem Aufruf von foo_init() initialisiert. Weitere Informationen über thd finden Sie unter Abschnitt 15.16.3, „Implementierung von ROLLBACK“.

  7. Der Savepoint-Offset. Um Daten pro Savepoint speichern zu können, besitzt die Speicher-Engine einen Speicherbereich in der angeforderten Größe (0, wenn kein Savepoint-Speicher notwendig ist).

    Der Savepoint-Offset muss als fester Wert mit der Größe des benötigten Speichers initialisiert werden, um Daten pro Savepoint speichern zu können. Nach foo_init wird er auf einen Offset des Savepoint-Speicherbereichs umgestellt und muss nicht mehr von der Speicher-Engine verwendet werden.

    Mehr zum Thema unter Abschnitt 15.16.5.1, „Den Savepoint-Offset angeben“.

  8. Transaktionssichere Speicher-Engines bereinigen den ihrem Slot zugewiesenen Speicher.

  9. Ein Funktionszeiger auf die Handler-Funktion savepoint_set(). Dieser wird genutzt, um einen Savepoint anzulegen und in dem entsprechend großen zugewiesenen Arbeitsspeicherbereich abzulegen.

    Mehr zum Thema unter Abschnitt 15.16.5.2, „Implementierung der Funktion savepoint_set“.

  10. Ein Funktionszeiger auf die Handler-Funktion rollback_to_savepoint(). Dieser wird verwendet, um während einer Transaktion zu einem Savepoint zurückzukehren. Er wird nur für Speicher-Engines angelegt, die Savepoints unterstützen.

    Mehr zum Thema unter Abschnitt 15.16.5.3, „Implementierung der Funktion savepoint_rollback()“.

  11. Ein Funktionszeiger auf die Handler-Funktion release_savepoint(). Er wird verwendet, um die Ressourcen eines Savepoints während einer Transaktion freizugeben. Der Zeiger wird optional für Speicher-Engines, die Savepoints unterstützen, angelegt.

    Mehr zum Thema unter Abschnitt 15.16.5.4, „Implementierung der Funktion savepoint_release()“.

  12. Ein Funktionszeiger auf die Handler-Funktion commit(). Wird verwendet, um eine Transaktion festzuschreiben. Er wird nur für Speicher-Engines angelegt, die Savepoints unterstützen.

    Mehr zum Thema unter Abschnitt 15.16.4, „Implementierung von COMMIT“.

  13. Ein Funktionszeiger auf die Handler-Funktion rollback(). Wird verwendet, um eine Transaktion zurückzurollen. Er wird nur für Speicher-Engines angelegt, die Savepoints unterstützen.

    Mehr zum Thema unter Abschnitt 15.16.3, „Implementierung von ROLLBACK“.

  14. Erforderlich für transaktionssichere XA-Speicher-Engines. Bereitet eine Transaktion auf das Commit vor.

  15. Erforderlich für transaktionssichere XA-Speicher-Engines. Gibt eine Liste von Transaktionen zurück, die sich im vorbereiteten Zustand befinden.

  16. Erforderlich für transaktionssichere XA-Speicher-Engines. Schreibt die Transaktion XID fest.

  17. Erforderlich für transaktionssichere XA-Speicher-Engines. Rollt die Transaktion XID zurück.

  18. Wird beim Anlegen eines Cursors aufgerufen, damit die Speicher-Engine eine konsistente Read-View erzeugen kann.

  19. Wird aufgerufen, um auf eine bestimmte konsistente Read-View umzustellen.

  20. Wird aufgerufen, um eine bestimmte Read-View zu schließen.

  21. OBLIGATORISCH . Erzeugt eine Handler-Instanz und gibt sie zurück.

    Mehr zum Thema unter Abschnitt 15.5, „Die Erzeugung von Handlern“.

  22. Wird verwendet, wenn die Speicher-Engine beim Löschen eines Schemas besondere Maßnahmen ergreifen muss (wie zum Beispiel eine Speicher-Engine, die Tablespaces verwendet).

  23. Bereinigungsfunktion, die nach dem Herunterfahren oder Abstürzen eines Servers aufgerufen wird.

  24. InnoDB-spezifische Funktion.

  25. InnoDB-spezifische Funktion, die beim Start von SHOW ENGINE InnoDB STATUS aufgerufen wird.

  26. Funktion, die aufgerufen wird, um einen konsistenten Read zu beginnen.

  27. Wird aufgerufen, um anzuzeigen, dass die Logs auf einem zuverlässigen Speichermedium gespeichert werden sollen.

  28. Liefert für Menschen lesbare Statusinformationen über die Speicher-Engine für SHOW ENGINE foo STATUS.

  29. InnoDB-spezifische Funktion, die zur Replikation verwendet wird.

  30. Handlerton-Flags, welche die Fähigkeiten der Speicher-Engine anzeigen. Die möglichen Werte sind in sql/handler.h definiert und werden hier noch einmal aufgeführt: 

    #define HTON_NO_FLAGS                 0
#define HTON_CLOSE_CURSORS_AT_COMMIT (1 << 0)
#define HTON_ALTER_NOT_SUPPORTED     (1 << 1)
#define HTON_CAN_RECREATE            (1 << 2)
#define HTON_FLUSH_AFTER_RENAME      (1 << 3)
#define HTON_NOT_USER_SELECTABLE     (1 << 4)

    HTON_ALTER_NOT_SUPPORTED zeigt an, dass die Speicher-Engine keine ALTER TABLE-Anweisungen annehmen kann. Die FEDERATED-Speicher-Engine ist ein Beispiel dafür.

    HTON_FLUSH_AFTER_RENAME zeigt an, dass FLUSH LOGS nach der Umbenennung einer Tabelle aufgerufen werden muss.

    HTON_NOT_USER_SELECTABLE bedeutet, dass die Speicher-Engine nicht angezeigt werden darf, wenn ein Benutzer SHOW STORAGE ENGINES aufruft. Wird für System-Speicher-Engines wie zum Beispiel die Dummy-Engine für Binärlogs verwendet.

Dies ist eine Übersetzung des MySQL-Referenzhandbuchs, das sich auf dev.mysql.com befindet. Das ursprüngliche Referenzhandbuch ist auf Englisch, und diese Übersetzung ist nicht notwendigerweise so aktuell wie die englische Ausgabe. Das vorliegende deutschsprachige Handbuch behandelt MySQL bis zur Version 5.1.