Um die Tabelle für die Anfrage anzugeben, wird die Methode from() verwendet. Der Tabellenname kann als einfacher String übergeben werden. Zend_Db_Select wendet Quotierung auf Bezeichner an, es können also auch spezielle Zeichen verwendet werden.

// Erstellen dieser Anfrage:
//   SELECT *
//   FROM "products"

$select = $db->select()
             ->from('products');

Es kann auch der Beziehungsname (auch Aliasname genannt) einer Tabelle angegeben werden. Anstelle eines einfachen Strings muss dann ein assoziatives Array übergeben werden, welches den Beziehungsnamen dem tatsächlichen Tabellennamen zuordnet. In anderen Bedingungen der SQL-Anfrage kann dann dieser Beziehungsname verwendet werden. Wenn die Anfrage mehr als eine Tabelle verbindet, generiert Zend_Db_Select eindeutige Beziehungsnamen basierend auf den Tabellennamen, wenn keine Beziehungsnamen angegeben wurden.

// Erzeugt diese Anfrage:
//   SELECT p.*
//   FROM "products" AS p

$select = $db->select()
             ->from(array('p' => 'products'));

Einige RDBMS-Marken unterstützen einen voran stehenden Schemenbezeichner für eine Tabelle. Der Tabellenname kann mit "schemaName.tabellenName" angegeben werden, Zend_Db_Select quotiert die einzelnen Teile für sich. Der Schemaname kann aber auch separat angegeben werden. Ein Schemaname, der mit dem Tabellennamen angegeben wurde, bekommt Vorrang, falls beides angegeben wurde.

// Erzeut diese Anfrage:
//   SELECT *
//   FROM "myschema"."products"

$select = $db->select()
             ->from('myschema.products');

// oder

$select = $db->select()
             ->from('products', '*', 'myschema');

Im zweiten Argument der Methode from() kann angegeben werden, welche Spalten der Tabelle ausgelesen werden sollen. Werden keine Spalten angegeben, so gilt der Standardwert *, der SQL Platzhalter für alle Spalten.

Die Spalten können in einem einfachen Array von Strings oder einem assoziativen Array, in dem Aliasnamen den Spaltennamen zugewiesen werden, angegeben werden. Soll nur eine einzelne Spalte ohne Aliasnamen ausgelesen werden, so kann auch ein einfacher String übergeben werden.

Wird ein leeres Array übergeben, so werden auch keine Spalten der Tabelle in den Ergebnissatz aufgenommen. Ein Codebeispiel gibt es unter Codebeispiel bei der Methode join().

Der Spaltenname kann mit "beziehungsName.spaltenName" angegeben werden. Zend_Db_Select quotiert die einzelnen Teile für sich. Wird kein Beziehungsname für die Spalte angegeben, dann wird der Beziehungsname der Tabelle der aktuellen Methode from() verwendet.

// Erzeugt diese Anfrage:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id', 'product_name'));

// Erzeugt dieselbe Anfrage, Angabe von Beziehungsnamen:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('p.product_id', 'p.product_name'));

// Erzeugt diese Anfrage mit einem Alias für eine Spalte:
//   SELECT p."product_id" AS prodno, p."product_name"
//   FROM "products" AS p

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('prodno' => 'product_id', 'product_name'));

Spalten in einer SQL-Anfrage sind manchmal Ausdrücke, keine einfachen Spaltennamen einer Tabelle. Ausdrücke dürfen keine Beziehungsnamen oder Quotierungen bekommen. Wenn der Spaltenstring runde Klammern enthält, erkennt Zend_Db_Select dies als Ausdruck.

Es kann auch ein Objekt des Typs Zend_Db_Expr erzeugt werden um zu verhindern, dass ein String wie ein Spaltenname behandelt wird. Zend_Db_Expr ist eine Minimalklasse, die einen String enthält. Zend_Db_Select erkennt Objekte des Typs Zend_Db_Expr und konvertiert diese in Strings, nimmt aber keine Änderungen daran vor, wie Quotierung oder Beziehungsnamen.

// Erzeugt diese Anfrage:
//   SELECT p."product_id", LOWER(product_name)
//   FROM "products" AS p
// Ein Ausdruck eingeschlossen von runden Klammern wird zu Zend_Db_Expr.

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id', 'LOWER(product_name)'));

// Erzeugt diese Anfrage:
//   SELECT p."product_id", (p.cost * 1.08) AS cost_plus_tax
//   FROM "products" AS p

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id',
                          'cost_plus_tax' => '(p.cost * 1.08)'));

