Previous Next

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:

  • Objekt Orientierte Methoden um SQL Anfragen Stück für Stück zu formulieren.

  • Datenbank unabhängige Abstraktion einiger Teile der SQL Anfrage.

  • In den meisten Fällen automatische Quotierung von Metadaten um Bezeichner zu unterstützen welche reservierte SQL Wörter und spezielle Zeichen enthalten.

  • Quotierung von Bezeichnern und Werten um dabei zu helfen das Risiko von SQL Injektion Attacken zu reduzieren.

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 select() Methode des Zend_Db_Adapter_Abstract Objekts erzeugt werden.

Beispiel #1 Beispiel für die Nutzung der select() Methode 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 #2 Beispiel für die Erzeugung eines Select Objektes

$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 eine separate Methode für das Hinzufügen von verschiedenen Bedingungen zum Zend_Db_Select Objekt.

Beispiel #3 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 das jede Methode eine Referenz auf das aufrufende Objekt zurück gibt, daher kann direkt eine andere Methode aufgerufen werden.

Beispiel #4 Beispiel für die Nutzung der flüssigen Schnittstelle

$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 an zu geben wird die from() Methode verwendet. Der Tabellenname kann als einfacher String übergeben werden. Zend_Db_Select wendet Bezeichner Quotierung an, es können also auch spezielle Zeichen verwendet werden.

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

// 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 #6 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 #7 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 from() Methode 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 code example bei der join() Methode.

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 from() Methode verwendet.

Beispiel #8 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 Expressions

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

Es kann auch ein Objekt des Typs Zend_Db_Expr erzeugt werden um zu verhindern das 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.

Hinweis:

Benutzung von Zend_Db_Expr für Spaltennamen ist nicht nötig wenn Spaltennamen Expressions runde Klammern enthalten. Zend_Db_Select erkennt diese und behandelt den String als eine Expression und lässt Quotierung und Beziehungsnamen aus.

Beispiel #9 Beispiel für das angeben von Spaltennamen, die Expressions enthalten

// Erzeugt diese Anfrage:
//   SELECT p."product_id", LOWER(product_name)
//   FROM "products" AS p
// Eine Expression 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 ändern Zend_Db_Select den String nicht mit Beziehungsnamen oder Bezeichnerquotierung. Wenn diese Änderungen notwendig sein sollten um doppeldeutigkeiten auf zu lösen, muss dies manuell am String geändert werden.

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

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

Beispiel #10 Beispiel für die Quotierung von Spalten in einer Expression

// Erzeugt folgende Anfrage und Quotiert dabei einen Spaltennamen
// "from" in der Expression:
//   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 wo es gewünscht ist Spalten zu einer bestehenden FROM oder JOIN Tabelle hinzuzufügen nachdem diese Methoden aufgerufen wurde. Die columns() Methode 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 das die Spalten zu der FROM Tabelle hinzugefügt werden sollen, andernfall muß ein bestehender Korrelationsname verwendet werden.

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

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

// Die selbe Abfrage bauen, durch spezifizierung 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 join() Methode hinzugefügt werden. Die Nutzung dieser Methode ist ähnlich der from() Methode, außer das in den meisten Fällen zusätzlich eine Join Bedingung angegeben werden kann.

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

// 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 join() Methode ist ein String mit der Join Bedingung. Dies ist eine Exspression die Kriterien angibt, welche Zeilen in der einen Tabelle mit Zeilen einer anderen Tabelle verknüpft werden. Es können Beziehungsnamen in dieser Expression verwendet werden.

Hinweis:

Es wird keine Quotierung auf die Expression 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 Spaltennahmen, entsprechend des Arrays der from() Methode. Der Standard ist ebenfalls "*" und unterstützt Beziehungsnamen, Expressions und Zend_Db_Expr in der gleichen Weise wie dem Array von Spaltennamen der from() Methode.

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 from() Methode, 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 #13 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 das leere array() in dem oben stehenden Beispiel, am Stelle einer Liste von Spalten der verbundenen Tabelle.

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

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

    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 diesen Join Typ.

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

    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 diesen Join Typ.

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

    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 Typ nicht, aber grundsätzlich kann jeder Right Join durch einen Left Join mit umgekehrter Sortierung der Tabellen dargestellt werden.

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

    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's an Stelle der Spalten der anderen Tabelle.

    Einige RDBMS Marken unterstützen diesen Join Typ nicht.

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

    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 joinCross() Methode hat keinen Parameter für die Join Bedingung. Einige RDBMS Marken unterstützen diesen Join Typ nicht.

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

    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 joinNatural() Methode hat keinen Parameter für die Join Bedingung.

