Man kann eine Instanz eines Adapters erzeugen, indem man den Konstruktor verwendet. Ein Adapter Konstruktur benötigt ein Argument, wobei es sich um ein Array mit Parametern für die Verbindung handelt.

$db = new Zend_Db_Adapter_Pdo_Mysql(array(
    'host'     => '127.0.0.1',
    'username' => 'webuser',
    'password' => 'xxxxxxxx',
    'dbname'   => 'test'
));

Als Alternative zur direkten Nutzung des Konstruktors kann man auch eine Instanz des Adapters erzeugen indem man die statische Methode Zend_Db::factory() nutzt. Diese Methode lädt die Adapterklasse dynamisch bei Aufruf unter Nutzung von Zend_Loader::loadClass().

Das erste Argument ist ein String der den Namen der Adapterklasse enthält. Zum Beispiel entspricht der String 'Pdo_Mysql' der Klasse Zend_Db_Adapter_Pdo_Mysql. Das zweite Argument ist das gleiche Array von Parametern wie bei der Verwendung des Adapter Konstruktors.

// Wir benötigen das folgende Statement nicht da die
// Zend_Db_Adapter_Pdo_Mysql Datei für uns durch die Factory
// Methode von Zend_Db geladen wird

// require_once 'Zend/Db/Adapter/Pdo/Mysql.php';

// Lädt automatisch die Klasse Zend_Db_Adapter_Pdo_Mysql
// und erzeugt eine Instanz von Ihr.
$db = Zend_Db::factory('Pdo_Mysql', array(
    'host'     => '127.0.0.1',
    'username' => 'webuser',
    'password' => 'xxxxxxxx',
    'dbname'   => 'test'
));

Wenn eine eigene Klasse geschrieben wird, die Zend_Db_Adapter_Abstract erweitert aber nicht mit dem Präfix "Zend_Db_Adapter" beginnt, kann die factory() Methode verwendet werden um den Adapter zu Laden wenn der führende Teil der Adapter Klasse mit dem 'adapterNamespace' Schlüssel im Parameter Array spezifiziert wird.

// Wir müssen die Datei der Adapter Klasse nicht laden
// weil Sie für uns durch die Factory Methode von Zend_Db geladen wird

// Die MyProject_Db_Adapter_Pdo_Mysql Klasse automatisch laden
// und eine Instanz von Ihr erstellen.
$db = Zend_Db::factory('Pdo_Mysql', array(
    'host'             => '127.0.0.1',
    'username'         => 'webuser',
    'password'         => 'xxxxxxxx',
    'dbname'           => 'test',
    'adapterNamespace' => 'MyProject_Db_Adapter'
));

Optional kann jedes Argument der factory() Methode als Objekt des Typs Zend_Config spezifiziert werden.

Wenn das erste Argument ein Config Objekt ist, wird erwartet das es eine Eigenschaft enthält die adapter heißt und einen String enthält der nach dem Adapter Basis Klassen Namen benannt ist. Optional kann das Objekt eine Eigenschaft genannt params enthalten, mit Subeigenschaften korrespondierend zu den Parameter Namen des Adapters. Das wird nur verwendet wenn das zweite Argument für die factory() Methode nicht angegeben wird.

$config = new Zend_Config(
    array(
        'database' => array(
            'adapter' => 'Mysqli',
            'params'  => array(
                'host'     => '127.0.0.1',
                'dbname'   => 'test',
                'username' => 'webuser',
                'password' => 'secret',
            )
        )
    )
);

$db = Zend_Db::factory($config->database);

Das zweite Argument der factory() Methode kann ein assoziatives Array sein das Einträge enthält die den Parameters des Adapters entsprechen. Dieses Argument ist optional. Wenn das erste Argument vom Typ Zend_Config ist, wird angenommen das es alle Parameter enthält, und das zweite Argument wird ignoriert.

Die folgende Liste erklärt die gemeinsamen Parameter die von Zend_Db Adapterklassen erkannt werden.

$options = array(
    Zend_Db::CASE_FOLDING => Zend_Db::CASE_UPPER
);