// Erzeugt diese Anfrage unter ausdrücklicher Verwendung  von Zend_Db_Expr:
//   SELECT p."product_id", p.cost * 1.08 AS cost_plus_tax
//   FROM "products" AS p

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id',
                          'cost_plus_tax' =>
                              new Zend_Db_Expr('p.cost * 1.08'))
                    );

In den oben stehenden Fällen ändert Zend_Db_Select den String nicht mit Beziehungsnamen oder Bezeichnerquotierung. Wenn diese Änderungen notwendig sein sollten um Doppeldeutigkeiten aufzulösen, muss dies manuell am String geändert werden.

Wenn die Spaltennamen aus SQL-Schlüsselwörtern bestehen oder spezielle Zeichen enthalten, sollte die Methode quoteIdentifier() verwendet werden und der Rückgabewert in den String eingefügt werden. Die Methode quoteIdentifier() verwendet SQL-Quotierung um Bezeichner abzugrenzen, wodurch klar wird, dass es sich um einen Bezeichner für eine Tabelle oder Spalte handelt, und nicht um einen anderen Teil der SQL-Syntax.

Der Code wird datenbankunabhängiger, wenn die Methode quoteIdentifier() anstelle von direkter Eingabe der Quotierungszeichen verwendet wird, da einige RDBMS-Marken nicht-Standard Symbole für die Quotierung von Bezeichnern verwenden. Die Methode quoteIdentifier() wählt die passenden Quotierungssymbole für den Adaptertyp aus. Die Methode quoteIdentifier() ersetzt außerdem alle Quotierungszeichen innerhalb des Bezeichners.

// Erzeugt folgende Anfrage und quotiert dabei einen Spaltennamen
// "from" im Ausdruck:
//   SELECT p."from" + 10 AS origin
//   FROM "products" AS p

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('origin' =>
                          '(p.' . $db->quoteIdentifier('from') . ' + 10)')
                   );

Es kann Fälle geben, in denen es gewünscht ist, Spalten zu einer bestehenden FROM- oder JOIN-Tabelle hinzuzufügen, nachdem diese Methoden aufgerufen wurden. Die Methode columns() erlaubt es spezifische Spalten an jedem Punkt hinzuzufügen, bevor die Abfrage aufgeführt wird. Die Spalte kann entweder als String oder Zend_Db_Expr oder als Array dieser Elemente angegeben werden. Das zweite Argument dieser Methode kann unterdrückt werden, was impliziert, dass die Spalten zu der FROM-Tabelle hinzugefügt werden sollen, andernfall muß ein bestehender Korrelationsname verwendet werden.

// Diese Abfrage bauen:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p

$select = $db->select()
             ->from(array('p' => 'products'), 'product_id')
             ->columns('product_name');

// Dieselbe Abfrage bauen, durch Angabe der Korrelationsnamen:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p

$select = $db->select()
             ->from(array('p' => 'products'), 'p.product_id')
             ->columns('product_name', 'p');
             // Alternativ kann columns('p.product_name') verwendet werden

Viele nützliche Anfragen benötigen ein JOIN um mehrere Spalten verschiedener Tabellen miteinander zu kombinieren. Tabellen können zu einer Zend_Db_Select-Anfrage mit der Methode join() hinzugefügt werden. Die Nutzung dieser Methode ist ähnlich der Methode from(), außer dass in den meisten Fällen zusätzlich eine Join-Bedingung angegeben werden kann.

// Erzeugt diese Anfrage:
//   SELECT p."product_id", p."product_name", l.*
//   FROM "products" AS p JOIN "line_items" AS l
//     ON p.product_id = l.product_id

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id', 'product_name'))
             ->join(array('l' => 'line_items'),
                    'p.product_id = l.product_id');

Das zweite Argument der Methode join() ist ein String mit der Join-Bedingung. Dies ist ein Ausdruck die Kriterien angibt, welche Zeilen in der einen Tabelle mit Zeilen einer anderen Tabelle verknüpft werden. Es können Beziehungsnamen in diesem Ausdruck verwendet werden.

Das dritte Argument für join() ist ein Array von Spaltennamen, entsprechend des Arrays der Methode from(). Der Standard ist ebenfalls "*" und unterstützt Beziehungsnamen, Ausdrücke und Zend_Db_Expr in der gleichen Weise wie dem Array von Spaltennamen der Methode from().