Zusätzlich zu diesen Join Methoden können Abfragen durch Verwendung der JoinUsing Methoden vereinfacht werden. Statt das 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 #14 Beispiel für die joinUsing() Methode

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

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

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

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

Hinweis:

Auf Expressions die an where() oder orWhere() Methoden ü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 where() Methode ist optional. Es ist ein Wert der in die Expression eingesetzt wird. Zend_Db_Select Quotiert den Wert und ersetzt ihn für ein Fragezeichen ("?") in der Expression.

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

// 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 where() Methode übergeben wenn der SQL IN Operator verwendet wird.

Beispiel #17 Beispiel eines Array Parameters in der where() Methode

// 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 where() Methode kann mehrere Male in dem selben Zend_Db_Select Objekt aufgerufen werden. Die daraus folgenden Anfrage kombiniert die unterschiedlichen Ausdrücke unter Benutzung von AND zwischen ihnen.

Beispiel #18 Beispiel für mehrfach Aufruf der where() Methode

// 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 orWhere() Methode verwendet werden. Sie wird genauso benutzt wie die where() Methode, außer das dem angegebene Ausdruck ein OR vorangestellt wird, anstelle eines AND.

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

// 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 Expressions automatisch mit runden Klammern ein wenn sie mit der where() oder orWhere() Methode angegeben wurden. Dies hilft sicher zu stellen dass das voranstellen von Boolean Operatoren keine unerwarteten Ergebnisse nach sich zieht.

Beispiel #20 Beispiel für das Einklammern von Boolean Expressions

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

In dem oben stehenden Beispiel währen die Ergebnisse ohne den Klammern ziemlich anders, weil AND eine höhere Priorität als OR hat. Zend_Db_Select erzeugt runde Klammern wodurch jede Expression von aufeinander folgenden Aufrufen der where() Methode fester binden als das AND welches die Expressions 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), welche in dem GROUP BY Abschnitt benannt sind, einzuschränken.

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

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

// 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 from() Methode, 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 abgewendet bevor Gruppen definiert wurden. Im Gegensatz werden HAVING Bedingungen erst angewendet nach dem Gruppen definiert wurden.

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

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

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

Hinweis:

Es wird keine Quotierung bei den Expressions welche an die having() oder orHaving() Methoden ü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 Expressions 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 standard Sortierung 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 order() Methode 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 folgen, abgetrennt durch ein Leerzeichen.

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

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

// 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 Anfrage Abschnitt, 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 Anfrage Ergebnisse auf aufeinander folgenden Seiten angezeigt werden sollen.

In Zend_Db_Select kann die limit() Methode 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 #24 Beispiel für die limit() Methode

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

Hinweis:

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 für das RDBMS passende SQL Syntax zu erzeugen.

Die limitPage() Methode kann als alternativer Weg verwendet werden um Zeilenanzahl und Offset zu spezifizieren. Diese Methode erlaubt den Ergebnissatz auf einen Subset, aus einer Serie von Subsets mit Reihen einer fixe Länge, auf dem totalen Ergebnissatz der Abfrage, zu limitieren. In anderen Worten, spezifiziert man die Länge einer Seite ("page") von Ergebnissen, und die ordinale Anzahl an Ergebnissen einer einzelnen Seite, die als von der Abfrage zurück gegeben werden sollen. Die Seitennummer ist das erste Argument der limitPage() Methode, und die Seitenlänge ist das zweite Argument. Beide Argumente werden benötigt; sie haben keinen Standardwert.

Beispiel #25 Beispiel der limitPage() Methode

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

Die distinct() Methode ermöglicht es DISTINCT Schlüsselworte in die SQL Syntax einzufügen.

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

// 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 FOR UPDATE Anfragewandlers

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

Beispiel #27 Beispiel der forUpdate() Methode

// 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 union() Methode ü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 spezifizieren den man ausführen will.