$params = array(
    'host'           => '127.0.0.1',
    'username'       => 'webuser',
    'password'       => 'xxxxxxxx',
    'dbname'         => 'test',
    'options'        => $options
);

$db = Zend_Db::factory('Db2', $params);

$options = array(
    Zend_Db::AUTO_QUOTE_IDENTIFIERS => false
);

$params = array(
    'host'           => '127.0.0.1',
    'username'       => 'webuser',
    'password'       => 'xxxxxxxx',
    'dbname'         => 'test',
    'options'        => $options
);

$db = Zend_Db::factory('Pdo_Mysql', $params);

$pdoParams = array(
    PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true
);

$params = array(
    'host'           => '127.0.0.1',
    'username'       => 'webuser',
    'password'       => 'xxxxxxxx',
    'dbname'         => 'test',
    'driver_options' => $pdoParams
);

$db = Zend_Db::factory('Pdo_Mysql', $params);

echo $db->getConnection()
        ->getAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY);

$options = array(
    Zend_Db::ALLOW_SERIALIZATION => false
);

$params = array(
    'host'           => '127.0.0.1',
    'username'       => 'webuser',
    'password'       => 'xxxxxxxx',
    'dbname'         => 'test',
    'options'        => $options
);

$db = Zend_Db::factory('Pdo_Mysql', $params);

Die Erzeugung einer Instanz der Adapterklasse stellt nicht gleichzeitig eine Verbindung zum RDBMS her. Der Adapter speichert die Verbindungsparameter und stellt die tatsächliche Verbindung bei Bedarf her, wenn die erste Anfrage ausgeführt wird. Dies stellt sicher, dass die Erzeugung eines Adapterobjekts schnell und sparsam ist. Dadurch kann auch dann eine Instanz eines Adapters erzeugt werden, wenn nicht zwingend eine Datenbankanfrage für die aktuell gelieferte Darstellung der Anwendung benötigt wird.

Wenn der Adapter zwingend eine Verbindung zum RDBMS herstellen soll, kann die getConnection() Methode verwendet werden. Diese liefert ein Objekt der Verbindung, welches eine Verbindung entsprechend der verwendeten PHP Erweiterung repräsentiert. Wenn zum Beispiel irgendeine der PDO Adapterklassen verwendet wird, dann liefert getConnection() das PDO Object, nachdem es als eine live Verbindung zu der entsprechenden Datenbank initialisiert wurde.

Es kann nützlich sein eine Verbindung zu erzwingen um jegliche Exceptions abzufangen, die als Resultat falscher Konto Berechtigungen oder einem anderen Fehler bei der Verbindung zum RDBMS auftreten. Diese Exceptions treten nicht auf, bis die tatsächliche Verbindung hergestellt ist, daher kann es den Anwendungs-Code vereinfachen, wenn diese Exceptions an einer Stelle bearbeitet werden, und nicht erst bei der ersten Anfrage.

Zusätzlich kann ein Adapter serialisiert werden um Ihn zu speichern, zum Beispiel in einer Session Variable. Das kann sehr nütlich sein, nicht nur für den Adapter selbst, sondern auch für andere Objekte die Ihn verwenden, wie ein Zend_Db_Select Objekt. Standardmäßig, ist es Adaptern erlaubt serialisiert zu werden. Wenn man das nicht will, sollte man die Zend_Db::ALLOW_SERIALIZATION Option mit FALSE übergeben, wie im Beispiel anbei gezeigt. Um das Prinzip von Lazy Connections zu erlauben, wird der Adapter sich selbst nicht wiederverbinden wenn er deserialisiert wird. Man muß getConnection() selbst aufrufen. Mann kann den Adapter dazu bringen sich automatisch wieder zu verbinden indem Zend_Db::AUTO_RECONNECT_ON_UNSERIALIZE als Option mit TRUE zum Adapter übergeben wird.