Wenn keine Spalten einer Tabelle ausgewählt werden soll, muss ein leeres Array für die Liste der Spaltennamen übergeben werden. Diese Nutzung funktioniert ebenfalls in der Methode from(), aber normalerweise werden einige Spalten der primären Tabelle in den Anfragen benötigt, während möglicherweise keine Spalten der verbundenen Tabelle ausgewählt werden sollen.

// Erzeugt diese Anfrage:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p JOIN "line_items" AS l
//     ON p.product_id = l.product_id

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id', 'product_name'))
             ->join(array('l' => 'line_items'),
                    'p.product_id = l.product_id',
                    array() ); // leere Liste von Spalten

SQL kennt verschiedene Varianten von Joins. In der Liste weiter unten sind Methoden für die verschiedenen Join-Varianten zu finden, die Zend_Db_Select unterstützt.

Zusätzlich zu diesen Join-Methoden können Abfragen durch Verwendung der Methoden JoinUsing vereinfacht werden. Statt dass eine komplette Definition des Joins angegeben wird, kann einfach der Spaltenname übergeben werden, auf welchem gejoint werden soll und das Zend_Db_Select-Objekt vervollständigt die Bedingung alleine.

// Erzeugt diese Abfrage
//   SELECT *
//   FROM "table1"
//   JOIN "table2"
//   ON "table1".column1 = "table2".column1
//   WHERE column2 = 'foo'

$select = $db->select()
             ->from('table1')
             ->joinUsing('table2', 'column1')
             ->where('column2 = ?', 'foo');

Jede der anwendbaren Join-Methoden in der Komponente Zend_Db_Select hat eine entsprechende 'using'-Methode.

Mit der Methode where() können Kriterien angegeben werden, die den Ergebnissatz einschränken. Das erste Argument dieser Methode ist ein SQL-Ausdruck, welche in einer SQL-WHERE-Klausel der Anfrage steht.

// Erzeugt diese Anfrage:
//   SELECT product_id, product_name, price
//   FROM "products"
//   WHERE price > 100.00

$select = $db->select()
             ->from('products',
                    array('product_id', 'product_name', 'price'))
             ->where('price > 100.00');

Das zweite Argument der Methode where() ist optional. Es ist ein Wert, der in den Ausdruck eingesetzt wird. Zend_Db_Select quotiert den Wert und ersetzt ihn für ein Fragezeichen ("?") im Ausdruck.

// Erzeugt diese Anfrage:
//   SELECT product_id, product_name, price
//   FROM "products"
//   WHERE (price > 100.00)

$minimumPrice = 100;

$select = $db->select()
             ->from('products',
                    array('product_id', 'product_name', 'price'))
             ->where('price > ?', $minimumPrice);

Man kann als zweiten Parameter ein Array an die Methode where() übergeben, wenn der SQL-Operator IN verwendet wird.

// Diese Abrage wird gebaut:
//   SELECT product_id, product_name, price
//   FROM "products"
//   WHERE (product_id IN (1, 2, 3))

$productIds = array(1, 2, 3);

$select = $db->select()
             ->from('products',
                    array('product_id', 'product_name', 'price'))
             ->where('product_id IN (?)', $productIds);

Die Methode where() kann mehrere Male in demselben Zend_Db_Select-Objekt aufgerufen werden. Die daraus folgende Anfrage kombiniert die unterschiedlichen Ausdrücke unter Benutzung von AND dazwischen.

// Erzeugt diese Anfrage:
//   SELECT product_id, product_name, price
//   FROM "products"
//   WHERE (price > 100.00)
//     AND (price < 500.00)

$minimumPrice = 100;
$maximumPrice = 500;

$select = $db->select()
            ->from('products',
                   array('product_id', 'product_name', 'price'))
            ->where('price > ?', $minimumPrice)
            ->where('price < ?', $maximumPrice);

Wenn mehrere Ausdrücke mit OR verknüpft werden sollen, kann die Methode orWhere() verwendet werden. Sie wird genauso benutzt wie die Methode where(), außer dass dem angegebenen Ausdruck ein OR vorangestellt wird, anstelle eines AND.

// Erzeugt diese Anfrage:
//   SELECT product_id, product_name, price
//   FROM "products"
//   WHERE (price < 100.00)
//     OR (price > 500.00)

$minimumPrice = 100;
$maximumPrice = 500;

$select = $db->select()
             ->from('products',
                    array('product_id', 'product_name', 'price'))
             ->where('price < ?', $minimumPrice)
             ->orWhere('price > ?', $maximumPrice);

