repo_zf1/documentation/manual/pl/module_specs/Zend_Db_Select.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- Reviewed: no -->
<sect1 id="zend.db.select">
    <title>Zend_Db_Select</title>

    <sect2 id="zend.db.select.introduction">
        <title>Wprowadzenie</title>

        <para>
        	Obiekt <classname>Zend_Db_Select</classname> reprezentuje pojedyncze polecenie
        	<acronym>SQL</acronym> <acronym>SELECT</acronym>. Klasa posiada metody służące do
        	umieszczenia poszczególnych części zapytania. Za jej pomocą można zapisać elementy
        	zapytania poprzez metody i struktur danych <acronym>PHP</acronym> a klasa sama 
        	tworzy poprawne polecenie <acronym>SQL</acronym>. Po zbudowaniu zapytania można go
        	użyć tak jakby było napisane w postaci zwykłego łańcucha znaków.
        </para>

        <para>
        	Wartość <classname>Zend_Db_Select</classname> zawiera się w poniższych cechach:
        </para>

        <itemizedlist>
            <listitem>
                <para>
                	Metody obiektowe służące tworzeniu zapytań <acronym>SQL</acronym> krok po 
                	kroku;
                </para>
            </listitem>

            <listitem>
                <para>
                	Poziom abstrakcji umożliwiający używanie określonych części zapytania 
                	<acronym>SQL</acronym> są w sposób niezależny od rodzaju bazy danych;
                </para>
            </listitem>

            <listitem>
                <para>
                	Automatyczne umieszczanie identyfikatorów metadanych w cudzysłowach ułatwia 
                	używanie identyfikatorów zawierających zarezerwowane słowa i specjalne znaki 
                	<acronym>SQL</acronym>;
                </para>
            </listitem>

            <listitem>
                <para>
                	Umieszczanie identyfikatorów i wartości w cudzysłowach pomaga ograniczyć 
                	ryzyko ataków wstrzykiwania kodu <acronym>SQL</acronym> (<acronym>SQL</acronym>
                	injection);
                </para>
            </listitem>
        </itemizedlist>

        <para>
        	Używanie <classname>Zend_Db_Select</classname> nie jest obowiązkowe. Dla najprostrzych
        	zapytań SELECT z reguły łatwiej jest zapisać całe polecenie <acronym>SQL</acronym> w 
        	postaci łańcucha znaków i wywołać je za pomocą metod Adaptera takich jak 
        	<methodname>query()</methodname> lub <methodname>fetchAll()</methodname>. Użycie
        	<classname>Zend_Db_Select</classname> jest przydatne jeśli zajdzie potrzeba połączenia 
        	części złożonego zapytania w kodzie np. w zależności od wystąpienia dodatkowych warunków 
        	logicznych.
        </para>

    </sect2>

    <sect2 id="zend.db.select.creating">

        <title>Tworzenie objektu Select</title>

        <para>
        	Instancję klasy <classname>Zend_Db_Select</classname> można utworzyć poprzez metodę 
        	<methodname>select()</methodname> obiektu <classname>Zend_Db_Adapter_Abstract</classname>.
        </para>

        <example id="zend.db.select.creating.example-db">

            <title>Przykład metody select() adaptera bazy danych</title>

            <programlisting language="php"><![CDATA[
$db = Zend_Db::factory( ...options... );
$select = $db->select();
]]></programlisting>

        </example>

        <para>
        	Innym sposobem utworzenia objektu <classname>Zend_Db_Select</classname> jest użycie
        	konstruktora, podając adapter bazy danych w argumencie.
        </para>

        <example id="zend.db.select.creating.example-new">

            <title>Przykład tworzenia nowego obiektu Select</title>

            <programlisting language="php"><![CDATA[
$db = Zend_Db::factory( ...options... );
$select = new Zend_Db_Select($db);
]]></programlisting>

        </example>

    </sect2>

    <sect2 id="zend.db.select.building">

        <title>Tworzenie poleceń Select</title>

        <para>
        	Budując zapytanie można dodawać jego części jedna po drugiej. Obiekt 
        	<classname>Zend_Db_Select</classname> posiada odrębne metody dla każdej klauzuli 
        	<acronym>SQL</acronym>.
        </para>

        <example id="zend.db.select.building.example">

            <title>Przykład użycia metod służących dodawaniu części zapytania</title>

            <programlisting language="php"><![CDATA[
// Utworzenie objektu Zend_Db_Select
$select = $db->select();

// Dodanie klauzuli FROM
$select->from( ...podanie tabel i kolumn... )

// Dodanie klauzuli WHERE
$select->where( ...podanie kryteriów ograniczenia... )

// Dodanie klauzuli ORDER BY
$select->order( ...podanie kryteriów sortowania... );
]]></programlisting>

        </example>

        <para>
        	Większości metod obiektu <classname>Zend_Db_Select</classname> można używać za pomocą przyjaznego
        	płynego interfejsu (fluent interface). Interfejs płynny oznacza, że każda z metod zwraca
        	referencję do obiektu wywołującego więc można od razu użyć następnej metody.
        </para>

        <example id="zend.db.select.building.example-fluent">

            <title>Przykład użycia płynego interfejsu</title>

            <programlisting language="php"><![CDATA[
$select = $db->select()
    ->from( ...podanie tabel i kolumn... )
    ->where( ...podanie kryteriów ograniczenia... )
    ->order( ...podanie kryteriów sortowania... );
]]></programlisting>

        </example>

        <para>
        	Przykłady w tym rozdziale używają płynnego interfejsu ale zawsze można z niego zrezygnować.
        	Często może się to okazać niezbędne w przypadku gdy należy wykonać operacje zgodne
        	z logiką biznesową aplikacji przed umieszczeniem dodatkowej klauzuli w zapytaniu.
        </para>

        <sect3 id="zend.db.select.building.from">

            <title>Dodawanie klauzuli FROM</title>

            <para>
            	Można wybrać tabelę dla zapytania używając metody <methodname>from()</methodname>.
            	Aby tego dokonać należy podać nazwę tabeli jako łańcuch znaków.
            	<classname>Zend_Db_Select</classname> umieszcza cudzysłowy wokół podanej nazwy, więc
            	można używać znaków specjalnych.
            </para>

            <example id="zend.db.select.building.from.example">

                <title>Przykład używacia metody from()</title>

                <programlisting language="php"><![CDATA[
// Utworzenie zapytania:
//   SELECT *
//   FROM "products"

$select = $db->select()
             ->from( 'products' );
]]></programlisting>

            </example>

            <para>
            	Można podać również nazwę korelacyjną (nazywaną również "aliasem tabeli") danej tabeli.
            	Aby to zrobić w argumencie należy podać tablicę asocjacyjną, która będzie zawierała 
            	mapowanie nazwy aliasu na nazwę tabeli. W pozostałych częściach zapytania 
            	<acronym>SQL</acronym> będzie można używać tej nazwy zamiast tabeli. Jeśli dane zapytanie
            	łączy wiele tabel <classname>Zend_Db_Select</classname> utworzy unikalne aliasy na 
            	podstawie prawdziwych nazw dla każdej tabeli dla której nie zrobi tego użytkownik.
            </para>

            <example id="zend.db.select.building.from.example-cname">

                <title>Przykład użycia aliasu</title>

                <programlisting language="php"><![CDATA[
// Utworzenie zapytania:
//   SELECT p.*
//   FROM "products" AS p

$select = $db->select()
             ->from( array('p' => 'products') );
]]></programlisting>

            </example>

            <para>
            	Niektóre silniki bazy danych (<acronym>RDBMS</acronym>) wspierają podawanie nazw schematu
            	przed nazwą tabeli. W takim przypadku należy podać nazwę tabeli jako 
            	"<code>nazwaSchematu.nazwaTabeli</code>" a <classname>Zend_Db_Select</classname>
            	umieści w cudzysłowach każdą z części takiej nazwy indywidualnie. Można też podać
            	nazwę schematu oddzielnie. Nazwa schematu podana przy nazwie tabeli ma pierwszeństwo
            	wobec nazwy schematu podanej osobno (jeśli obie występują). 
            </para>

            <example id="zend.db.select.building.from.example-schema">

                <title>Przykład podawania nazwy schematu</title>

                <programlisting language="php"><![CDATA[
// Utworzenie zapytania:
//   SELECT *
//   FROM "myschema"."products"

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

// lub

$select = $db->select()
             ->from('products', '*', 'myschema');
]]></programlisting>

            </example>

        </sect3>

        <sect3 id="zend.db.select.building.columns">

            <title>Dodawanie kolumn</title>

            <para>
            	Drugi argument metody <methodname>from()</methodname> może zawierać kolumny, które
            	mają zostać pobrane z odpowiedniej tabeli. Jeśli nie poda się tego argumentu domyślną
            	wartością jest "<code>*</code>" czyli znak specjalny <acronym>SQL</acronym> odpowiadający
            	wszystkim kolumnom.
            </para>

            <para>
            	Kolumny można podawać w prostej tablicy łańcuchów tekstowych lub jako asocjacyjnej
            	tablicy aliasów kolumn do nazw kolumn. Jeśli potrzebna jest tylko jedna kolumna to 
            	można ją podać w prostym stringu - nie trzeba używać tablicy.
            </para>

            <para>
            	Jeśli w tym argumencie zostanie podana pusta tablica to żadna kolumna z odpowiedniej
            	tabeli nie zostanie dołączona do wyniku zapytania. Zobacz
            	<link linkend="zend.db.select.building.join.example-no-columns">przykład kodu</link>
            	znajdujący się pod rozdziałem dotyczącym metody <methodname>join()</methodname>.
            </para>

            <para>
            	Nazwę kolumny można podać w formie "<code>nazwaAliasu.nazwaKolumny</code>".
            	<classname>Zend_Db_Select</classname> umieści każdą z części nazwy oddzielnie
            	w cudzysłowach, używając aliasu wcześniej ustalonego w metodzie 
            	<methodname>from()</methodname> (jeśli nie został podany bezpośrednio). 
            </para>

            <example id="zend.db.select.building.columns.example">

                <title>Przykład dodawania kolumn</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p

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