try {
    $db = Zend_Db::factory('Pdo_Mysql', $parameters);
    $db->getConnection();
} catch (Zend_Db_Adapter_Exception $e) {
    // Möglicherweise ein fehlgeschlagener login,
    // oder die RDBMS läuft möglicherweise nicht
} catch (Zend_Exception $e) {
    // Möglicherweise kann factory() die definierte Adapter Klasse nicht laden
}

Man kann eine SQL SELECT Anfrage ausführen und alle Ergebnisse auf einmal mit der fetchAll() Methode abrufen.

Das erste Argument dieser Methode ist ein String der die SELECT Anweisung enthält. Als Alternative kann das erste Argument auch ein Objekt der Zend_Db_Select Klasse sein. Der Adapter konvertiert dieses automatisch in einen String der die SELECT Anweisung repräsentiert.

Das zweite Argument von fetchAll() ist ein Array von Werten die Parameterplatzhalter in der SQL Anweisung ersetzen.

$sql = 'SELECT * FROM bugs WHERE bug_id = ?';

$result = $db->fetchAll($sql, 2);

Standardmäßig gibt fetchAll() ein Array von Zeilen, jede als assoziatives Array, zurück. Die Schlüssel von diesem assoziativem Array entsprechen den Spalten oder Spaltenaliasen wie sie in der SELECT Anfrage benannt sind.

Man kann einen anderen Stil für das Holen der Ergebnisse mit der setFetchMode() Methode angeben. Die unterstützten Modi werden mit folgenden Konstanten identifiziert:

$db->setFetchMode(Zend_Db::FETCH_OBJ);

$result = $db->fetchAll('SELECT * FROM bugs WHERE bug_id = ?', 2);

// $result ist ein Array von Objekten
echo $result[0]->bug_description;

Die fetchAssoc() Methode gibt Daten in einem Array von assoziativen Array zurück, egal welcher Wert für den fetch-Modus gesetzt wurde, indem die erste Spalte als Array Index verwendet wird.

$db->setFetchMode(Zend_Db::FETCH_OBJ);

$result = $db->fetchAssoc(
    'SELECT bug_id, bug_description, bug_status FROM bugs'
);

// $result ist ein Array von assoziativen Arrays im Geist von fetch mode
echo $result[2]['bug_description']; // Beschreibung von Fehler #2
echo $result[1]['bug_description']; // Beschreibung von Fehler #1

Die fetchCol() Methode gibt Daten in einem Array von Werten zurück, egal welcher Wert für den fetch-Modus gesetzt wurde. Sie gibt nur die erste Spalte der Anfrage zurück. Alle weiteren Spalten der Anfrage werden verworfen. Wenn eine andere Spalte als die Erste benötigt wird sollte dieser Abschnitt beachtet werden.

$db->setFetchMode(Zend_Db::FETCH_OBJ);

$result = $db->fetchCol(
    'SELECT bug_description, bug_id FROM bugs WHERE bug_id = ?', 2);

// Enthält bug_description; bug_id wird nicht zurückgegeben
echo $result[0];

Die fetchPairs() Methode gibt Daten in einem Array von Schlüssel-Wert Paaren zurück, einem assoziativen Array mit einem einzelnen Eintrag pro Zeile. Der Schlüssel dieses assoziativen Arrays wird von der ersten Spalte des SELECT Ergebnisses genommen. Der Wert wird aus der zweiten Spalte des SELECT Ergebnisses genommen. Alle weiteren Spalten des Ergebnisses werden verworfen.

Die SELECT Anfrage sollte so gestaltet sein, dass die erste Spalte nur eindeutige Werte liefert. Wenn doppelte Werte in der ersten Spalte vorkommen, werden entsprechende Einträge in dem assoziativen Array überschrieben.

$db->setFetchMode(Zend_Db::FETCH_OBJ);

$result = $db->fetchAssoc('SELECT bug_id, bug_status FROM bugs');

echo $result[2];

Die fetchRow() Methode gibt Daten entsprechend dem fetch-Modus zurück, jedoch nur die erste Zeile des Ergebnisssatzes.

$db->setFetchMode(Zend_Db::FETCH_OBJ);

$result = $db->fetchRow('SELECT * FROM bugs WHERE bug_id = 2');