Zend_Db_Select klammert Ausdrücke automatisch mit runden Klammern ein, wenn sie mit einer der Methoden where() oder orWhere() erzeugt wurden. Dies hilft sicherzustellen, dass das Voranstellen von Boolschen Operatoren keine unerwarteten Ergebnisse nach sich zieht.

// Erzeugt diese Anfrage:
//   SELECT product_id, product_name, price
//   FROM "products"
//   WHERE (price < 100.00 OR price > 500.00)
//     AND (product_name = 'Apple')

$minimumPrice = 100;
$maximumPrice = 500;
$prod = 'Apple';

$select = $db->select()
             ->from('products',
                    array('product_id', 'product_name', 'price'))
             ->where("price < $minimumPrice OR price > $maximumPrice")
             ->where('product_name = ?', $prod);

Im oben stehenden Beispiel wären die Ergebnisse ohne die Klammern ziemlich anders, weil AND eine höhere Priorität als OR hat. Zend_Db_Select erzeugt runde Klammern, wodurch jeder Ausdruck von aufeinander folgenden Aufrufen der Methode where() fester binden als das AND, welches die Ausdrücke kombiniert.

In SQL ermöglicht der GROUP BY-Abschnitt die Zeilenzahl des Ergebnissatzes auf eine Zeile pro eindeutigem Wert der Spalte(n) einzuschränken, welche im GROUP BY-Abschnitt benannt sind.

In Zend_Db_Select können diese Spalte(n) mit der Methode group() angegeben werden. Das Argument der Methode ist ein Spaltenname oder ein Array von Spaltennamen, welche im GROUP BY-Abschnitt stehen sollen.

// Erzeugt diese Anfrage:
//   SELECT p."product_id", COUNT(*) AS line_items_per_product
//   FROM "products" AS p JOIN "line_items" AS l
//     ON p.product_id = l.product_id
//   GROUP BY p.product_id

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id'))
             ->join(array('l' => 'line_items'),
                    'p.product_id = l.product_id',
                    array('line_items_per_product' => 'COUNT(*)'))
             ->group('p.product_id');

Wie in dem Array von Spaltennamen der Methode from(), so können auch hier Beziehungsnamen in den Strings der Spaltennamen verwendet werden, und der Spaltenname wird als Bezeichner quotiert, wenn er nicht in runden Klammern steht oder ein Objekt des Typs Zend_Db_Expr ist.

In SQL fügt der HAVING-Abschnitt eine Beschränkungsbedingung für Gruppen von Zeilen ein. Dies ist ähnlich der Einschränkungsbedingungen auf Zeilen, des WHERE-Abschnittes. Die beiden Abschnitte unterscheiden sich jedoch, denn die WHERE Bedingungen werden angewendet, bevor Gruppen definiert wurden. Im Gegensatz werden HAVING-Bedingungen erst angewendet, nachdem Gruppen definiert wurden.

In Zend_Db_Select können Bedingungen für die Einschränkung von Gruppen mit der Methode having() angegeben werden. Die Nutzung ist ähnlich wie die der Methode where(). Das erste Argument ist ein String, welcher einen SQL-Ausdruck enthält. Das zweite Argument ist optional und wird verwendet, um einen Platzhalter im SQL-Ausdruck zu ersetzen. Ausdrücke, die durch mehrfaches Aufrufen der Methode having() erzeugt wurden, werden mit dem Boolschen Operator AND verknüpft, oder mit dem Operator OR, wenn die Methode orHaving() verwendet wird.

// Erzeugt diese Anfrage:
//   SELECT p."product_id", COUNT(*) AS line_items_per_product
//   FROM "products" AS p JOIN "line_items" AS l
//     ON p.product_id = l.product_id
//   GROUP BY p.product_id
//   HAVING line_items_per_product > 10

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id'))
             ->join(array('l' => 'line_items'),
                    'p.product_id = l.product_id',
                    array('line_items_per_product' => 'COUNT(*)'))
             ->group('p.product_id')
             ->having('line_items_per_product > 10');

In SQL gibt der ORDER BY Abschnitt eine oder mehrere Spalten oder Ausdrücke an, wonach ein Ergebnissatz sortiert wird. Wenn mehrere Spalten angegeben sind, werden die sekundären Spalten verwendet um "ties" aufzulösen; die Sortierung wird von sekundären Spalten bestimmt, wenn vorhergehende Spalten identische Werte enthalten. Die Standardsortierung ist vom kleinsten zum größten Wert. Dieses Verhalten kann umgekehrt werden, wenn das Schlüsselwort DESC nach der Spalte angegeben wird.