// Tworzenie podobnego zapytania z użyciem aliasów tabeli:
//   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'));

// Tworzenie podobnego zapytania z aliasem dla jednej kolumny:
//   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'));
]]></programlisting>

            </example>

        </sect3>

        <sect3 id="zend.db.select.building.columns-expr">

            <title>Dodawanie kolumn z wyrażeniami</title>

            <para>
            	W zapytaniach <acronym>SQL</acronym> często zachodzi potrzeba użycia wyrażeń 
            	zamiast zwykłych kolumn tabeli. Wyrażenia nie powinny być otoczone cudzysłowami
            	ani zawierać aliasów tabel. Jeśli podana kolumna zawiera nawiasy 
            	<classname>Zend_Db_Select</classname> rozpoznaje ją jako wyrażenie.
            </para>

            <para>
            	Można również samemu utworzyć obiekt klasy <classname>Zend_Db_Expr</classname>
            	aby łańcuch znaków nie został potraktowany jak zwykła nazwa kolumny.
            	<classname>Zend_Db_Expr</classname> jest małą klasą zawierającą jeden string.
            	<classname>Zend_Db_Select</classname> rozpoznaje instancje klasy 
            	<classname>Zend_Db_Expr</classname> i zamienia je na łańcuchy znaków ale nie
            	wprowadza zmian takich jak cudzysłowy czy aliasy tabel.
            </para>

            <note>

                <para>
                	Używanie <classname>Zend_Db_Expr</classname> dla wyrażeń nie jest obowiązkowe
                	jeśli zawiera ono nawiasy. <classname>Zend_Db_Select</classname> rozpoznaje
                	nawiasy i traktuje dany łańcuch jak wyrażenie (nie umieszcza w cudzysłowach
                	ani nie dodanie nazw alias tabel).
                </para>

            </note>

            <example id="zend.db.select.building.columns-expr.example">

                <title>Przykłady podawania kolumn zawierających wyrażenia</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   SELECT p."product_id", LOWER(product_name)