// Beachte das $result ein einzelnes Objekt ist, und kein Array von Objekten
echo $result->bug_description;

Die fetchOne() Methode ist wie eine Kombination von fetchRow() mit fetchCol(), gibt also nur die erste Zeile des Ergebnisssatze zurück, und von dieser auch nur den Wert der ersten Spalte. Daher wird nur ein einziger scalarer Wert zurückgegeben, kein Array und auch kein Objekt.

$result = $db->fetchOne('SELECT bug_status FROM bugs WHERE bug_id = 2');

// this is a single string value
echo $result;

Neue Zeilen können in die Datenbank mit der insert() Methode eingefügt werden. Das erste Argument ist ein String der die Tabelle benennt, und das zweite Argument ist ein assoziatives Array das den Spaltennamen Datenwerte zuordnet.

$data = array(
    'created_on'      => '2007-03-22',
    'bug_description' => 'Etwas falsch',
    'bug_status'      => 'NEW'
);

$db->insert('bugs', $data);

Spalten die nicht in dem Array definiert sind, werden nicht an die Datenbank übergeben. Daher folgen sie den selben Regeln denen eine SQL INSERT Anweisung folgt: wenn die Spalte eine DEFAULT Klausel hat, so bekommt die Spalte der neuen Zeile diesen Wert. Andernfalls behält sie den Status NULL.

Standardmäßig werden die Daten in dem Array mit Parametern eingefügt. Dies reduziert das Risiko einiger Typen von Sicherheitsproblemen. Die Werte in dem Array müssen daher nicht escaped oder quotiert übergeben werden.

Einige Werte in dem Array könnten als SQL Expressions benötigt werden, in diesem Fall dürfen sie nicht in Anführungszeichen stehen. Standardmäßig werden alle übergebenen String-Werte als String-literale behandelt. Um anzugeben das ein Wert eine SQL Expression ist, und daher nicht quotiert werden soll, muss der Wert als ein Objekt des Typs Zend_Db_Expr übergeben werden, und nicht als einfacher String.

$data = array(
    'created_on'      => new Zend_Db_Expr('CURDATE()'),
    'bug_description' => 'Etwas falsch',
    'bug_status'      => 'NEW'
);

$db->insert('bugs', $data);

Einige RDBMS Marken unterstützen Auto-Incrementierung von Primärschlüsseln. Eine Tabelle die so definiert ist generiert automatisch einen Primärschlüsselwert während des INSERT's einer neuen Zeile. Der Rückgabewert der insert() Methode ist nicht die letzte eingefügte ID, weil die Tabelle keine Auto-Increment Spalte haben könnte. Statt dessen ist der Rückgabewert die Anzahl der betroffenen Zeilen (normalerweise 1).

Wenn die Tabelle mit einem Auto-Increment Primärschlüssel definiert ist, kann die lastInsertId() Methode nach dem INSERT aufgerufen werden. Diese Methode gibt den letzten generierten Wertim Rahmen der aktuellen Datenbankverbindung zurück.

$db->insert('bugs', $data);

// Gib den letzten durch eine auto-inkrement Spalte erzeugten Wert zurück
$id = $db->lastInsertId();

Einige RDBMS Marken unterstützen ein Sequenz-Objekt, welches eindeutige Werte generiert, die als Primärschlüsselwerte dienen. Um Sequenzen zu unterstützen, akzeptiert die lastInsertId() Method zwei optionale String Argumente. Diese Argumente benennen die Tabelle und die Spalte, in der Annahme das die Konvention beachtet wurde, dass eine Sequenz mit der Tabelle und der Spalte benannt wurde, für die sie Werte generiert plus dem Anhang "_seq". Dies basiert auf der Konvention die von PostgreSQL verwendet wird, wenn Sequenzen für SERIAL Spalten benannt werden. Zum Beispiel würde eine Tabelle "bugs" mit der Primärschlüsselspalte "bug_id" eine Sequenz als "bugs_bug_id_seq" benennen.

$db->insert('bugs', $data);