In Zend_Db_Select kann die Methode order() verwendet werden um Spalten oder Arrays von Spalten anzugeben, nach denen sortiert werden soll. Jedes Element des Arrays ist ein String, welcher die Spalte benennt. Optional kann auf den Namen eines der Schlüsselwörter ASC DESC getrennt durch ein Leerzeichen folgen.

Wie in den Methoden from() und group() werden Spalten als Bezeichner quotiert, wenn sie nicht von runden Klammern eingeschlossen oder vom Objekttyp Zend_Db_Expr sind.

// Erzeugt diese Anfrage:
//   SELECT p."product_id", COUNT(*) AS line_items_per_product
//   FROM "products" AS p JOIN "line_items" AS l
//     ON p.product_id = l.product_id
//   GROUP BY p.product_id
//   ORDER BY "line_items_per_product" DESC, "product_id"

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id'))
             ->join(array('l' => 'line_items'),
                    'p.product_id = l.product_id',
                    array('line_items_per_product' => 'COUNT(*)'))
             ->group('p.product_id')
             ->order(array('line_items_per_product DESC',
                           'product_id'));

Einige RDBMS-Marken erweitern SQL mit einem Anfrageabschnitt, bekannt als LIMIT-Abschnitt. Dieser Abschnitt begrenzt die Anzahl der Zeilen in einem Ergebnissatz auf die angegebene Höchstanzahl. Es kann ebenfalls angegeben werden, dass eine Anzahl von Zeilen ausgelassen werden soll. Dieses Feature erlaubt es, eine Untermenge des Ergebnissatzes zu holen, zum Beispiel wenn Anfrageergebnisse auf einander folgenden Seiten angezeigt werden sollen.

In Zend_Db_Select kann die Methode limit() verwendet werden, um die Anzahl von Zeilen und die Anzahl der auszulassenden Spalten anzugeben. Das erste Argument dieser Methode ist die gewünschte Anzahl an Zeilen. Das zweite Argument gibt die Anzahl der auszulassenden Zeilen an.

// Erzeugt diese Anfrage:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p
//   LIMIT 10, 20
// Identisch zu:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p
//   LIMIT 20 OFFSET 10

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id', 'product_name'))
             ->limit(20, 10);

Die Methode limitPage() kann als alternativer Weg verwendet werden, um Zeilenanzahl und Offset zu anzugeben. Diese Methode erlaubt es, den Ergebnissatz auf ein Subset aus einer Serie von Subsets mit Reihen einer fixen Länge aus dem Gesamtergebnis zu begrenzen. In anderen Worten gibt man die Länge einer Seite ("page") und die Nummer der Seite an, die als Ergebnis von der Abfrage zurückgegeben werden sollen. Die Seitennummer ist das erste Argument der Methode limitPage(), die Seitenlänge ist das zweite Argument. Beide Argumente werden benötigt; sie haben keinen Standardwert.

// Erstelle diese Abfrage:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p
//   LIMIT 10, 20

$select = $db->select()
             ->from(array('p' => 'products'),
                    array('product_id', 'product_name'))
             ->limitPage(2, 10);

Die Methode distinct() ermöglicht es, das Schlüsselwort DISTINCT in die SQL-Syntax einzufügen.

// Erzeugt diese Anfrage:
//   SELECT DISTINCT p."product_name"
//   FROM "products" AS p

$select = $db->select()
             ->distinct()
             ->from(array('p' => 'products'), 'product_name');

Die Methode forUpdate() ermöglicht es, die Schlüsselworte FOR UPDATE in die SQL-Syntax einzufügen.

// Erzeugt diese Anfrage:
//   SELECT FOR UPDATE p.*
//   FROM "products" AS p

$select = $db->select()
             ->forUpdate()
             ->from(array('p' => 'products'));

Man kann Union-Abfragen mit Zend_Db_Select erstellen, indem ein Array von Zend_Db_Select oder SQL Query Strings an die Methode union() übergeben wird. Als zweiter Parameter können die Konstanten Zend_Db_Select::SQL_UNION oder Zend_Db_Select::SQL_UNION_ALL übergeben werden, um den Typ der Union zu anzugeben, den man ausführen will.

$sql1 = $db->select();
$sql2 = "SELECT ...";

$select = $db->select()
    ->union(array($sql1, $sql2))
    ->order("id");