//   FROM "products" AS p
// Wyrażenie z nawiasami staje się obiektem klasy Zend_Db_Expr.

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

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

// Tworzenie zapytania używając 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'))
                    );
]]></programlisting>

            </example>

            <para>
            	W powyższych przykładach <classname>Zend_Db_Select</classname> nie zmienia stringa
            	i nie dodaje aliasów tabel ani nie używa cudzysłowów. Jeśli takie zmiany są niezbędne
            	(np. z powodu dwuznaczności nazw) należy je wprowadzić ręcznie.
            </para>

            <para>
            	Jeśli podane nazwy kolumn zawierają słowa kluczowe <acronym>SQL</acronym> lub 
            	znaki specjalne należy użyć metody adaptera połączenia o nazwie
            	<methodname>quoteIdentifier()</methodname> i rezultat umieścić w stringu. Metoda
            	<methodname>quoteIdentifier()</methodname> używa cudzysłowów dzięki czemu można być
            	pewnym, że podany łańcuch znaków jest identyfikatorem tabeli lub kolumny
            	a nie częścią składni polecenia <acronym>SQL</acronym>.
            </para>

            <para>
            	Dzięki użyciu metody <methodname>quoteIdentifier()</methodname> zamiast ręcznego
            	wpisywania cudzysłowów kod staje się niezależny od rodzaju bazy danych. Niektóre
            	systemy zarządzania bazą danych (<acronym>RDBMS</acronym>) używają niestandardowych
            	znaków do ograniczania identyfikatorów. Metoda <methodname>quoteIdentifier()</methodname>
            	jest przystosowana do używania odpowiednich symboli ograniczających w zależności
            	od typu używanego adaptera. Metoda <methodname>quoteIdentifier()</methodname> dokonuje
            	również unikania znaków cudzysłowia, które pojawią się w argumencie wejściowym.
            </para>

            <example id="zend.db.select.building.columns-quoteid.example">

                <title>Przykłady umieszczania wyrażeń w cudzysłowach</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania, 
// umieszczając kolumnę o nazwie "from" w cudzysłowach:
//   SELECT p."from" + 10 AS origin
//   FROM "products" AS p

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

            </example>

        </sect3>

        <sect3 id="zend.db.select.building.columns-atomic">

            <title>Dodawanie kolumn do wcześniej utworzonej klauzuli FROM lub JOIN</title>

            <para>
            	Może powstać sytuacja w której niezbędne okazuje się dodanie kolumn do klauzuli
            	FROM lub JOIN, która została utworzona wcześniej (za pomocą odpowiedniej metody).
            	Metoda <methodname>columns()</methodname> pozwala na dodanie kolumn w dowolnym
            	momencie przed wykonaniem zapytania. Kolumny można podać jako łańcuchy znaków,
            	obiekty <classname>Zend_Db_Expr</classname> lub jako tablice tych elementów. Drugi
            	argument tej metody może zostać pominięty co oznacza, że kolumny powinny zostać 
            	dodane do tabeli z klauzuli FROM. W przeciwnym razie należy podać alias lub nazwę
            	tabeli.
            </para>

            <example id="zend.db.select.building.columns-atomic.example">

                <title>Przykłady dodawania kolumn metodą columns()</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p

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