Beispiel #28 Beispiel der union() Methode

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

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

Ausführen von SELECT Anfrage

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 query() Methode des Zend_Db_Adapter_Abstract Objekts übergeben wird. Dabei wird das Zend_Db_Select anstelle eines Strings verwendet.

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

Beispiel #29 Beispiel für die Nutzung der query() Methode 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 query() Methode des Adapterobjekts kann auch die query() Methode des Zend_Db_Select Objekts verwendet werden. Beide Methoden geben ein Objekt vom Typ Zend_Db_Statement oder PDOStatement zurück, je nachdem welcher Adaptertyp verwendet wird.

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

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

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

Konvertieren eines Select Objekts in einen SQL String

Wenn Zugriff zu auf eine String Repräsentante der SQL Anfrage, entsprechend dem Zend_Db_Select, benötigt wird, kann die __toString() Methode verwendet werden.

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

$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 getPart() Methode gibt eine Repräsentante eines Teils der SQL Anfrage zurück. Zum Beispiel kann diese Methode verwendet werden um, ein Array von Expressions des WHERE Abschnitts, ein Array von Spalten (oder Spalten Expressions) 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äsentante, was typischerweise eine Arraystruktur ist, welche Werte und Expressions enthält. Jeder Teil der Anfrage hat eine unterschiedliche Struktur.

Das einzige Argument der getPart() Methode ist ein String der den zurück zu gebenden 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 Zend_Db_Select Klasse 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 #32 Beispiel der getPart() Methode

$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 den selben Abschnitt zu definieren
$orderData = $select->getPart( Zend_Db_Select::ORDER );

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

Zurücksetzen von Teilen des Select Objekts

Die reset() Methode 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 getPart() Methode verwendet wird. Der angegebene Teil wird auf ein 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 #33 Beispiel der reset() Methode

