# Zend_Db_Select

## Einführung

Das `Zend_Db_Select`-Objekt repräsentiert ein SQL-SELECT-Anfrage-Statement. Die Klasse bietet Methoden um einzelne Teile der Anfrage hinzuzufügen. Einzelne Teile der Anfrage können mit Hilfe von PHP Methoden und Datenstrukturen angegeben werden, und die Klasse erzeugt korrekte SQL-Syntax. Nachdem die Anfrage formuliert wurde, kann sie ausgeführt werden, als wäre sie mit einem normalen String geschrieben worden.

`Zend_Db_Select` bietet folgenden Nutzen:

- Objektorientierte Methoden um SQL-Anfragen Stück für Stück zu formulieren.

- Datenbankunabhängige Abstraktion einiger Teile der SQL-Anfrage.

- In den meisten Fällen automatische Quotierung von Metadaten um zu erlauben, dass Bezeichner reservierte SQL-Wörter und spezielle Zeichen enthalten dürfen.

- Quotierung von Bezeichnern und Werten, um das Risiko von Angriffen durch SQL-Injektion zu verringern.

Nutzung von `Zend_Db_Select` ist nicht zwingend erforderlich. Für einfache SELECT-Anfragen ist es normalerweise einfacher, die gesamte SQL-Anfrage in einem String zu formulieren und mit Hilfe der Methoden der Adapterklasse, wie `query()` oder `fetchAll()`, auszuführen. Die Nutzung von `Zend_Db_Select` ist hilfreich, wenn eine SELECT-Anfrage prozedural oder basierend auf der konditionellen Logik der Anwendung zusammengesetzt wird.

## Erzeugung eines Select-Objekts

Die Instanz eines `Zend_Db_Select`-Objekts kann mit Hilfe der Methode `select()` des `Zend_Db_Adapter_Abstract`-Objekts erzeugt werden.

### Beispiel für die Nutzung der Methode select() der Datenbankadapterklasse

    $db = Zend_Db::factory( ...Optionen... );
    $select = $db->select();

Ein anderer Weg ein `Zend_Db_Select`-Objekt zu erzeugen, ist die Nutzung des Konstruktors unter Angabe des Datenbankadapters als Argument.

### Beispiel für die Erzeugung eines Select-Objekts

    $db = Zend_Db::factory( ...Optionen... );
    $select = new Zend_Db_Select($db);

## Erstellung von Select-Anfragen

Wenn die Anfrage erstellt wird, können Bedingungen der Anfrage nacheinander hinzugefügt werden. Es gibt separate Methoden für das Hinzufügen von verschiedenen Bedingungen zum `Zend_Db_Select`-Objekt.

### Beispiele für die Nutzung der Methoden zum Hinzufügen von Bedingungen

    // Erzeugung des Zend_Db_Select-Objekts
    $select = $db->select();

    // Hinzufügen einer FROM Bedingung
    $select->from( ...Angabe von Tabelle und Spalten... )

    // Hinzufügen einer WHERE Bedingung
    $select->where( ...Angabe von Suchkriterien... )

    // Hinzufügen einer ORDER BY Bedingung
    $select->order( ...Angabe von Sortierkriterien... );

Die meisten Methoden des `Zend_Db_Select`-Objekts lassen sich auch über das bequeme Fluent Interface nutzen. Fluent Interface bedeutet, dass jede Methode eine Referenz auf das aufrufende Objekt zurück gibt, daher kann direkt eine andere Methode aufgerufen werden.

### Beispiel für die Nutzung des Fluent Interface

    $select = $db->select()
        ->from( ...Angabe von Tabelle und Spalten... )
        ->where( ...Angabe von Suchkriterien... )
        ->order( ...Angabe von Sortierkriterien... );

Die Beispiele in diesem Abschnitt zeigen die Nutzung des Fluent Interface, es kann aber auch immer das normale Interface verwendet werden. Häufig ist es nötig das normale Interface zu nutzen, zum Beispiel wenn die Anwendung vor dem Hinzufügen der Bedingung Berechnungen durchführen muss.

### Hinzufügen eines FROM Abschnitts

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.

#### Beispiel für die Methode from()

    // 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.

#### Beispiel für das Angeben eines Beziehungsnamens

    // 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.

#### Beispiel für das Angeben eines Schemanamens

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

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

    // oder

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

### Hinzufügen von Spalten

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.

#### Beispiele für das Angeben von Spalten

    // 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'));

### Hinzufügen von Spalten mit Ausdrücke

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.