// Tworzenie zapytania używając nazwy alias:
//   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');
             // Alternatywnie można użyć columns('p.product_name')
]]></programlisting>

            </example>

        </sect3>

        <sect3 id="zend.db.select.building.join">

            <title>Dodawanie tabeli do zapytania za pomocą JOIN</title>

            <para>
            	Wiele użytecznych zapytań zawiera klauzulę <acronym>JOIN</acronym> służącą do
            	łączenia wierszy z wielu tabel. Aby dodać tabele do obiektu
            	<classname>Zend_Db_Select</classname> należy użyć metody 
            	<methodname>join()</methodname>. Używanie jej jest podobne do użycia metody
            	<methodname>from()</methodname> z tym, że tu można również użyć warunek łączenia
            	tabel.
            </para>

            <example id="zend.db.select.building.join.example">

                <title>Przykład użycia metody join()</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   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');
]]></programlisting>

            </example>

            <para>
            	Drugi argument metody <methodname>join()</methodname> to string stanowiący warunek
            	połączenia. Jest to wyrażenie określające kryteria wg. których wiersze z jednej tabeli
            	łączą się z wierszami drugiej tabeli. W tym miejscu można użyć aliasów tabel.
            </para>

            <note>

                <para>
                	Do warunku połączenia nie są stosowane cudzysłowy; Jeśli występuje konieczność
                	umieszczenia nazwy kolumny w cudzysłowach, należy użyć metody adaptera
                	<methodname>quoteIdentifier()</methodname> przy formowaniu wyrażenia warunku 
                	połączenia.
                </para>

            </note>

            <para>
            	Trzeci argument metody <methodname>join()</methodname> to tablica nazw kolumn (tak 
            	jak przy metodzie <methodname>from()</methodname>). Domyślną wartością jest 
            	"<code>*</code>". Można w nim podawać aliasy kolumn, wyrażenia lub obiekty
            	<classname>Zend_Db_Expr</classname> w taki sam sposób jak w metodzie
            	<methodname>from()</methodname>.
            </para>

            <para>
            	Aby nie wybierać żadnej kolumny należy podać pustą tablicę zamiast nazw kolumn.
            	Ten sposób działa również w metodzie <methodname>from()</methodname> ale z 
            	podstawowych tabel przeważnie kolumny są potrzebne, co nie zawsze jest prawdą 
            	dla kolumn tabeli połączonej.
            </para>

            <example id="zend.db.select.building.join.example-no-columns">

                <title>Przykład nie podawania kolumn</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   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() ); // pusta lista kolumn
]]></programlisting>

                <para>
                	W miejscu listy kolum tabeli połączonej występuje pusta tablica
                	(<methodname>array()</methodname>).
                </para>

            </example>

            <para>
            	<acronym>SQL</acronym> dysponuje wieloma rodzajami klauzul JOIN. Poniżej znajduje
            	się lista metod klasy <classname>Zend_Db_Select</classname> obsługująca je.
            </para>

            <itemizedlist>
                <listitem>
                    <para>
                    	<command>INNER JOIN</command> za pomocą <methodname>join(tabela, warunek, [kolumny])</methodname>
                    	lub <methodname>joinInner(tabela, warunek, [kolumny])</methodname>
                    </para>

                    <para>
                    	To jest najbardziej popularny rodzaj połączenia JOIN. Wiersze z każdej tabeli
                    	są porównywane za pomocą podanego warunku. Zbiór wyjściowy zawiera jedynie
                    	wiersze, które spełniają warunek połączenia. Jeśli żadna para wierszy nie
                    	spełnia warunku to zbiór pozostanie pusty.
                    </para>

                    <para>
                    	Wszystkie systemy zarządzania bazą danych (<acronym>RDBMS</acronym>) posiadają
                    	implementację tego rodzaju polecenia JOIN.
                    </para>
                </listitem>

                <listitem>
                    <para>
                    	<command>LEFT JOIN</command> za pomocą metody
                        <methodname>joinLeft(tabela, warunek, [kolumny])</methodname>.
                    </para>

                    <para>
                    	Wszystkie wiersze z tabeli znajdującej się po lewej stronie "wchodzą"
                    	do wyniku. Te, które nie mają odpowiadającego wiersza w tabeli znajdującej
                    	się po stronie prawej - zostają wypełnione wartościami <constant>NULL</constant>
                    	(w kolumnach z prawej tabeli).
                    </para>

                    <para>
                    	Wszystkie systemy zarządzania bazą danych (<acronym>RDBMS</acronym>) posiadają
                    	implementację tego rodzaju polecenia JOIN.
                    </para>
                </listitem>

                <listitem>
                    <para>
                    	<command>RIGHT JOIN</command> za pomocą metody
                        <methodname>joinRight(tabela, warunek, [kolumny])</methodname>
                    </para>

                    <para>
                    	RIGHT JOIN to przeciwieństwo LEFT JOIN. Wszystkie wiersze z tabeli znajdującej
                    	się po prawej stronie są umieszczone w wyniku. Te, które nie posiadają 
                    	odpowiednika w tabeli lewej otrzymują wartości <constant>NULL</constant>
                    	w kolumnach z lewej tabeli.
                    </para>

                    <para>
                    	Niektóre systemy zarządzania bazą danych (<acronym>RDBMS</acronym>) nie
                    	wspierają tego typu polecenia JOIN ale generalnie każdy
                    	<command>RIGHT JOIN</command> może zostać zaprezentowany jako 
                    	<command>LEFT JOIN</command> poprzez odwrócenie kolejności dodawania tabel.
                    </para>
                </listitem>

                <listitem>
                    <para>
                    	<command>FULL JOIN</command> za pomocą metody
                        <methodname>joinFull(tabela, warunek, [kolumny])</methodname>
                    </para>

                    <para>
                    	To polecenie jest jak połączenie <command>LEFT JOIN</command> oraz
                    	<command>RIGHT JOIN</command>. Wszystkie wiersze z obu tabel są włączane
                    	do wyniku. Jeśli dany wiersz nie posiada odpowiednika spełniającego warunek
                    	połączenia w drugiej tabeli to w kolumnach z tej tabeli umieszczony jest
                    	<constant>NULL</constant>.
                    </para>

                    <para>
                    	Niektóre systemy zarządzania bazą danych (<acronym>RDBMS</acronym>) nie
                    	wspierają tego typu polecenia JOIN.
                    </para>
                </listitem>

                <listitem>
                    <para>
                    	<command>CROSS JOIN</command> za pomocą metody 
                        <methodname>joinCross(tabela, [kolumny])</methodname>.
                    </para>

                    <para>
                    	Cross join to iloczyn kartezjański tabel. Każdy wiersz z pierwszej tabeli 
                    	zostaje połączony z każdym wierszem z tabeli drugiej. Ilość wierszy w zbiorze
                    	wynikowym jest równa iloczynowi ilości wierszy w obu tabelach. Poprzez użycie 
                    	warunku WHERE można ograniczyć wiersze wynikowe przez co cross join może być
                    	podobny do składni polecenia join ze standardu SQL-89.
                    </para>

                    <para>
                    	Metoda <methodname>joinCross()</methodname> nie ma parametru odnoszącego się
                    	do warunku połączenia. Niektóre systemy zarządzania bazą danych 
                        (<acronym>RDBMS</acronym>) nie wspierają tego typu polecenia JOIN.
                    </para>
                </listitem>

                <listitem>
                    <para>
                    	<command>NATURAL JOIN</command> za pomocą metody
                        <methodname>joinNatural(tabela, [kolumny])</methodname>.
                    </para>

                    <para>
                    	Polecenie natural join łączy wiersze pod względem wszystkich kolumn, które
                    	mają taką samą nazwę w obydwu tabelach. Warunkiem połączenia jest zgodność
                    	wartości wszystkich tak samo nazwanych kolumn tabel. Porównywanie wartości
                    	na zasadzie niezgodności (różnicy) nie stanowi polecenia natural join. 
                    	Jedynie polecenia typu natural inner join są zaimplementowane w tym API 
                    	pomimo tego że standard <acronym>SQL</acronym> definiuje też polecenia
                    	natural outer join.
                    </para>

                    <para>
                    	Metoda <methodname>joinCross()</methodname> nie ma parametru odnoszącego się
                    	do warunku połączenia.
                    </para>
                </listitem>
            </itemizedlist>

            <para>
            	Oprócz powyższych metod można uprościć zapytania używając metod JoinUsing. Zamiast
            	podawania pełnego warunku można wybrać nazwę kolumny, na podstawie której 
            	połączenie będzie przeprowadzone a obiekt <classname>Zend_Db_Select</classname>
            	dopisze niezbędną część polecenia warunku.
            </para>

            <example id="zend.db.select.building.joinusing.example">

                <title>Przykład użycia metody joinUsing()</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   SELECT *