// 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();
Previous Next
Einführung zum Zend Framework
Übersicht
Installation
Einstieg ins Zend Framework
Schnellstart in den Zend Framework
Zend Framework & MVC Einführung
Das Projekt erstellen
Ein Layout erstellen
Ein Modell und eine Datenbank Tabelle erstellen
Erstellen eines Formulars
Gratulation!
Autoloading im Zend Framework
Einführung
Ziele und Design
Grundsätzliche Verwendung von Autoloadern
Automatisches Laden von Ressourcen
Zusammenfassung
Plugins im Zend Framework
Einführung
Verwenden von Plugins
Fazit
Einstieg in Zend_Layout
Einführung
Zend_Layout verwenden
Zend_Layout: Fazit
Einstieg in Zend_View Platzhalter
Einführung
Grundsätzliche Verwendung von Platzhaltern
Standard Platzhalter
View Platzhalter: Fazit
Zend_Form's Gestalter (Decorator) verstehen und verwenden
Einführung
Decorator Grundlagen
Layeraufbau von Decorators
Darstellung individueller Decorators
Erstellung und Darstellung von kombinierten Elementen
Fazit
Einstieg in Zend_Session, Zend_Auth, und Zend_Acl
Erstellung von Multi-User Anwendungen mit Zend Framework
User Session im Zend Framework managen
Benutzer im Zend Framework authentifizieren
Erstellung eines Authorisations Systems in Zend Framework
Einstieg in Zend_Search_Lucene
Einführung in Zend_Search_Lucene
Lucene Index Struktur
Indezes öffnen und erstellen
Indizierung
Suchen
Unterstützte Abfragen
Seitendarstellung von Suchergebnissen
Einstieg in Zend_Paginator
Einführung
Einfaches Beispiel
Seitenkontrolle und ScrollingStyles
Alles zusammenfügen
Zend Framework's Referenz
Zend_Acl
Einführung
Verfeinern der Zugriffskontrolle
Fortgeschrittene Verwendung
Zend_Amf
Einführung
Zend_Amf_Server
Zend_Application
Einführung
Zend_Application Quick Start
Theorie der Funktionsweise
Beispiele
Kern Funktionalität
Vorhandene Ressource Plugins
Zend_Auth
Einführung
Datenbanktabellen Authentifizierung
Digest Authentication
HTTP Authentication Adapter
LDAP Authentifizierung
Open ID Authentifikation
Zend_Barcode
Einführung
Barcodes mit Hilfe der Zend_Barcode Klasse erstellen
Zend_Barcode Objekte
Zend_Barcode Renderer
Zend_Cache
Einführung
Die Theorie des Cachens
Zend_Cache Frontends
Zend_Cache Backends
Der Cache Manager
Zend_Captcha
Einführung
Captcha Anwendung
CAPTCHA Adapter
Zend_CodeGenerator
Einführung
Zend_CodeGenerator Beispiele
Zend_CodeGenerator Referenz
Zend_Config
Einleitung
Theory of Operation
Zend_Config_Ini
Zend_Config_Xml
Zend_Config_Writer
Zend_Config_Writer
Zend_Console_Getopt
Einführung
Definieren von Getopt Regeln
Holen von Optionen und Argumenten
Konfigurieren von Zend_Console_Getopt
Zend_Controller
Zend_Controller Schnellstart
Zend_Controller Grundlagen
Der Front Controller
Das Request Objekt
Der Standard Router
Der Dispatcher
Action Controller
Action Helfer
Das Response Objekt
Plugins
Eine konventionelle modulare Verzeichnis Struktur verwenden
MVC Ausnahmen
Zend_Currency
Einführung in Zend_Currency
Zend_Currency verwenden
Optionen für Währungen
Was macht eine Währung aus?
Wo ist die Währung?
Wie sieht die Währung aus?
Wie viel Währung habe ich?
Rechnen mit Währungen
Währungen wechseln
Zusätzliche Informationen für Zend_Currency
Zend_Date
Einführung
Theorie der Arbeitsweise
Basis Methoden
Zend_Date API Übersicht
Erstellen von Datumswerten
Konstanten für generelle Datums Funktionen
Funktionierende Beispiele
Zend_Db
Zend_Db_Adapter
Zend_Db_Statement
Zend_Db_Profiler
Zend_Db_Select
Zend_Db_Table
Zend_Db_Table_Row
Zend_Db_Table_Rowset
Zend_Db_Table Relationships
Zend_Db_Table_Definition
Zend_Debug
Variablen ausgeben
Zend_Dojo
Einführung
Zend_Dojo_Data: dojo.data Envelopes
Dojo View Helfer
Formular Elemente und Dekoratore für Dojo
Support für den Build Layer von Zend_Dojo
Zend_Dom
Einführung
Zend_Dom_Query
Zend_Exception
Verwenden von Ausnahmen
Grundsätzliche Verwendung
Vorherige Exceptions
Zend_Feed
Einführung
Feeds importieren
Feeds von Websites abrufen
Einen RSS Feed konsumieren
Einen Atom Feed konsumieren
Einen einzelnen Atom Eintrag konsumieren
Verändern der Feed- und Eintragsstruktur
Eigene Klassen für Feeds und Einträge
Zend_Feed_Reader
Zend_Feed_Writer
Zend_Feed_Pubsubhubbub
Zend_File
Zend_File_Transfer
Prüfungen für Zend_File_Transfer
Filter für Zend_File_Transfer
Zend_Filter
Einführung
Standard Filter Klassen
Filter Ketten
Filter schreiben
Zend_Filter_Input
Zend_Filter_Inflector
Zend_Form
Zend_Form
Schnellstart mit Zend_Form
Erstellen von Form Elementen mit Hilfe von Zend_Form_Element
Erstellen von Form durch Verwendung von Zend_Form
Erstellen von eigenem Form Markup durch Zend_Form_Decorator
Standard Form Elemente die mit dem Zend Framework ausgeliefert werden
Standard Formular Dekoratoren die mit dem Zend Framework ausgeliefert werden
Internationalisierung von Zend_Form
Fortgeschrittene Verwendung von Zend_Form
Zend_Gdata
Einführung
Authentifizierung mit AuthSub
Die Buchsuche Daten API verwenden
Authentifizieren mit ClientLogin
Google Kalender verwenden
Verwenden der Google Dokumente Listen Daten API
Verwenden von Google Health
Google Tabellenkalkulation verwenden
Google Apps Provisionierung verwenden
Google Base verwenden
Picasa Web Alben verwenden
Verwenden der YouTube Daten API
Gdata Ausnahmen auffangen
Zend_Http
Einführung
Zend_Http_Client - Fortgeschrittende Nutzung
Zend_Http_Client - Verbindungsadapter
Zend_Http_Cookie und Zend_Http_CookieJar
Zend_Http_Response
Zend_InfoCard
Einführung
Zend_Json
Einführung
Grundlegende Verwendung
Fortgeschrittene Verwendung von Zend_Json
XML zu JSON Konvertierung
Zend_Json_Server - JSON-RPC Server
Zend_Layout
Einführung
Zend_Layout Schnellstart
Zend_Layout Konfigurations Optionen
Erweiterte Verwendung von Zend_Layout
Zend_Ldap
Einführung
API Übersicht
Szenarien der Verwendung
Tools
Objektorientierter Zugriff auf den LDAP Baum durch Verwendung von Zend_Ldap_Node
Informationen vom LDAP Server erhalten
Serialisieren von LDAP Daten von und zu LDIF
Zend_Loader
Dynamisches Laden von Dateien und Klassen
Der Autoloader
Ressource Autoloader
Plugins laden
Zend_Locale
Einführung
Zend_Locale verwenden
Normalisierung und Lokalisierung
Arbeiten mit Daten und Zeiten
Unterstützte Gebietsschemata
Zend_Log
Übersicht
Writer
Formatter
Filter
Die Factory verwenden um ein Log zu erstellen
Zend_Mail
Einführung
Versand über SMTP
Versand von mehreren E-Mails über eine SMTP Verbindung
Verwendung von unterschiedlichen Versandwegen
HTML E-Mail
Anhänge
Empfänger hinzufügen
Die MIME Abgrenzung kontrollieren
Zusätzliche Kopfzeilen
Zeichensätze
Kodierung
SMTP Authentifizierung
SMTP Übertragungen sichern
Lesen von Mail Nachrichten
Zend_Markup
Einführung
Beginnen mit Zend_Markup
Zend_Markup Parser
Zend_Markup Renderer
Zend_Measure
Einführung
Erstellung einer Maßeinheit
Ausgabe von Maßeinheiten
Manipulation von Maßeinheiten
Arten von Maßeinheiten
Zend_Memory
Übersicht
Memory Manager
Memory Objekte
Zend_Mime
Zend_Mime
Zend_Mime_Message
Zend_Mime_Part
Zend_Navigation
Einführung
Seiten
Container
Zend_Oauth
Einführung zu OAuth
Zend_OpenId
Einführung
Zend_OpenId_Consumer Grundlagen
Zend_OpenId_Provider
Zend_Paginator
Einführung
Verwendung
Konfiguration
Advanced usage
Zend_Pdf
Einführung
Erstellen und Laden von PDF Dokumenten
Änderungen an PDF Dokumenten speichern
Arbeiten mit Seiten
Zeichnen
Interaktive Features
Dokument Informationen und Metadaten
Anwendungsbeispiel für die Zend_Pdf Komponente
Zend_ProgressBar
Zend_ProgressBar
Zend_Queue
Einführung
Beispiel der Verwendung
Framework
Adapter
Anpassen von Zend_Queue
Stomp
Zend_Reflection
Einführung
Zend_Reflection Beispiele
Zend_Reflection Referenz
Zend_Registry
Die Registry verwenden
Zend_Rest
Einführung
Zend_Rest_Client
Zend_Rest_Server
Zend_Search_Lucene
Überblick
Indexerstellung
Einen Index durchsuchen
Abfragesprache
Abfrage Erzeugungs API
Zeichensätze
Erweiterbarkeit
Zusammenarbeit Mit Java Lucene
Erweitert
Die besten Anwendungen
Zend_Serializer
Einführung
Zend_Serializer_Adapter
Zend_Server
Einführung
Zend_Server_Reflection
Zend_Service
Einführung
Zend_Service_Akismet
Zend_Service_Amazon
Zend_Service_Amazon_Ec2
Zend_Service_Amazon_Ec2: Instanzen
Zend_Service_Amazon_Ec2: Windows Instanzen
Zend_Service_Amazon_Ec2: Reservierte Instanzen
Zend_Service_Amazon_Ec2: CloudWatch Monitoring
Zend_Service_Amazon_Ec2: Amazon Maschinen Images (AMI)
Zend_Service_Amazon_Ec2: Elastischer Block Speicher (EBS)
Zend_Service_Amazon_Ec2: Elastische IP Adressen
Zend_Service_Amazon_Ec2: Schlüsselpaare
Zend_Service_Amazon_Ec2: Regionen und Availability Zones
Zend_Service_Amazon_Ec2: Sicherheitsgruppen
Zend_Service_Amazon_S3
Zend_Service_Amazon_Sqs
Zend_Service_Audioscrobbler
Zend_Service_Delicious
Zend_Service_DeveloperGarden
Zend_Service_Flickr
Zend_Service_LiveDocx
Zend_Service_Nirvanix
Zend_Service_ReCaptcha
Zend_Service_Simpy
Zend_Service_SlideShare
Zend_Service_StrikeIron
Zend_Service_StrikeIron: Mitgelieferte Services
Zend_Service_StrikeIron: Erweiterte Verwendung
Zend_Service_Technorati
Zend_Service_Twitter
Zend_Service_WindowsAzure
Zend_Service_Yahoo
Zend_Session
Einführung
Grundsätzliche Verwendung
Fortgeschrittene Benutzung
Globales Session Management
Zend_Session_SaveHandler_DbTable
Zend_Soap
Zend_Soap_Server
Zend_Soap_Client
WSDL Zugriffsmethoden
AutoDiscovery
Zend_Tag
Einführung
Zend_Tag_Cloud
Zend_Test
Einführung
Zend_Test_PHPUnit
Zend_Test_PHPUnit_Db
Zend_Text
Zend_Text_Figlet
Zend_Text_Table
Zend_TimeSync
Einführung
Arbeiten mit Zend_TimeSync
Zend_Tool
Verwendung von Zend_Tool auf der Kommandozeile
Zend_Tool erweitern
Zend_Tool_Framework
Einführung
Verwenden des CLI Tools
Architektur
Erstellen von Providern für die Verwendung mit Zend_Tool_Framework
Mitgelieferte System Provider
Extending and Configuring Zend_Tool_Framework
Zend_Tool_Project
Einführung
Ein Projekt erstellen
Project Provider für Zend_Tool
Zend_Tool_Project Internas
Zend_Translate
Einführung
Adapter für Zend_Translate
Verwendung der Übersetzungsadapter
Erstellen von Quelldateien
Zusätzliche Features für Übersetzungen
Schreibweisen von Pluralformen für Übersetzungen
Zend_Uri
Zend_Uri
Zend_Validate
Einführung
Standard Prüfklassen
Kettenprüfungen
Schreiben von Prüfern
Prüfungsmeldungen
Zend_Version
Die Version des Zend Frameworks erhalten
Zend_View
Einführung
Controller Skripte
View Scripte
View Helfer
Zend_View_Abstract
Zend_Wildfire
Zend_Wildfire
Zend_XmlRpc
Einführung
Zend_XmlRpc_Client
Zend_XmlRpc_Server
ZendX_Console_Process_Unix
ZendX_Console_Process_Unix
ZendX_JQuery
Introduction
ZendX_JQuery View Helpers
ZendX_JQuery Form Elements and Decorators
Zend Framework Voraussetzungen
Einführung
Zend Framework's Migrationshinweise
Zend Framework 1.10
Zend Framework 1.9
Zend Framework 1.8
Zend Framework 1.7
Zend Framework 1.6
Zend Framework 1.5
Zend Framework 1.0
Zend Framework 0.9
Zend Framework 0.8
Zend Framework 0.6
Zend Framework Coding Standard für PHP
Übersicht
PHP Dateiformatierung
Namens Konventionen
Code Stil
Zend Framework Dokumentations Standard
Übersicht
Formatierung von Dokumentationsdateien
Empfehlungen
Vorgeschlagene Struktur für die Projekt Struktur von Zend Framework MVC Anwendungen
Übersicht
Vorgeschlagene Verzeichnis Struktur für Projekte
Modul Struktur
Leitfaden für die Rewrite Konfiguration
Zend Framework's Performanceratgeber
Einführung
Laden von Klassen
Zend_Db Performance
Internationalisierung (I18n) und Lokalisierung (L10n)
Darstellen der View
Urheberrecht Informationen