// Gib den letzten durch die 'bugs_bug_id_seq' Sequenz erstellten Wert zurück
$id = $db->lastInsertId('bugs', 'bug_id');

// Gib, alternativ, den letzten durch die 'bugs_seq' Sequenz
// erstellten Wert zurück
$id = $db->lastInsertId('bugs');

Wenn der Name des Squenz-Objekts nicht dieser Konvention folgt muss die lastSequenceId() Methode an Stelle verwendet werden. Diese Methode benötigt ein String Argument, welches die Sequenz wörtlich benennt.

$db->insert('bugs', $data);

// Gib den letzten durch die 'bugs_id_gen' Sequenz erstellten Wert zurück.
$id = $db->lastSequenceId('bugs_id_gen');

Bei RDBMS Marken die keine Sequenzen unterstützen, dazu gehören MySQL, Microsoft SQL Server und SQLite, werden die Argumente an die lastInsertId() Methode ignoriert, und der zurück gegebene Wert ist der zuletzt für eirgendeine Tabelle während einer INSERT Operation generierte Wert innerhalb der aktuellen Verbindung. Für diese RDBMS Marken gibt die lastSequenceId() Methode immer NULL zurück.

Zeilen in der Datenbank können mit der update() Methode eines Adapters aktualisiert werden. Diese Methode benötigt drei Argumente: Das Erste ist der Name der Tabelle und das Zweite ist ein assoziatives Array das den zu Ändernden Spalten neue Werte zuordnet.

Die Werte des Datenarrays werden als String Literale behandelt. Beachte diesen Abschnitt für Informationen zur Nutzung von SQL Expressions in dem Datenarray.

Das dritte Argument ist ein String der aus einer SQL Expression besteht, die genutzt wird um Kriterien für die Auswahl der zu ändernden Zeilen zu bestimmen. Die Werte und Bezeichner in diesem Argument werden nicht escaped oder quotiert. An dieser Stelle muss darauf geachtet werden das sichergestellt ist, das dynamischer Inhalt sicher in diesen String eingefügt wird. In diesem Abschnitt sind Methoden beschrieben die dabei helfen können.

Der Rückgabewert ist die Anzahl der Betroffenen Zeilen der UPDATE Operation.

$data = array(
    'updated_on'      => '2007-03-23',
    'bug_status'      => 'FIXED'
);

$n = $db->update('bugs', $data, 'bug_id = 2');

Wenn das dritte Argument ausgelassen wird, werden alle Zeilen der Tabelle mit den Werten des Datenarrays aktualisiert.

Wenn ein Array mit Strings als drittes Argument übergeben wird, werden diese Strings als eine Expression von Ausdrücken, getrennt von AND Operatoren, zusammengefügt.

Wenn man ein Array von Arrays als drittes Argument anbietet, werden die Werte automatisch in die Schlüssel eingefügt. Diese werden dann zusammen zu Ausdrücken verbunden, getrennt von AND Operatoren.

$data = array(
    'updated_on'      => '2007-03-23',
    'bug_status'      => 'FIXED'
);

$where[] = "reported_by = 'goofy'";
$where[] = "bug_status = 'OPEN'";

$n = $db->update('bugs', $data, $where);

// Der erstellte SQL Syntax ist:
//  UPDATE "bugs" SET "update_on" = '2007-03-23', "bug_status" = 'FIXED'
//  WHERE ("reported_by" = 'goofy') AND ("bug_status" = 'OPEN')

$data = array(
    'updated_on'      => '2007-03-23',
    'bug_status'      => 'FIXED'
);

$where['reported_by = ?'] = 'goofy';
$where['bug_status = ?']  = 'OPEN';

$n = $db->update('bugs', $data, $where);

// Das resultierende SQL ist:
//  UPDATE "bugs" SET "update_on" = '2007-03-23', "bug_status" = 'FIXED'
//  WHERE ("reported_by" = 'goofy') AND ("bug_status" = 'OPEN')

Daten können aus einer Datenbanktabelle mit der delete() Methode gelöscht werden. Diese Methode benötigt zwei Argumente: Das erste ist ein String der die Tabelle benennt.