//   FROM "table1"
//   JOIN "table2"
//   ON "table1".column1 = "table2".column1
//   WHERE column2 = 'foo'

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

            </example>

            <para>
            	Każda z metod połączenia klasy <classname>Zend_Db_Select</classname> ma 
            	odpowiednią metodę 'using'.
            </para>

            <itemizedlist>
                <listitem>
                    <para>
                        <methodname>joinUsing(tabela, [kolumny])</methodname> and
                        <methodname>joinInnerUsing(tabela, [kolumny])</methodname>
                    </para>
                </listitem>

                <listitem>
                    <para>
                        <methodname>joinLeftUsing(tabela, [kolumny])</methodname>
                    </para>
                </listitem>

                <listitem>
                    <para>
                        <methodname>joinRightUsing(tabela, [kolumny])</methodname>
                    </para>
                </listitem>

                <listitem>
                    <para>
                        <methodname>joinFullUsing(tabela, [kolumny])</methodname>
                    </para>
                </listitem>
            </itemizedlist>

        </sect3>

        <sect3 id="zend.db.select.building.where">

            <title>Dodawanie klauzuli WHERE</title>

            <para>
            	Za pomocą metody <methodname>where()</methodname> można określić kryteria
            	ograniczające ilość wierszy zwracanych przez zapytanie. Pierwszy argument tej
            	metody to wyrażenie <acronym>SQL</acronym> które zostanie użyte w klauzuli
            	WHERE zapytania <acronym>SQL</acronym>.
            </para>

            <example id="zend.db.select.building.where.example">

                <title>Przykład użycia metody where()</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   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');
]]></programlisting>

            </example>

            <note>

                <para>
                	Wyrażenia w metodach <methodname>where()</methodname> lub
                	<methodname>orWhere()</methodname> nie zostają umieszczone w cudzysłowach.
                	Jeśli nazwa kolumny tego wymaga należy użyć metody 
                	<methodname>quoteIdentifier()</methodname> podczas tworzenia parametru warunku.
                </para>

            </note>

            <para>
            	Drugi argument metody <methodname>where()</methodname> jest opcjonalny. Stanowi on
            	wartość umieszczaną w warunku. <classname>Zend_Db_Select</classname> ogranicza tą 
            	wartość cudzysłowami i za jej pomocą podmienia symbol znaku zapytania 
            	("<code>?</code>") w warunku.
            </para>

            <example id="zend.db.select.building.where.example-param">

                <title>Przykład użycia parametru w metodzie where()</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   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);
]]></programlisting>

            </example>

            <para>
            	Drugi parametr metody <methodname>where()</methodname> przyjmuje również
            	tablicę w przypadku gdy używa się operatora IN.
            </para>

            <example id="zend.db.select.building.where.example-array">

                <title>Przykład użycia tablicy w metodzie where()</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   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);
]]></programlisting>

            </example>

            <para>
            	Metoda <methodname>where()</methodname> może być wywoływana wiele razy dla jednego
            	obiektu <classname>Zend_Db_Select</classname>. Zapytanie wynikowe łączy wszystkie
            	warunki używając wyrażenia <acronym>AND</acronym>.
            </para>

            <example id="zend.db.select.building.where.example-and">

                <title>Przykład wywołania metody where() wiele razy</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   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);
]]></programlisting>

            </example>

            <para>
            	Jeśli istnieje potrzeba połączenia warunków za pomocą wyrażenia <acronym>OR</acronym>
            	należy użyć metody <methodname>orWhere()</methodname>. Można jej używać
            	w taki sam sposób jak metody <methodname>where()</methodname>. W wynikowym 
            	poleceniu warunki zostaną połączone wyrażeniem <acronym>OR</acronym>
            	zamiast <acronym>AND</acronym>.
            </para>

            <example id="zend.db.select.building.where.example-or">

                <title>Przykład użycia metody orWhere()</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   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);
]]></programlisting>

            </example>

            <para>
            	<classname>Zend_Db_Select</classname> automatycznie umieszcza wyrażenia podane
            	do metod <methodname>where()</methodname> lub <methodname>orWhere()</methodname>
            	w nawiasach. Dzięki temu kolejność wykonywania działań logicznych nie spowoduje
            	nieoczekiwanych rezultatów.
            </para>

            <example id="zend.db.select.building.where.example-parens">

                <title>Przykład umieszczania wyrażeń w nawiasach</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   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);
]]></programlisting>

            </example>

            <para>
            	W powyższym przykładzie zapytanie bez nawiasów przyniosłoby inny rezultat ponieważ
            	<acronym>AND</acronym> ma wyższy priorytet niż <acronym>OR</acronym>.
            	Dzięki nawiasom <classname>Zend_Db_Select</classname> sprawia, że każde 
            	wywołanie metody <methodname>where()</methodname> łączy zawarte w niej warunki
            	z wyższym priorytetem niż <acronym>AND</acronym> który łączy poszczególne warunki.
            </para>

        </sect3>

        <sect3 id="zend.db.select.building.group">

            <title>Adding a GROUP BY Clause</title>

            <para>
            	W <acronym>SQL</acronym>, klauzula <command>GROUP BY</command> pozwala na 
            	ograniczenie wierszy wyników zapytania do jednego wiersza na każdą unikalną wartość 
            	znalezioną w kolumnie podanej przy klauzuli <command>GROUP BY</command>.
            </para>

            <para>
            	Aby określić kolumny używane do podzielenia wyników na grupy w
            	<classname>Zend_Db_Select</classname> należy użyć metody <methodname>group()</methodname>.
            	Jako argument podaje się kolumnę lub tablicę kolumn, które mają trafić
            	do klauzuli <command>GROUP BY</command>.
            </para>

            <example id="zend.db.select.building.group.example">

                <title>Przykład użycia metody group()</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   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');
]]></programlisting>

            </example>

            <para>
            	Podobnie jak w przypadku metody <methodname>from()</methodname> w argumencie można 
            	używać aliasów tabel a nazwy są umieszczane w cudzysłowach jako identyfikatory chyba
            	że łańcuch znaków zawiera nawiasy lub jest obiektem <classname>Zend_Db_Expr</classname>.
            </para>

        </sect3>

        <sect3 id="zend.db.select.building.having">

            <title>Dodawanie klauzuli HAVING</title>

            <para>
            	W <acronym>SQL</acronym>, klauzula <constant>HAVING</constant> wprowadza ograniczenie
            	w stosunku do grup wierszy. Jest to podobne do sposobu w jaki klauzula 
            	<constant>WHERE</constant> ogranicza wiersze ogólnie. Te klauzule są różne ponieważ
            	warunki <constant>WHERE</constant> są oceniane prze definiowaniem grup, podczas gdy
            	warunki <constant>HAVING</constant> nakładane są po uformowaniu grup.
            </para>

            <para>
            	W <classname>Zend_Db_Select</classname> można określić warunki dotyczące grup wierszy
            	za pomocą metody <methodname>having()</methodname>. Użycie jej jest podobne do metody
            	<methodname>where()</methodname>. Pierwszy argument to string zawierający wyrażenie
            	<acronym>SQL</acronym>. Opcjonalny drugi argument to wartość używana do zamienienia
            	pozycyjnych parametrów w wyrażeniu <acronym>SQL</acronym>. Wyrażenia umieszczone w
            	wielu wywołaniach metody <methodname>having()</methodname> są łączone za pomocą 
            	operatora <constant>AND</constant> lub <code>OR</code> - jeśli zostanie użyta metoda
            	<methodname>orHaving()</methodname>.
            </para>

            <example id="zend.db.select.building.having.example">

                <title>Przykład użycia metody having()</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   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');
]]></programlisting>

            </example>

            <note>

                <para>
                	W metodach <methodname>having()</methodname> oraz
                	<methodname>orHaving()</methodname> nie jest stosowane umieszczanie 
                	identyfikatorów w cudzysłowach. Jeśli nazwa kolumny tego wymaga należy użyć 
                	metody <methodname>quoteIdentifier()</methodname> podczas tworzenia parametru 
                	warunku.
                </para>

            </note>

        </sect3>

        <sect3 id="zend.db.select.building.order">

            <title>Dodawanie klauzuli ORDER BY</title>

            <para>
            	W <acronym>SQL</acronym>, klauzula <code>ORDER BY</code> określa jedną bądź więcej
            	kolumn lub wyrażeń według których zbiór wynikowy jest posortowany. Jeśli poda się
            	wiele kolumn to sortowanie odbywa się w pierwszej kolejności na podstawie wcześniej
            	podanej kolumny. Jeśli istnieją wiersze o takiej samej wartośći w danej kolumnie 
            	to do sortowania używana jest kolejna klumna klauzuli <code>ORDER BY</code>. Domyślny 
            	kierunek sortowania to od najmniejszej wartości do największej. Można sortować w 
            	przeciwnym kierunku przez użycie słowa kluczowego <constant>DESC</constant> po 
            	nazwie kolumny sortowania.
            </para>

            <para>
            	W <classname>Zend_Db_Select</classname> można użyć metody <methodname>order()</methodname>
            	i podać kolumnę lub tablicę kolumn według których sortowanie ma przebiegać. Każdy z
            	elementów tablicy powinien być łańcuchem znaków określającym kolumnę. Opcjonalnie
            	można dodać słowa kluczowe <constant>ASC</constant> lub <constant>DESC</constant>
            	oddzielone od kolumny spacją.
            </para>

            <para>
            	Podobnie jak przy metodach <methodname>from()</methodname> oraz
            	<methodname>group()</methodname> nazwy kolumn są otaczane cudzysłowami, chyba że
            	zawierają nawiasy lub są obiektami klasy <classname>Zend_Db_Expr</classname>.
            </para>

            <example id="zend.db.select.building.order.example">

                <title>Przykład użycia metody order()</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   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'));
]]></programlisting>

            </example>

        </sect3>

        <sect3 id="zend.db.select.building.limit">

            <title>Dodawanie klauzuli LIMIT</title>

            <para>
            	Niektóre systemy zarządzania bazą danych (<acronym>RDBMS</acronym>) rozszerzają
            	<acronym>SQL</acronym> za pomocą klauzuli <constant>LIMIT</constant>. Za jej 
            	pomocą można ograniczyć ilość wierszy zwracanych w zapytaniu do podanej ilości.
            	Można również określić ilość wierszy, która ma zostać opuszczona przed rozpoczęciem
            	zwracania wyników zapytania. Dzięki temu można w łatwy sposób uzyskać podzbiór
            	ze zbioru wynikowego. Może to być przydatne np. przy wyświetlaniu rezultatów zapytania
            	z podziałem na strony.
            </para>

            <para>
            	W <classname>Zend_Db_Select</classname> można użyć metody 
            	<methodname>limit()</methodname> aby określić ilość wierszy do zwrócenia oraz do
            	opuszczenia. <emphasis>Pierswszy</emphasis> argumement metody to ilość wierszy
            	jaka maksymalnie ma zostać zwrócona. <emphasis>Drugi</emphasis> argument to ilość
            	wierszy do opuszczenia.
            </para>

            <example id="zend.db.select.building.limit.example">

                <title>Przykład użycia metody limit()</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   SELECT p."product_id", p."product_name"