Die Benutzung von `Zend_Db_Expr` für Spaltennamen ist nicht nötig, wenn die Spaltennamen Ausdrücke runde Klammern enthalten. `Zend_Db_Select` erkennt diese und behandelt den String als Ausdruck und lässt Quotierung und Beziehungsnamen aus.

#### Beispiel für das Angeben von Spaltennamen, die Ausdrücke enthalten

    // 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.

#### Beispiel für die Quotierung von Spalten in einem Ausdruck

    // 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)')
                       );

### Spalten zu einer existierenden FROM oder JOIN Tabelle hinzufügen

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.

#### Beispiel für das Hinzufügen von Spalten mit der Methode columns()

    // 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

### Hinzufügen einer weiteren Tabelle zu der Anfrage mit JOIN

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.

#### Beispiel für die Methode join()

    // 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.

Es wird keine Quotierung auf den Ausdruck für die Join-Bedingung angewendet. Werden Spaltennamen verwendet, welche Quotierung benötigen, so muss `quoteIdentifier()` verwendet werden, wenn der String für die Join-Bedingung formuliert wird.

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.

#### Beispiel für das Angeben keiner Spalten

    // 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

Zu beachten ist, dass leere `array()` in dem oben stehenden Beispiel, an der Stelle einer Liste von Spalten der verbundenen Tabelle.

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.

- `INNER JOIN` mit den Methoden `join(tabelle, join, [spalten])` oder `joinInner(tabelle, join, [spalten])`.

  Dies wird der gebräuchlichste Typ von Join sein. Zeilen jeder Tabelle werden mit Hilfe der angegebenen Join-Bedingung verglichen. Der Ergebnissatz enthält nur die Zeilen, die der Join Bedingungen entsprechen. Der Ergebnissatz kann leer sein, wenn keine Zeile die Bedingung erfüllt.

  Alle RDBMS-Marken unterstützen diese Variante.

- `LEFT JOIN` mit der Methode `joinLeft(tabelle, bedingung, [spalten])`.

  Alle Zeilen der links vom Operanden stehenden Tabelle sind enthalten, passende Zeilen der rechts stehenden Tabelle sind ebenfalls enthalten. Die Spalten der rechts stehenden Tabelle werden mit `NULL` aufgefüllt, wenn keine zu der linken Tabelle passenden Zeilen existieren.

  Alle RDBMS-Marken unterstützen diese Variante.

- `RIGHT JOIN` mit der Methode `joinRight(tabelle, bedingung, [spalten])`.

  Right Outer Join ist das Gegenstück zu Left Outer Join. Alle Zeilen der rechts vom Operanden stehenden Tabelle sind enthalten, passende Zeilen der links stehenden Tabelle sind ebenfalls enthalten. Die Spalten der links stehenden Tabelle werden mit `NULL` aufgefüllt, wenn keine zu der rechten Tabelle passenden Zeilen existieren.

  Einige RDBMS-Marken unterstützen diesen Join nicht, aber grundsätzlich kann jeder Right Join durch einen Left Join mit umgekehrter Sortierung der Tabellen dargestellt werden.

- `FULL JOIN` mit der Methode `joinFull(tabelle, bedingung, [spalten])`.

  Ein Full Outer Join ist wie eine Kombination eines Left Outer Join mit einem Right Outer Join. Alle Zeilen beider Tabellen sind enthalten, gepaart miteinander in der gleichen Zeile des Ergebnissatzes wenn die Join-Bedingung erfüllt wird, oder wenn nicht, mit `NULL` an Stelle der Spalten der anderen Tabelle.

  Einige RDBMS-Marken unterstützen diesen Join nicht.

- `CROSS JOIN` mit der Methode `joinCross(tabelle, [spalten])`.

  Ein Cross Join ist ein Kartesisches Produkt. Jede Zeile der ersten Tabelle wird mit jeder Zeile der zweiten Tabelle verbunden. Daher ist die Anzahl der Zeilen im Ergebnissatz gleich dem Produkt der Zeilenanzahlen der beiden Tabellen. Der Ergebnissatz kann mit Bedingungen einer WHERE-Bedingung gefiltert werden. Ein Cross Join ist ähnlich der alten SQL-89 Join Syntax.

  Die Methode `joinCross()` hat keinen Parameter für die Join-Bedingung. Einige RDBMS-Marken unterstützen diesen Join nicht.

- `NATURAL JOIN` mit der Methode `joinNatural(tabelle, [spalten])`.

  Ein Natural Join vergleicht alle Spalten die in beiden Tabellen mit gleichem Namen vorkommen. Der Vergleich prüft Gleichheit aller Spalten, ein Vergleich auf Ungleichheit ist kein Natural Join. Von dieser API werden nur Natural Inner Joins unterstützt, auch wenn SQL auch Natural Outer Joins erlaubt.

  Die Methode `joinNatural()` hat keinen Parameter für die Join-Bedingung.

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.