Die Anfrage, die durch das Zend_Db_Select-Objekt repräsentiert wird, kann ausgeführt werden, indem sie als erstes Argument an die Methode query() des Zend_Db_Adapter_Abstract-Objekts übergeben wird. Dabei wird das Zend_Db_Select anstelle eines Strings verwendet.

Die Methode query() gibt ein Objekt vom Typ Zend_Db_Statement oder PDOStatement zurück, je nachdem welcher Adaptertyp verwendet wird.

$select = $db->select()
             ->from('products');

$stmt = $db->query($select);
$result = $stmt->fetchAll();

Als Alternative zur Nutzung der Methode query() des Adapterobjekts kann auch die Methode query() des Objekts Zend_Db_Select verwendet werden. Beide Methoden geben ein Objekt vom Typ Zend_Db_Statement oder PDOStatement zurück, je nachdem welcher Adaptertyp verwendet wird.

$select = $db->select()
             ->from('products');

$stmt = $select->query();
$result = $stmt->fetchAll();

Wenn Zugriff auf die String-Repräsentation der SQL-Anfrage benötigt wird, welche dem Objekt Zend_Db_Select entspricht, kann die Methode __toString() verwendet werden.

$select = $db->select()
             ->from('products');

$sql = $select->__toString();
echo "$sql\n";

// Ausgabe ist dieser String:
//   SELECT * FROM "products"

Die Methode getPart() gibt eine Repräsentation eines Teils der SQL-Anfrage zurück. Zum Beispiel kann diese Methode verwendet werden um ein Array von Ausdrücke des WHERE-Abschnitts, ein Array von Spalten (oder Spaltenausdrücke) von SELECT oder die Werte der Spaltenzahl und Auslassungen des LIMIT-Abschnitts zu erhalten.

Die Rückgabe ist kein String, der ein Fragment der SQL-Syntax enthält. Der Rückgabewert ist eine interne Repräsentation, was typischerweise eine Arraystruktur ist, welche Werte und Ausdrücke enthält. Jeder Teil der Anfrage hat eine unterschiedliche Struktur.

Das einzige Argument der Methode getPart() ist ein String, der den zurückzugebenden Teil der Anfrage bezeichnet. Zum Beispiel bezeichnet der String 'from' den Teil des Select-Objekts, welcher Informationen über den FROM-Abschnitt, einschließlich verbundener Tabellen enthält.

Die Klasse Zend_Db_Select definiert Konstanten, die für Teile der SQL-Anfrage verwendet werden können. Es können die Konstantendefinitionen oder die literalen Strings verwendet werden.

$select = $db->select()
             ->from('products')
             ->order('product_id');

// Ein literaler String kann verwendet werden, um den Abschnitt zu definieren
$orderData = $select->getPart( 'order' );

// Eine Konstante kann verwendet werden, um denselben Abschnitt zu definieren
$orderData = $select->getPart( Zend_Db_Select::ORDER );

// Der zurückgegebene Wert kann eine Arraystruktur sein, kein String.
// Jeder Abschnitt hat eine unterschiedliche Struktur.
print_r( $orderData );

Die Methode reset() ermöglicht es, einen angegebenen Teil der SQL-Anfrage zu löschen oder, wenn der Parameter ausgelassen ist, alle Teile der SQL-Anfrage zu löschen.

Das einzige Argument ist optional. Es kann der Teil der Anfrage angegeben werden, der gelöscht werden soll, unter Nutzung des gleichen Strings wie er als Argument der Methode getPart() verwendet wird. Der angegebene Teil wird auf einen Standardwert zurück gesetzt.

Wenn der Parameter ausgelassen wird, setzt reset() alle geänderten Teile auf einen Standardwert zurück. Dadurch ist das Zend_Db_Select-Objekt gleichwertig mit einem neuen Objekt, wie wenn es gerade instanziiert wurde.

// Erzeugt diese Anfrage:
//   SELECT p.*
//   FROM "products" AS p
//   ORDER BY "product_name"

$select = $db->select()
             ->from(array('p' => 'products')
             ->order('product_name');

// Geänderte Anforderungen, stattdessen sortiert nach einer anderen Spalte:
//   SELECT p.*
//   FROM "products" AS p
//   ORDER BY "product_id"

// Lösche einen Abschnitt, damit er neu defniert werden kann
$select->reset( Zend_Db_Select::ORDER );

// und definiere eine andere Spalte
$select->order('product_id');

// Lösche alle Abschnitte von der Abfrage
$select->reset();