//   FROM "products" AS p
//   LIMIT 10, 20
// Equivalent to:
//   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);
]]></programlisting>

            </example>

            <note>

                <para>
                	Polecenie <constant>LIMIT</constant> nie jest wspierane przez wszystkie rodzaje
                	baz danych. Niektóre z nich wymagają innej składni dla uzyskania podobnego efektu.
                	Każda z klas <classname>Zend_Db_Adapter_Abstract</classname> zawiera metodę 
                	tworzącą polecenie <acronym>SQL</acronym> odpowiednie dla danego 
                	<acronym>RDBMS</acronym>.
                </para>

            </note>

            <para>
            	Można użyć metody <methodname>limitPage()</methodname> jako alternatywy do określania
            	ilości wierszy do zwrotu i do pominięcia. Ta metoda pozwala na podzielenie zbioru
            	wynikowego na wiele podzbiorów o stałej wielkości i zwrócenie jednego z nich.
            	Innymi słowy należy określić długość jednej "strony" z wynikami zapytania oraz liczbę
            	porządkową określającą stronę, która ma zostać zwrócona. Numer strony stanowi pierwszy
            	argument metody <methodname>limitPage()</methodname> a długość strony to drugi argument.
            	Obydwa argumenty są wymagane - nie mają wartości domyślnych.
            </para>

            <example id="zend.db.select.building.limit.example2">

                <title>Przykład użycia metody limitPage()</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   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);
]]></programlisting>

            </example>

        </sect3>

        <sect3 id="zend.db.select.building.distinct">

            <title>Dodawanie słowa kluczowego DISTINCT do zapytania</title>

            <para>
            	Metoda <methodname>distinct()</methodname> pozwala na dodanie słowa 
            	kluczowego <constant>DISTINCT</constant> do zapytania <acronym>SQL</acronym>.
            </para>

            <example id="zend.db.select.building.distinct.example">

                <title>Przykład użycia metody distinct()</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   SELECT DISTINCT p."product_name"