#### Beispiel für die Methode joinUsing()

    // 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.

- `joinUsing(table, join, [columns])` und `joinInnerUsing(table, join, [columns])`

- `joinLeftUsing(table, join, [columns])`

- `joinRightUsing(table, join, [columns])`

- `joinFullUsing(table, join, [columns])`

### Hinzufügen eines WHERE-Abschnitts

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.

#### Beispiel für die Methode where()

    // 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');

Auf Ausdrücke, welche an die Methoden `where()` oder `orWhere()` übergeben werden, wird keine Quotierung angewendet. Werden Spaltennamen verwendet, die quotiert werden müssen, so muss `quoteIdentifier()` verwendet werden, wenn der String für die Bedingung formuliert wird.

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.

#### Beispiel für einen Parameter in der Methode where()

    // 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.

#### Beispiel mit Array als Parameters in der Methode where()

    // 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.

#### Beispiel für Mehrfachaufruf der Methode where()

    // 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.

#### Beispiel für die Methode orWhere()

    // 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.

#### Beispiel für das Einklammern von Boolschen Ausdrücken

    // 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.

### Hinzufügen eines GROUP BY-Abschnitts

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.

#### Beispiel für die Methode group()

    // 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.

### Hinzufügen eines HAVING-Abschnittes

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.

#### Beispiel für die Methode having()

    // 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');

Es wird keine Quotierung auf Ausdrücke angewendet, welche an die Methoden `having()` oder `orHaving()` übergeben werden. Werden Spaltennamen verwendet, die quotiert werden müssen, so muss `quoteIdentifier()` verwendet werden, wenn der String für die Bedingung formuliert wird.

### Hinzufügen eines ORDER BY Abschnitts

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.

#### Beispiel für die Methode order()

    // 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'));

### Hinzufügen eines LIMIT-Abschnitts

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.

#### Beispiel für die Methode limit()

    // 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 `LIMIT`-Syntax wird nicht von allen RDBMS-Marken unterstützt. Einige RDBMS benötigen eine unterschiedliche Syntax für eine ähnliche Funktionalität. Jede `Zend_Db_Adapter_Abstract`-Klasse enthält eine Methode um die für das RDBMS passende SQL-Syntax zu erzeugen.

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.

#### Beispiel der Methode limitPage()

    // 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);

### Hinzufügen des Anfragewandlers DISTINCT

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

#### Beispiel für die Methode distinct()

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

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

### Hinzufügen des Anfragewandlers FOR UPDATE

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

#### Beispiel der Methode forUpdate()

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

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

### Eine UNION-Abfrage erstellen

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.

#### Beispiel der Methode union()

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

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

## Ausführen von SELECT-Anfragen

Dieser Abschnitt beschreibt, wie Anfragen ausgeführt werden, die durch ein `Zend_Db_Select`-Objekt repräsentiert werden.

### Ausführen von Select-Anfragen aus dem Db-Adapter

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.

#### Beispiel für die Nutzung der Methode query() des Db-Adapters

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

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

### Ausführen von Select-Anfragen mit dem Objekt

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.

#### Beispiel für die Nutzung der Methode query() des Select-Objekts

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

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

### Konvertieren eines Select-Objekts in einen SQL-String

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.

#### Beispiel für die Methode __toString()

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

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

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

## Andere Methoden

Dieser Abschnitt beschreibt andere Methoden der `Zend_Db_Select` Klasse, welche bisher nicht beschrieben wurden: `getPart()` und `reset()`.

### Abfragen von Teilen des Select-Objekts

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.

#### Konstanten, die von getPart() und reset() verwendet werden

Konstante | String Wert
--- | ---
`Zend_Db_Select::DISTINCT` | `'distinct'`
`Zend_Db_Select::FOR_UPDATE` | `'forupdate'`
`Zend_Db_Select::COLUMNS` | `'columns'`
`Zend_Db_Select::FROM` | `'from'`
`Zend_Db_Select::WHERE` | `'where'`
`Zend_Db_Select::GROUP` | `'group'`
`Zend_Db_Select::HAVING` | `'having'`
`Zend_Db_Select::ORDER` | `'order'`
`Zend_Db_Select::LIMIT_COUNT` | `'limitcount'`
`Zend_Db_Select::LIMIT_OFFSET` | `'limitoffset'`

#### Beispiel der Methode getPart()

    $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 );

### Zurücksetzen von Teilen des Select-Objekts

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.

#### Beispiel der Methode reset()

    // 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();