Das zweite Argument ist ein String der aus einer SQL Expression besteht, welche Kriterien für die zu löschenden Zeilen enthält. Die Werte und Bezeichner in diesem Argument werden nicht escaped quotiert. An dieser Stelle muss darauf geachtet werden das sichergestellt ist, das dynamischer Inhalt sicher in diesen String eingefügt wird. In diesem Abschnitt sind Methoden beschrieben die dabei helfen können.

Der Rückgabewert ist die Anzahl der Betroffenen Zeilen der DELETE Operation.

$n = $db->delete('bugs', 'bug_id = 3');

Wenn das zweite Argument ausgelassen wird, werden alle Zeilen der Tabelle gelöscht.

Wenn ein Array mit Strings als zweites Argument übergeben wird, werden diese Strings als eine Expression von Ausdrücken, getrennt von AND Operatoren, zusammengefügt.

Wenn man ein Array von Arrays als zweites Argument übergibt, werden die Werte automatisch in die Schlüssel eingefügt. Diese werden dann zusammen zu Ausdrücken verbunden, getrennt durch AND Operatoren.

Die quote() Methode benötigt ein Argument, einen skalaren String Wert. Sie gibt den Wert mit ersetzten speziellen Zeichen, passend zu dem eingesetzten RDBMS, und umgeben von Stringwertbegrenzern zurück. Der Standard SQL Stringwertbegrenzer ist das einfache Anführungszeichen (').

$name = $db->quote("O'Reilly");
echo $name;
// 'O\'Reilly'

$sql = "SELECT * FROM bugs WHERE reported_by = $name";

echo $sql;
// SELECT * FROM bugs WHERE reported_by = 'O\'Reilly'

Zu beachten ist, dass der Rückgabewert von quote() die Stringwertbegrenzer enthält. Dies ist ein Unterschied zu anderen Methoden die spezielle Zeichen ersetzen, aber keine Stringwertbegrenzer hinzufügen, wie z.B. mysql_real_escape_string().

Es kann notwendig sein Werte in Anführungszeichen zu setzen oder nicht je nach dem Kontext des SQL Datentyps in dem diese verwendet werden. Zum Beispiel darf, in einigen RDBMS Typen, ein Integer Wert nicht wie in String in Anführungszeichen gesetzt werden, wenn dieser mit einer Integer-Typ Spalte oder einem Ausdruck verglichen wird. Anders gesagt ist das folgende in einigen SQL Implementationen ein Fehler, wenn angenommen wird dass intColumn einen SQL Datentyp von INTEGER besitzt

SELECT * FROM atable WHERE intColumn = '123'

Es kann das optionale zweite Argument der quote() Methode verwendet werden um die Verwendung von Anführungszeichen selektiv für den spezifizierten SQL Datentyp auszuwählen.

$value = '1234';
$sql = 'SELECT * FROM atable WHERE intColumn = '
     . $db->quote($value, 'INTEGER');

Jede Zend_Db_Adapter Klasse hat den Namen des nummerischen SQL Datentyps für die respektive Marke von RDBMS codiert. Man kann genauso die Konstanten Zend_Db::INT_TYPE, Zend_Db::BIGINT_TYPE, und Zend_Db::FLOAT_TYPE verwenden um Code in einem mehr RDBMS-unabhängigen Weg zu schreiben.

Zend_Db_Table definiert SQL Typen zu quote() automatisch wenn SQL Abfragen erstellt werden die einer Tabellen Schlüssel Spalte entsprechen.

Die typischste Anwendung von Quotierung ist das Einfügen von PHP Variablen in eine SQL Expression oder Anweisung. Die quoteInto() Methode kann verwendet werden um dies in einem Schritt zu erledigen. Die Methode benötigt zwei Argumente: Das erste Argument ist ein String der ein Platzhaltersymbol (?) enthält, und das zweite Argument ist ein Wert oder eine PHP Variable die den Platzhalter ersetzen soll.

Das Platzhaltersymbol ist das gleiche Symbol wie es von vielen RDBMS Marken für Lage betreffende Parameter verwendet wird, aber die quoteInto() Methode bildet nur Abfrageparameter nach. Die Methode fügt den Wert in den String ein, ersetzt dabei spezielle Zeichen und fügt Stringwertbegrenzer ein. Echte Abfrageparameter sorgen für eine Trennung von SQL String und Parametern wenn die Anweisung vom RDBMS Server verarbeitet wird.

$sql = $db->quoteInto("SELECT * FROM bugs WHERE reported_by = ?", "O'Reilly");

echo $sql;
// SELECT * FROM bugs WHERE reported_by = 'O\'Reilly'

Man kann den optionalen dritten Parameter von quoteInto() verwenden um den SQL Datentyp zu spezifizieren. Nummerische Datentypen werden nicht in Anführungszeichen gesetzt und andere Typen werden in Anführungszeichen gesetzt.

$sql = $db
    ->quoteInto("SELECT * FROM bugs WHERE bug_id = ?", '1234', 'INTEGER');

echo $sql;
// SELECT * FROM bugs WHERE reported_by = 1234

Werte könnten nicht der einzige Teil der SQL Syntax sein, der Variabel sein soll. Wenn PHP Variablen genutzt werden um Tabellen, Spalten oder andere Bezeichner in den SQL Anweisungen zu benennen, könnte es nötig sein das diese Strings ebenfalls quotiert werden müssen. Standardmäßig haben SQL Bezeichner Syntaxregeln wie PHP und die meißten anderen Programmiersprachen. Zum Beispiel dürfen Bezeichner keine Leerzeichen, bestimmte Punktierung, spezielle Zeichen oder Internationale Zeichen enthalten. Außerdem sind bestimmte Wörter für die SQL Syntax reserviert und dürfen nicht als Bezeichner verwendet werden.

Dennoch hat SQL ein Feature mit Namen delimited identifiers (begrenzte Bezeichner), welches eine größere Auswahl bei der Schreibweise von Bezeichnern erlaubt. Wenn ein SQL Bezeichner mit dem richtigen Typ von´ Quotierung eingeschlossen ist, können Schreibweisen für die Bezeichner verwendet werden, die ohne der Quotierung ungültig wären. Begrenzte Bezeichner können Leerzeichen, Punktierung oder internationale Zeichen enthalten. Desweiteren dürfen auch von der SQL Syntax reservierte Wörter verwendet werden, wenn sie von Bezeichner Begrenzungszeichen eingeschlossen sind.

Die quoteIdentifier() Methode funktioniert wie quote(), aber sie wendet die Bezeichner Begrenzungszeichen entsprechend dem verwendeten Adapter an. Zum Beispiel nutzt Standard SQL doppelte Anführungszeichen (") zum begrenzen von Bezeichnern und die meisten der RDBMS Marken nutzen ebenfalls dieses Symbol. MySQL hingegen benutzt back-quotes (`) als Standardzeichen. Die quoteIdentifier() Methode ersetzt außerdem spezielle Zeichen im String Argument.

// Wir könnten einen Tabellennamen haben, der ein in SQL reserviertes Wort ist
$tableName = $db->quoteIdentifier("order");

$sql = "SELECT * FROM $tableName";

echo $sql
// SELECT * FROM "order"

SQL begrenzte Bezeichner beachten die Groß- und Kleinschreibung, im Gegensatz zu nicht quotierten Bezeichnern. Daher muss, bei Verwendung von begrenztern Bezeichnern, die Schreibung der Bezeichner genau der Schreibung der Bezeichner im Tabellenschema entsprechen. Einschließlich der Groß- und Kleinschreibung.

In den meisten Fällen wo SQL innerhalb der Zend_Db Klassen generiert wird, werden standardmäßig alle Bezeichner automatisch begrenzt. Dieses Verhalten kann mit der Option Zend_Db::AUTO_QUOTE_IDENTIFIERS geändert werden. Dies muss beim Instanziieren des Adapters wie in diesem Beispiel angegeben werden.