//   FROM "products" AS p

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

            </example>

        </sect3>

        <sect3 id="zend.db.select.building.for-update">

            <title>Dodawanie słowa kluczowego FOR UPDATE do zapytania</title>

            <para>
            	Metoda <methodname>forUpdate()</methodname> pozwala na dodanie słowa 
            	kluczowego <code>FOR UPDATE</code> do zapytania <acronym>SQL</acronym>.
            </para>

            <example id="zend.db.select.building.for-update.example">

                <title>Przykład użycia metody forUpdate()</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   SELECT FOR UPDATE p.*
//   FROM "products" AS p

$select = $db->select()
             ->forUpdate()
             ->from(array('p' => 'products'));
]]></programlisting>

            </example>

        </sect3>

        <sect3 id="zend.db.select.building.union">
            <title>Tworzenie zapytania z UNION</title>

            <para>
            	Z <classname>Zend_Db_Select</classname> można łączyć zapytania poprzez przekazanie tablicy
            	obiektów <classname>Zend_Db_Select</classname> lub łańcuchów zapytań do metody 
            	<methodname>union()</methodname>. Jako drugi parametr można podać stałe 
            	<constant>Zend_Db_Select::SQL_UNION</constant> lub <constant>Zend_Db_Select::SQL_UNION_ALL</constant>
            	aby określić rodzaj połączenia jaki chce się uzyskać.
            </para>

            <example id="zend.db.select.building.union.example">
                <title>Przykład użycia metody union()</title>

                <programlisting language="php"><![CDATA[
$sql1 = $db->select();
$sql2 = "SELECT ...";

$select = $db->select()
    ->union(array($sql1, $sql2))
    ->order("id");
]]></programlisting>
            </example>
        </sect3>

    </sect2>

    <sect2 id="zend.db.select.execute">

        <title>Wykonywanie zapytań Select</title>

        <para>
        	Poniższa część opisuje jak wywołać zapytanie zawarte w obiekcie
            <classname>Zend_Db_Select</classname>.
        </para>

        <sect3 id="zend.db.select.execute.query-adapter">

            <title>Wykonywanie zapytań Select z poziomu adaptera bazy danych</title>

            <para>
            	Zapytanie zawarte w obiekcie <classname>Zend_Db_Select</classname> można wywołać
            	poprzez podanie obiektu jako pierwszego argumentu metody <methodname>query()</methodname>
            	obiektu <classname>Zend_Db_Adapter_Abstract</classname>. Zalecane jest używanie
            	obiektów <classname>Zend_Db_Select</classname> zamiast łańcuchów znaków z zapytaniem.
            </para>

            <para>
            	Metoda <methodname>query()</methodname> w zależności od typu adaptera bazy danych
            	zwraca obiekt klasy <classname>Zend_Db_Statement</classname> lub PDOStatement.
            </para>

            <example id="zend.db.select.execute.query-adapter.example">

                <title>Przykład użycia metody query() adaptera bazy danych</title>

                <programlisting language="php"><![CDATA[
$select = $db->select()
             ->from('products');

$stmt = $db->query($select);
$result = $stmt->fetchAll();
]]></programlisting>

            </example>

        </sect3>

        <sect3 id="zend.db.select.execute.query-select">

            <title>Wykonywanie zapytań Select z samego obiektu</title>

            <para>
            	Jako alternatywny sposób w stosunku do użycia metody <methodname>query()</methodname>
            	adaptera bazy danych, można użyć metody o takiej samej nazwie obiektu 
            	<classname>Zend_Db_Select</classname>. Obydwie metody zwracają obiekt klasy
            	<classname>Zend_Db_Statement</classname> lub PDOStatement w zależności od typu 
            	użytego adaptera.
            </para>

            <example id="zend.db.select.execute.query-select.example">

                <title>Przykład użycia metody obiektu Zend_Db_Select</title>

                <programlisting language="php"><![CDATA[
$select = $db->select()
             ->from('products');

$stmt = $select->query();
$result = $stmt->fetchAll();
]]></programlisting>

            </example>

        </sect3>

        <sect3 id="zend.db.select.execute.tostring">

            <title>Zamiana obiektu Select w łańcuch polecenia SQL</title>

            <para>
            	Jeśli niezbędny jest dostęp do polecenia <acronym>SQL</acronym> w postaci łańcucha
            	znaków zawartego w obiekcie <classname>Zend_Db_Select</classname>, należy użyć
            	metody <methodname>__toString()</methodname>.
            </para>

            <example id="zend.db.select.execute.tostring.example">

                <title>Przykład użycia metody __toString()</title>

                <programlisting language="php"><![CDATA[
$select = $db->select()
             ->from('products');

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

// Wyjściowy string:
//   SELECT * FROM "products"
]]></programlisting>

            </example>

        </sect3>

    </sect2>

    <sect2 id="zend.db.select.other">

        <title>Inne metody</title>

        <para>
        	Ta część opisuje inne metody klasy <classname>Zend_Db_Select</classname>, które nie 
        	zostały wymienione wcześniej: <methodname>getPart()</methodname> oraz
            <methodname>reset()</methodname>.
        </para>

        <sect3 id="zend.db.select.other.get-part">

            <title>Uzyskanie części obiektu Select</title>

            <para>
            	Metoda <methodname>getPart()</methodname> zwraca postać łąńcucha znaków odpowiadającą
            	jednej części polecenia <acronym>SQL</acronym>. Można użyć tej metody aby uzyskać
            	tablicę warunków klauzuli <constant>WHERE</constant>, tablicę kolumn (lub wyrażeń)
            	zawartych w liście <constant>SELECT</constant> albo wartości ilości wierszy 
            	klauzuli <constant>LIMIT</constant>.
            </para>

            <para>
            	Wartością zwracaną nie jest string zawierający składnię <acronym>SQL</acronym>. 
            	Zamiast tego zwracana jest wewnętrzna postać danych, co przeważnie oznacza tablicę
            	zawierającą wartości i wyrażenia. Każda część zapytania ma inną strukturę.
            </para>

            <para>
            	Jedynym argumentem metody <methodname>getPart()</methodname> jest łańcuch znaków
            	identyfikujący żądaną część zapytania. String <code>'from'</code> odpowiada części
            	obiektu <classname>Zend_Db_Select</classname>, która przechowuje informacje o tabelach
            	(włączając w to tabele połączone) w klauzuli <constant>FROM</constant>.
            </para>

            <para>
            	Klasa <classname>Zend_Db_Select</classname> definiuje stałe, których można użyć 
            	jako oznaczeń zapytania <acronym>SQL</acronym>. Dozwolone jest stosowanie tych
            	stałych bądź nazw dosłownych.
            </para>

            <table id="zend.db.select.other.get-part.table">

                <title>Stałe używane przez metody getPart() oraz reset()</title>

                <tgroup cols="2">
                    <thead>
                        <row>
                            <entry>Stała</entry>
                            <entry>Wartość dosłowna</entry>
                        </row>
                    </thead>

                    <tbody>
                        <row>
                            <entry><constant>Zend_Db_Select::DISTINCT</constant></entry>
                            <entry><code>'distinct'</code></entry>
                        </row>

                        <row>
                            <entry><constant>Zend_Db_Select::FOR_UPDATE</constant></entry>
                            <entry><code>'forupdate'</code></entry>
                        </row>

                        <row>
                            <entry><constant>Zend_Db_Select::COLUMNS</constant></entry>
                            <entry><code>'columns'</code></entry>
                        </row>

                        <row>
                            <entry><constant>Zend_Db_Select::FROM</constant></entry>
                            <entry><code>'from'</code></entry>
                        </row>

                        <row>
                            <entry><constant>Zend_Db_Select::WHERE</constant></entry>
                            <entry><code>'where'</code></entry>
                        </row>

                        <row>
                            <entry><constant>Zend_Db_Select::GROUP</constant></entry>
                            <entry><code>'group'</code></entry>
                        </row>

                        <row>
                            <entry><constant>Zend_Db_Select::HAVING</constant></entry>
                            <entry><code>'having'</code></entry>
                        </row>

                        <row>
                            <entry><constant>Zend_Db_Select::ORDER</constant></entry>
                            <entry><code>'order'</code></entry>
                        </row>

                        <row>
                            <entry><constant>Zend_Db_Select::LIMIT_COUNT</constant></entry>
                            <entry><code>'limitcount'</code></entry>
                        </row>

                        <row>
                            <entry><constant>Zend_Db_Select::LIMIT_OFFSET</constant></entry>
                            <entry><code>'limitoffset'</code></entry>
                        </row>
                    </tbody>
                </tgroup>
            </table>

            <example id="zend.db.select.other.get-part.example">

                <title>Przykład użycia metody getPart()</title>

                <programlisting language="php"><![CDATA[
$select = $db->select()
             ->from('products')
             ->order('product_id');

// Można użyć dosłownej nazwy żądanej części
$orderData = $select->getPart( 'order' );

// Alternatywnie można posłużyć się stałą
$orderData = $select->getPart( Zend_Db_Select::ORDER );

// Wartość zwrotna może nie być stringiem a tablicą.
// Każda część zapytania może mieć inną strukturę.
print_r( $orderData );
]]></programlisting>

            </example>

        </sect3>

        <sect3 id="zend.db.select.other.reset">

            <title>Czyszczenie części obiektu Select</title>

            <para>
            	Metoda <methodname>reset()</methodname> umożliwia wyczyszczenie podanej części
            	lub całości (jeśli nie poda się argumentu) zapytania <acronym>SQL</acronym>.
            </para>

            <para>
            	Jedyny argument jest opcjonalny. Można podać w nim część zapytania przeznaczoną
            	do wyczyszczenia używając tych samych łąńcuchów co w przypadku metody
            	<methodname>getPart()</methodname>. Podana część zapytania jest ustawiana w stan
            	domyślny.
            </para>

            <para>
            	Jeśli nie poda się parametru, metoda <methodname>reset()</methodname> ustawia wszystkie
            	części zapytania w ich stan domyślny. Przez to używany obiekt
            	<classname>Zend_Db_Select</classname> odpowiada nowemu obiektowi, tak jakby
            	został on dopiero utworzony.
            </para>

            <example id="zend.db.select.other.reset.example">

                <title>Przykład użycia metody reset()</title>

                <programlisting language="php"><![CDATA[
// Tworzenie zapytania:
//   SELECT p.*
//   FROM "products" AS p
//   ORDER BY "product_name"

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

// Zmienione wymagania, sortowanie wg. innej kolumny:
//   SELECT p.*
//   FROM "products" AS p
//   ORDER BY "product_id"

// Wyczyszczenie jednej części aby można było ją ponownie zdefiniować
$select->reset( Zend_Db_Select::ORDER );

// Podanie nowej kolumny sortowania
$select->order('product_id');

// Wyczyszczenie wszystkich części zapytania
$select->reset();
]]></programlisting>

            </example>

        </sect3>

    </sect2>

</sect1>
<!--
vim:se ts=4 sw=4 et:
-->