documentation/manual/pl/module_specs/Zend_Db_Select.xml

   1 <?xml version="1.0" encoding="UTF-8"?>
   2 <!-- EN-Revision: 21584 -->
   3 <!-- Reviewed: no -->
   4 <sect1 id="zend.db.select">
   5     <title>Zend_Db_Select</title>
   6
   7     <sect2 id="zend.db.select.introduction">
   8         <title>Wprowadzenie</title>
   9
  10         <para>
  11             Obiekt <classname>Zend_Db_Select</classname> reprezentuje pojedyncze polecenie
  12             <acronym>SQL</acronym> <acronym>SELECT</acronym>. Klasa posiada metody służące do
  13             umieszczenia poszczególnych części zapytania. Za jej pomocą można zapisać elementy
  14             zapytania poprzez metody i struktur danych <acronym>PHP</acronym> a klasa sama
  15             tworzy poprawne polecenie <acronym>SQL</acronym>. Po zbudowaniu zapytania można go
  16             użyć tak jakby było napisane w postaci zwykłego łańcucha znaków.
  17         </para>
  18
  19         <para>
  20             Wartość <classname>Zend_Db_Select</classname> zawiera się w poniższych cechach:
  21         </para>
  22
  23         <itemizedlist>
  24             <listitem>
  25                 <para>
  26                     Metody obiektowe służące tworzeniu zapytań <acronym>SQL</acronym> krok po
  27                     kroku;
  28                 </para>
  29             </listitem>
  30
  31             <listitem>
  32                 <para>
  33                     Poziom abstrakcji umożliwiający używanie określonych części zapytania
  34                     <acronym>SQL</acronym> są w sposób niezależny od rodzaju bazy danych;
  35                 </para>
  36             </listitem>
  37
  38             <listitem>
  39                 <para>
  40                     Automatyczne umieszczanie identyfikatorów metadanych w cudzysłowach ułatwia
  41                     używanie identyfikatorów zawierających zarezerwowane słowa i specjalne znaki
  42                     <acronym>SQL</acronym>;
  43                 </para>
  44             </listitem>
  45
  46             <listitem>
  47                 <para>
  48                     Umieszczanie identyfikatorów i wartości w cudzysłowach pomaga ograniczyć
  49                     ryzyko ataków wstrzykiwania kodu <acronym>SQL</acronym> (<acronym>SQL</acronym>
  50                     injection);
  51                 </para>
  52             </listitem>
  53         </itemizedlist>
  54
  55         <para>
  56             Używanie <classname>Zend_Db_Select</classname> nie jest obowiązkowe. Dla najprostszych
  57             zapytań <acronym>SELECT</acronym> z reguły łatwiej jest zapisać
  58             całe polecenie <acronym>SQL</acronym> w
  59             postaci łańcucha znaków i wywołać je za pomocą metod Adaptera takich jak
  60             <methodname>query()</methodname> lub <methodname>fetchAll()</methodname>. Użycie
  61             <classname>Zend_Db_Select</classname> jest przydatne jeśli zajdzie potrzeba połączenia
  62             części złożonego zapytania w kodzie np. w zależności od wystąpienia dodatkowych warunków
  63             logicznych.
  64         </para>
  65
  66     </sect2>
  67
  68     <sect2 id="zend.db.select.creating">
  69
  70         <title>Tworzenie obiektu Select</title>
  71
  72         <para>
  73             Instancję klasy <classname>Zend_Db_Select</classname> można utworzyć poprzez metodę
  74             <methodname>select()</methodname> obiektu
  75             <classname>Zend_Db_Adapter_Abstract</classname>.
  76         </para>
  77
  78         <example id="zend.db.select.creating.example-db">
  79
  80             <title>Przykład metody select() adaptera bazy danych</title>
  81
  82             <programlisting language="php"><![CDATA[
  83 $db = Zend_Db::factory( ...options... );
  84 $select = $db->select();
  85 ]]></programlisting>
  86
  87         </example>
  88
  89         <para>
  90             Innym sposobem utworzenia obiektu <classname>Zend_Db_Select</classname> jest użycie
  91             konstruktora, podając adapter bazy danych w argumencie.
  92         </para>
  93
  94         <example id="zend.db.select.creating.example-new">
  95
  96             <title>Przykład tworzenia nowego obiektu Select</title>
  97
  98             <programlisting language="php"><![CDATA[
  99 $db = Zend_Db::factory( ...options... );
 100 $select = new Zend_Db_Select($db);
 101 ]]></programlisting>
 102
 103         </example>
 104
 105     </sect2>
 106
 107     <sect2 id="zend.db.select.building">
 108
 109         <title>Tworzenie poleceń Select</title>
 110
 111         <para>
 112             Budując zapytanie można dodawać jego części jedna po drugiej. Obiekt
 113             <classname>Zend_Db_Select</classname> posiada odrębne metody dla każdej klauzuli
 114             <acronym>SQL</acronym>.
 115         </para>
 116
 117         <example id="zend.db.select.building.example">
 118
 119             <title>Przykład użycia metod służących dodawaniu części zapytania</title>
 120
 121             <programlisting language="php"><![CDATA[
 122 // Utworzenie obiektu Zend_Db_Select
 123 $select = $db->select();
 124
 125 // Dodanie klauzuli FROM
 126 $select->from( ...podanie tabel i kolumn... )
 127
 128 // Dodanie klauzuli WHERE
 129 $select->where( ...podanie kryteriów ograniczenia... )
 130
 131 // Dodanie klauzuli ORDER BY
 132 $select->order( ...podanie kryteriów sortowania... );
 133 ]]></programlisting>
 134
 135         </example>
 136
 137         <para>
 138             Większości metod obiektu <classname>Zend_Db_Select</classname> można używać za pomocą
 139             przyjaznego płynnego interfejsu (fluent interface). Interfejs płynny oznacza, że
 140             każda z metod zwraca referencję do obiektu wywołującego więc można od razu
 141             użyć następnej metody.
 142         </para>
 143
 144         <example id="zend.db.select.building.example-fluent">
 145
 146             <title>Przykład użycia płynnego interfejsu</title>
 147
 148             <programlisting language="php"><![CDATA[
 149 $select = $db->select()
 150     ->from( ...podanie tabel i kolumn... )
 151     ->where( ...podanie kryteriów ograniczenia... )
 152     ->order( ...podanie kryteriów sortowania... );
 153 ]]></programlisting>
 154
 155         </example>
 156
 157         <para>
 158             Przykłady w tym rozdziale używają płynnego interfejsu ale zawsze można z niego
 159             zrezygnować.
 160             Często może się to okazać niezbędne w przypadku gdy należy wykonać operacje zgodne
 161             z logiką biznesową aplikacji przed umieszczeniem dodatkowej klauzuli w zapytaniu.
 162         </para>
 163
 164         <sect3 id="zend.db.select.building.from">
 165
 166             <title>Dodawanie klauzuli FROM</title>
 167
 168             <para>
 169                 Można wybrać tabelę dla zapytania używając metody <methodname>from()</methodname>.
 170                 Aby tego dokonać należy podać nazwę tabeli jako łańcuch znaków.
 171                 <classname>Zend_Db_Select</classname> umieszcza cudzysłowy wokół podanej nazwy, więc
 172                 można używać znaków specjalnych.
 173             </para>
 174
 175             <example id="zend.db.select.building.from.example">
 176
 177                 <title>Przykład użycia metody from()</title>
 178
 179                 <programlisting language="php"><![CDATA[
 180 // Utworzenie zapytania:
 181 //   SELECT *
 182 //   FROM "products"
 183
 184 $select = $db->select()
 185              ->from( 'products' );
 186 ]]></programlisting>
 187
 188             </example>
 189
 190             <para>
 191                 Można podać również nazwę korelacyjną (nazywaną również aliasem tabeli) danej
 192                 tabeli.
 193                 Aby to zrobić w argumencie należy podać tablicę asocjacyjną, która będzie zawierała
 194                 mapowanie nazwy aliasu na nazwę tabeli. W pozostałych częściach zapytania
 195                 <acronym>SQL</acronym> będzie można używać tej nazwy zamiast tabeli. Jeśli
 196                 dane zapytanie łączy wiele tabel
 197                 <classname>Zend_Db_Select</classname> utworzy unikalne aliasy na
 198                 podstawie prawdziwych nazw dla każdej tabeli dla której nie zrobi tego użytkownik.
 199             </para>
 200
 201             <example id="zend.db.select.building.from.example-cname">
 202
 203                 <title>Przykład użycia aliasu</title>
 204
 205                 <programlisting language="php"><![CDATA[
 206 // Utworzenie zapytania:
 207 //   SELECT p.*
 208 //   FROM "products" AS p
 209
 210 $select = $db->select()
 211              ->from( array('p' => 'products') );
 212 ]]></programlisting>
 213
 214             </example>
 215
 216             <para>
 217                 Niektóre silniki bazy danych (<acronym>RDBMS</acronym>) wspierają podawanie
 218                 nazw schematu przed nazwą tabeli. W takim przypadku należy podać nazwę tabeli jako
 219                 "<command>nazwaSchematu.nazwaTabeli</command>" a
 220                 <classname>Zend_Db_Select</classname>
 221                 umieści w cudzysłowach każdą z części takiej nazwy indywidualnie. Można też podać
 222                 nazwę schematu oddzielnie. Nazwa schematu podana przy nazwie tabeli ma pierwszeństwo
 223                 wobec nazwy schematu podanej osobno (jeśli obie występują).
 224             </para>
 225
 226             <example id="zend.db.select.building.from.example-schema">
 227
 228                 <title>Przykład podawania nazwy schematu</title>
 229
 230                 <programlisting language="php"><![CDATA[
 231 // Utworzenie zapytania:
 232 //   SELECT *
 233 //   FROM "myschema"."products"
 234
 235 $select = $db->select()
 236              ->from( 'myschema.products' );
 237
 238 // lub
 239
 240 $select = $db->select()
 241              ->from('products', '*', 'myschema');
 242 ]]></programlisting>
 243
 244             </example>
 245
 246         </sect3>
 247
 248         <sect3 id="zend.db.select.building.columns">
 249
 250             <title>Dodawanie kolumn</title>
 251
 252             <para>
 253                 Drugi argument metody <methodname>from()</methodname> może zawierać kolumny, które
 254                 mają zostać pobrane z odpowiedniej tabeli. Jeśli nie poda się tego
 255                 argumentu domyślną wartością jest "<emphasis>*</emphasis>" czyli znak
 256                 specjalny <acronym>SQL</acronym> odpowiadający wszystkim kolumnom.
 257             </para>
 258
 259             <para>
 260                 Kolumny można podawać w prostej tablicy łańcuchów tekstowych lub jako asocjacyjnej
 261                 tablicy aliasów kolumn do nazw kolumn. Jeśli potrzebna jest tylko jedna kolumna to
 262                 można ją podać w prostym stringu - nie trzeba używać tablicy.
 263             </para>
 264
 265             <para>
 266                 Jeśli w tym argumencie zostanie podana pusta tablica to żadna kolumna z odpowiedniej
 267                 tabeli nie zostanie dołączona do wyniku zapytania. Zobacz
 268                 <link linkend="zend.db.select.building.join.example-no-columns">przykład kodu</link>
 269                 znajdujący się pod rozdziałem dotyczącym metody <methodname>join()</methodname>.
 270             </para>
 271
 272             <para>
 273                 Nazwę kolumny można podać w formie "<command>nazwaAliasu.nazwaKolumny</command>".
 274                 <classname>Zend_Db_Select</classname> umieści każdą z części nazwy oddzielnie
 275                 w cudzysłowach, używając aliasu wcześniej ustalonego w metodzie
 276                 <methodname>from()</methodname> (jeśli nie został podany bezpośrednio).
 277             </para>
 278
 279             <example id="zend.db.select.building.columns.example">
 280
 281                 <title>Przykład dodawania kolumn</title>
 282
 283                 <programlisting language="php"><![CDATA[
 284 // Tworzenie zapytania:
 285 //   SELECT p."product_id", p."product_name"
 286 //   FROM "products" AS p
 287
 288 $select = $db->select()
 289              ->from(array('p' => 'products'),
 290                     array('product_id', 'product_name'));
 291
 292 // Tworzenie podobnego zapytania z użyciem aliasów tabeli:
 293 //   SELECT p."product_id", p."product_name"
 294 //   FROM "products" AS p
 295
 296 $select = $db->select()
 297              ->from(array('p' => 'products'),
 298                     array('p.product_id', 'p.product_name'));
 299
 300 // Tworzenie podobnego zapytania z aliasem dla jednej kolumny:
 301 //   SELECT p."product_id" AS prodno, p."product_name"
 302 //   FROM "products" AS p
 303
 304 $select = $db->select()
 305              ->from(array('p' => 'products'),
 306                     array('prodno' => 'product_id', 'product_name'));
 307 ]]></programlisting>
 308
 309             </example>
 310
 311         </sect3>
 312
 313         <sect3 id="zend.db.select.building.columns-expr">
 314
 315             <title>Dodawanie kolumn z wyrażeniami</title>
 316
 317             <para>
 318                 W zapytaniach <acronym>SQL</acronym> często zachodzi potrzeba użycia wyrażeń
 319                 zamiast zwykłych kolumn tabeli. Wyrażenia nie powinny być otoczone cudzysłowami
 320                 ani zawierać aliasów tabel. Jeśli podana kolumna zawiera nawiasy
 321                 <classname>Zend_Db_Select</classname> rozpoznaje ją jako wyrażenie.
 322             </para>
 323
 324             <para>
 325                 Można również samemu utworzyć obiekt klasy <classname>Zend_Db_Expr</classname>
 326                 aby łańcuch znaków nie został potraktowany jak zwykła nazwa kolumny.
 327                 <classname>Zend_Db_Expr</classname> jest małą klasą zawierającą jeden string.
 328                 <classname>Zend_Db_Select</classname> rozpoznaje instancje klasy
 329                 <classname>Zend_Db_Expr</classname> i zamienia je na łańcuchy znaków ale nie
 330                 wprowadza zmian takich jak cudzysłowy czy aliasy tabel.
 331             </para>
 332
 333             <note>
 334
 335                 <para>
 336                     Używanie <classname>Zend_Db_Expr</classname> dla wyrażeń nie jest obowiązkowe
 337                     jeśli zawiera ono nawiasy. <classname>Zend_Db_Select</classname> rozpoznaje
 338                     nawiasy i traktuje dany łańcuch jak wyrażenie (nie umieszcza w cudzysłowach
 339                     ani nie dodanie nazw alias tabel).
 340                 </para>
 341
 342             </note>
 343
 344             <example id="zend.db.select.building.columns-expr.example">
 345
 346                 <title>Przykłady podawania kolumn zawierających wyrażenia</title>
 347
 348                 <programlisting language="php"><![CDATA[
 349 // Tworzenie zapytania:
 350 //   SELECT p."product_id", LOWER(product_name)
 351 //   FROM "products" AS p
 352 // Wyrażenie z nawiasami staje się obiektem klasy Zend_Db_Expr.
 353
 354 $select = $db->select()
 355              ->from(array('p' => 'products'),
 356                     array('product_id', 'LOWER(product_name)'));
 357
 358 // Tworzenie zapytania:
 359 //   SELECT p."product_id", (p.cost * 1.08) AS cost_plus_tax
 360 //   FROM "products" AS p
 361
 362 $select = $db->select()
 363              ->from(array('p' => 'products'),
 364                     array('product_id',
 365                           'cost_plus_tax' => '(p.cost * 1.08)')
 366                    );
 367
 368 // Tworzenie zapytania używając Zend_Db_Expr:
 369 //   SELECT p."product_id", p.cost * 1.08 AS cost_plus_tax
 370 //   FROM "products" AS p
 371
 372 $select = $db->select()
 373              ->from(array('p' => 'products'),
 374                     array('product_id',
 375                           'cost_plus_tax' =>
 376                               new Zend_Db_Expr('p.cost * 1.08'))
 377                     );
 378 ]]></programlisting>
 379
 380             </example>
 381
 382             <para>
 383                 W powyższych przykładach <classname>Zend_Db_Select</classname> nie zmienia stringa
 384                 i nie dodaje aliasów tabel ani nie używa cudzysłowów. Jeśli takie zmiany
 385                 są niezbędne (np. z powodu dwuznaczności nazw) należy je wprowadzić ręcznie.
 386             </para>
 387
 388             <para>
 389                 Jeśli podane nazwy kolumn zawierają słowa kluczowe <acronym>SQL</acronym> lub
 390                 znaki specjalne należy użyć metody adaptera połączenia o nazwie
 391                 <methodname>quoteIdentifier()</methodname> i rezultat umieścić w stringu. Metoda
 392                 <methodname>quoteIdentifier()</methodname> używa cudzysłowów dzięki czemu można być
 393                 pewnym, że podany łańcuch znaków jest identyfikatorem tabeli lub kolumny
 394                 a nie częścią składni polecenia <acronym>SQL</acronym>.
 395             </para>
 396
 397             <para>
 398                 Dzięki użyciu metody <methodname>quoteIdentifier()</methodname> zamiast ręcznego
 399                 wpisywania cudzysłowów kod staje się niezależny od rodzaju bazy danych. Niektóre
 400                 systemy zarządzania bazą danych (<acronym>RDBMS</acronym>) używają niestandardowych
 401                 znaków do ograniczania identyfikatorów. Metoda
 402                 <methodname>quoteIdentifier()</methodname> jest przystosowana do
 403                 używania odpowiednich symboli ograniczających w zależności od typu
 404                 używanego adaptera. Metoda <methodname>quoteIdentifier()</methodname> dokonuje
 405                 również unikania znaków cudzysłowu, które pojawią się w argumencie wejściowym.
 406             </para>
 407
 408             <example id="zend.db.select.building.columns-quoteid.example">
 409
 410                 <title>Przykłady umieszczania wyrażeń w cudzysłowach</title>
 411
 412                 <programlisting language="php"><![CDATA[
 413 // Tworzenie zapytania,
 414 // umieszczając kolumnę o nazwie "from" w cudzysłowach:
 415 //   SELECT p."from" + 10 AS origin
 416 //   FROM "products" AS p
 417
 418 $select = $db->select()
 419              ->from(array('p' => 'products'),
 420                     array('origin' =>
 421                               '(p.' . $db->quoteIdentifier('from') . ' + 10)')
 422                    );
 423 ]]></programlisting>
 424
 425             </example>
 426
 427         </sect3>
 428
 429         <sect3 id="zend.db.select.building.columns-atomic">
 430
 431             <title>Dodawanie kolumn do wcześniej utworzonej klauzuli FROM lub JOIN</title>
 432
 433             <para>
 434                 Może powstać sytuacja w której niezbędne okazuje się dodanie kolumn do klauzuli
 435                 <acronym>FROM</acronym> lub <acronym>JOIN</acronym>,
 436                 która została utworzona wcześniej (za pomocą odpowiedniej metody).
 437                 Metoda <methodname>columns()</methodname> pozwala na dodanie kolumn w dowolnym
 438                 momencie przed wykonaniem zapytania. Kolumny można podać jako łańcuchy znaków,
 439                 obiekty <classname>Zend_Db_Expr</classname> lub jako tablice tych elementów. Drugi
 440                 argument tej metody może zostać pominięty co oznacza, że kolumny powinny zostać
 441                 dodane do tabeli z klauzuli <acronym>FROM</acronym>.
 442                 W przeciwnym razie należy podać alias lub nazwę tabeli.
 443             </para>
 444
 445             <example id="zend.db.select.building.columns-atomic.example">
 446
 447                 <title>Przykłady dodawania kolumn metodą columns()</title>
 448
 449                 <programlisting language="php"><![CDATA[
 450 // Tworzenie zapytania:
 451 //   SELECT p."product_id", p."product_name"
 452 //   FROM "products" AS p
 453
 454 $select = $db->select()
 455              ->from(array('p' => 'products'), 'product_id')
 456              ->columns('product_name');
 457
 458 // Tworzenie zapytania używając nazwy alias:
 459 //   SELECT p."product_id", p."product_name"
 460 //   FROM "products" AS p
 461
 462 $select = $db->select()
 463              ->from(array('p' => 'products'), 'p.product_id')
 464              ->columns('product_name', 'p');
 465              // Alternatywnie można użyć columns('p.product_name')
 466 ]]></programlisting>
 467
 468             </example>
 469
 470         </sect3>
 471
 472         <sect3 id="zend.db.select.building.join">
 473
 474             <title>Dodawanie tabeli do zapytania za pomocą JOIN</title>
 475
 476             <para>
 477                 Wiele użytecznych zapytań zawiera klauzulę <acronym>JOIN</acronym> służącą do
 478                 łączenia wierszy z wielu tabel. Aby dodać tabele do obiektu
 479                 <classname>Zend_Db_Select</classname> należy użyć metody
 480                 <methodname>join()</methodname>. Używanie jej jest podobne do użycia metody
 481                 <methodname>from()</methodname> z tym, że tu można również użyć warunek łączenia
 482                 tabel.
 483             </para>
 484
 485             <example id="zend.db.select.building.join.example">
 486
 487                 <title>Przykład użycia metody join()</title>
 488
 489                 <programlisting language="php"><![CDATA[
 490 // Tworzenie zapytania:
 491 //   SELECT p."product_id", p."product_name", l.*
 492 //   FROM "products" AS p JOIN "line_items" AS l
 493 //     ON p.product_id = l.product_id
 494
 495 $select = $db->select()
 496              ->from(array('p' => 'products'),
 497                     array('product_id', 'product_name'))
 498              ->join(array('l' => 'line_items'),
 499                     'p.product_id = l.product_id');
 500 ]]></programlisting>
 501
 502             </example>
 503
 504             <para>
 505                 Drugi argument metody <methodname>join()</methodname> to string stanowiący warunek
 506                 połączenia. Jest to wyrażenie określające kryteria wg. których wiersze z
 507                 jednej tabeli łączą się z wierszami drugiej tabeli. W tym miejscu
 508                 można użyć aliasów tabel.
 509             </para>
 510
 511             <note>
 512
 513                 <para>
 514                     Do warunku połączenia nie są stosowane cudzysłowy; Jeśli występuje konieczność
 515                     umieszczenia nazwy kolumny w cudzysłowach, należy użyć metody adaptera
 516                     <methodname>quoteIdentifier()</methodname> przy formowaniu wyrażenia warunku
 517                     połączenia.
 518                 </para>
 519
 520             </note>
 521
 522             <para>
 523                 Trzeci argument metody <methodname>join()</methodname> to tablica nazw kolumn (tak
 524                 jak przy metodzie <methodname>from()</methodname>). Domyślną wartością jest
 525                 "<emphasis>*</emphasis>". Można w nim podawać aliasy kolumn, wyrażenia lub obiekty
 526                 <classname>Zend_Db_Expr</classname> w taki sam sposób jak w metodzie
 527                 <methodname>from()</methodname>.
 528             </para>
 529
 530             <para>
 531                 Aby nie wybierać żadnej kolumny należy podać pustą tablicę zamiast nazw kolumn.
 532                 Ten sposób działa również w metodzie <methodname>from()</methodname> ale z
 533                 podstawowych tabel przeważnie kolumny są potrzebne, co nie zawsze jest prawdą
 534                 dla kolumn tabeli połączonej.
 535             </para>
 536
 537             <example id="zend.db.select.building.join.example-no-columns">
 538
 539                 <title>Przykład nie podawania kolumn</title>
 540
 541                 <programlisting language="php"><![CDATA[
 542 // Tworzenie zapytania:
 543 //   SELECT p."product_id", p."product_name"
 544 //   FROM "products" AS p JOIN "line_items" AS l
 545 //     ON p.product_id = l.product_id
 546
 547 $select = $db->select()
 548              ->from(array('p' => 'products'),
 549                     array('product_id', 'product_name'))
 550              ->join(array('l' => 'line_items'),
 551                     'p.product_id = l.product_id',
 552                     array() ); // pusta lista kolumn
 553 ]]></programlisting>
 554
 555                 <para>
 556                     W miejscu listy kolumn tabeli połączonej występuje pusta tablica
 557                     (<methodname>array()</methodname>).
 558                 </para>
 559
 560             </example>
 561
 562             <para>
 563                 <acronym>SQL</acronym> dysponuje wieloma rodzajami klauzul JOIN. Poniżej znajduje
 564                 się lista metod klasy <classname>Zend_Db_Select</classname> obsługująca je.
 565             </para>
 566
 567             <itemizedlist>
 568                 <listitem>
 569                     <para>
 570                         <command>INNER JOIN</command> za pomocą
 571                         <methodname>join(tabela, warunek, [kolumny])</methodname>
 572                         lub <methodname>joinInner(tabela, warunek, [kolumny])</methodname>
 573                     </para>
 574
 575                     <para>
 576                         To jest najbardziej popularny rodzaj połączenia JOIN. Wiersze z
 577                         każdej tabeli są porównywane za pomocą podanego warunku. Zbiór
 578                         wyjściowy zawiera jedynie
 579                         wiersze, które spełniają warunek połączenia. Jeśli żadna para wierszy nie
 580                         spełnia warunku to zbiór pozostanie pusty.
 581                     </para>
 582
 583                     <para>
 584                         Wszystkie systemy zarządzania bazą danych (<acronym>RDBMS</acronym>)
 585                         posiadają implementację tego rodzaju polecenia JOIN.
 586                     </para>
 587                 </listitem>
 588
 589                 <listitem>
 590                     <para>
 591                         <command>LEFT JOIN</command> za pomocą metody
 592                         <methodname>joinLeft(tabela, warunek, [kolumny])</methodname>.
 593                     </para>
 594
 595                     <para>
 596                         Wszystkie wiersze z tabeli znajdującej się po lewej stronie "wchodzą"
 597                         do wyniku. Te, które nie mają odpowiadającego wiersza w tabeli znajdującej
 598                         się po stronie prawej - zostają wypełnione wartościami
 599                         <constant>NULL</constant> (w kolumnach z prawej tabeli).
 600                     </para>
 601
 602                     <para>
 603                         Wszystkie systemy zarządzania bazą danych (<acronym>RDBMS</acronym>)
 604                         posiadają implementację tego rodzaju polecenia JOIN.
 605                     </para>
 606                 </listitem>
 607
 608                 <listitem>
 609                     <para>
 610                         <command>RIGHT JOIN</command> za pomocą metody
 611                         <methodname>joinRight(tabela, warunek, [kolumny])</methodname>
 612                     </para>
 613
 614                     <para>
 615                         RIGHT JOIN to przeciwieństwo LEFT JOIN. Wszystkie wiersze z
 616                         tabeli znajdującej się po prawej stronie są umieszczone w wyniku.
 617                         Te, które nie posiadają
 618                         odpowiednika w tabeli lewej otrzymują wartości <constant>NULL</constant>
 619                         w kolumnach z lewej tabeli.
 620                     </para>
 621
 622                     <para>
 623                         Niektóre systemy zarządzania bazą danych (<acronym>RDBMS</acronym>) nie
 624                         wspierają tego typu polecenia JOIN ale generalnie każdy
 625                         <command>RIGHT JOIN</command> może zostać zaprezentowany jako
 626                         <command>LEFT JOIN</command> poprzez odwrócenie kolejności dodawania tabel.
 627                     </para>
 628                 </listitem>
 629
 630                 <listitem>
 631                     <para>
 632                         <command>FULL JOIN</command> za pomocą metody
 633                         <methodname>joinFull(tabela, warunek, [kolumny])</methodname>
 634                     </para>
 635
 636                     <para>
 637                         To polecenie jest jak połączenie <command>LEFT JOIN</command> oraz
 638                         <command>RIGHT JOIN</command>. Wszystkie wiersze z obu tabel są włączane
 639                         do wyniku. Jeśli dany wiersz nie posiada odpowiednika spełniającego warunek
 640                         połączenia w drugiej tabeli to w kolumnach z tej tabeli umieszczony jest
 641                         <constant>NULL</constant>.
 642                     </para>
 643
 644                     <para>
 645                         Niektóre systemy zarządzania bazą danych (<acronym>RDBMS</acronym>) nie
 646                         wspierają tego typu polecenia JOIN.
 647                     </para>
 648                 </listitem>
 649
 650                 <listitem>
 651                     <para>
 652                         <command>CROSS JOIN</command> za pomocą metody
 653                         <methodname>joinCross(tabela, [kolumny])</methodname>.
 654                     </para>
 655
 656                     <para>
 657                         Cross join to iloczyn kartezjański tabel. Każdy wiersz z pierwszej tabeli
 658                         zostaje połączony z każdym wierszem z tabeli drugiej. Ilość wierszy
 659                         w zbiorze wynikowym jest równa iloczynowi ilości wierszy w obu tabelach.
 660                         Poprzez użycie warunku <acronym>WHERE</acronym> można ograniczyć
 661                         wiersze wynikowe przez co cross join może być podobny
 662                         do składni polecenia join
 663                         ze standardu <acronym>SQL</acronym>-89.
 664                     </para>
 665
 666                     <para>
 667                         Metoda <methodname>joinCross()</methodname> nie ma parametru odnoszącego się
 668                         do warunku połączenia. Niektóre systemy zarządzania bazą danych
 669                         (<acronym>RDBMS</acronym>) nie wspierają tego typu
 670                         polecenia <acronym>JOIN</acronym>.
 671                     </para>
 672                 </listitem>
 673
 674                 <listitem>
 675                     <para>
 676                         <command>NATURAL JOIN</command> za pomocą metody
 677                         <methodname>joinNatural(tabela, [kolumny])</methodname>.
 678                     </para>
 679
 680                     <para>
 681                         Polecenie natural join łączy wiersze pod względem wszystkich kolumn, które
 682                         mają taką samą nazwę w obydwu tabelach. Warunkiem połączenia jest zgodność
 683                         wartości wszystkich tak samo nazwanych kolumn tabel. Porównywanie wartości
 684                         na zasadzie niezgodności (różnicy) nie stanowi polecenia natural join.
 685                         Jedynie polecenia typu natural inner join są zaimplementowane w tym API
 686                         pomimo tego że standard <acronym>SQL</acronym> definiuje też polecenia
 687                         natural outer join.
 688                     </para>
 689
 690                     <para>
 691                         Metoda <methodname>joinCross()</methodname> nie ma parametru odnoszącego się
 692                         do warunku połączenia.
 693                     </para>
 694                 </listitem>
 695             </itemizedlist>
 696
 697             <para>
 698                 Oprócz powyższych metod można uprościć zapytania używając metod JoinUsing. Zamiast
 699                 podawania pełnego warunku można wybrać nazwę kolumny, na podstawie której
 700                 połączenie będzie przeprowadzone a obiekt <classname>Zend_Db_Select</classname>
 701                 dopisze niezbędną część polecenia warunku.
 702             </para>
 703
 704             <example id="zend.db.select.building.joinusing.example">
 705
 706                 <title>Przykład użycia metody joinUsing()</title>
 707
 708                 <programlisting language="php"><![CDATA[
 709 // Tworzenie zapytania:
 710 //   SELECT *
 711 //   FROM "table1"
 712 //   JOIN "table2"
 713 //   ON "table1".column1 = "table2".column1
 714 //   WHERE column2 = 'foo'
 715
 716 $select = $db->select()
 717              ->from('table1')
 718              ->joinUsing('table2', 'column1')
 719              ->where('column2 = ?', 'foo');
 720 ]]></programlisting>
 721
 722             </example>
 723
 724             <para>
 725                 Każda z metod połączenia klasy <classname>Zend_Db_Select</classname> ma
 726                 odpowiednią metodę 'using'.
 727             </para>
 728
 729             <itemizedlist>
 730                 <listitem>
 731                     <para>
 732                         <methodname>joinUsing(tabela, [kolumny])</methodname> and
 733                         <methodname>joinInnerUsing(tabela, [kolumny])</methodname>
 734                     </para>
 735                 </listitem>
 736
 737                 <listitem>
 738                     <para>
 739                         <methodname>joinLeftUsing(tabela, [kolumny])</methodname>
 740                     </para>
 741                 </listitem>
 742
 743                 <listitem>
 744                     <para>
 745                         <methodname>joinRightUsing(tabela, [kolumny])</methodname>
 746                     </para>
 747                 </listitem>
 748
 749                 <listitem>
 750                     <para>
 751                         <methodname>joinFullUsing(tabela, [kolumny])</methodname>
 752                     </para>
 753                 </listitem>
 754             </itemizedlist>
 755
 756         </sect3>
 757
 758         <sect3 id="zend.db.select.building.where">
 759
 760             <title>Dodawanie klauzuli WHERE</title>
 761
 762             <para>
 763                 Za pomocą metody <methodname>where()</methodname> można określić kryteria
 764                 ograniczające ilość wierszy zwracanych przez zapytanie. Pierwszy argument tej
 765                 metody to wyrażenie <acronym>SQL</acronym> które zostanie użyte w klauzuli
 766                 WHERE zapytania <acronym>SQL</acronym>.
 767             </para>
 768
 769             <example id="zend.db.select.building.where.example">
 770
 771                 <title>Przykład użycia metody where()</title>
 772
 773                 <programlisting language="php"><![CDATA[
 774 // Tworzenie zapytania:
 775 //   SELECT product_id, product_name, price
 776 //   FROM "products"
 777 //   WHERE price > 100.00
 778
 779 $select = $db->select()
 780              ->from('products',
 781                     array('product_id', 'product_name', 'price'))
 782              ->where('price > 100.00');
 783 ]]></programlisting>
 784
 785             </example>
 786
 787             <note>
 788
 789                 <para>
 790                     Wyrażenia w metodach <methodname>where()</methodname> lub
 791                     <methodname>orWhere()</methodname> nie zostają umieszczone w cudzysłowach.
 792                     Jeśli nazwa kolumny tego wymaga należy użyć metody
 793                     <methodname>quoteIdentifier()</methodname> podczas tworzenia parametru warunku.
 794                 </para>
 795
 796             </note>
 797
 798             <para>
 799                 Drugi argument metody <methodname>where()</methodname> jest opcjonalny. Stanowi on
 800                 wartość umieszczaną w warunku. <classname>Zend_Db_Select</classname> ogranicza tą
 801                 wartość cudzysłowami i za jej pomocą podmienia symbol znaku zapytania
 802                 ("<emphasis>?</emphasis>") w warunku.
 803             </para>
 804
 805             <example id="zend.db.select.building.where.example-param">
 806
 807                 <title>Przykład użycia parametru w metodzie where()</title>
 808
 809                 <programlisting language="php"><![CDATA[
 810 // Tworzenie zapytania:
 811 //   SELECT product_id, product_name, price
 812 //   FROM "products"
 813 //   WHERE (price > 100.00)
 814
 815 $minimumPrice = 100;
 816
 817 $select = $db->select()
 818              ->from('products',
 819                     array('product_id', 'product_name', 'price'))
 820              ->where('price > ?', $minimumPrice);
 821 ]]></programlisting>
 822
 823             </example>
 824
 825             <para>
 826                 Drugi parametr metody <methodname>where()</methodname> przyjmuje również
 827                 tablicę w przypadku gdy używa się operatora IN.
 828             </para>
 829
 830             <example id="zend.db.select.building.where.example-array">
 831
 832                 <title>Przykład użycia tablicy w metodzie where()</title>
 833
 834                 <programlisting language="php"><![CDATA[
 835 // Tworzenie zapytania:
 836 //   SELECT product_id, product_name, price
 837 //   FROM "products"
 838 //   WHERE (product_id IN (1, 2, 3))
 839
 840 $productIds = array(1, 2, 3);
 841
 842 $select = $db->select()
 843              ->from('products',
 844                     array('product_id', 'product_name', 'price'))
 845              ->where('product_id IN (?)', $productIds);
 846 ]]></programlisting>
 847
 848             </example>
 849
 850             <para>
 851                 Metoda <methodname>where()</methodname> może być wywoływana wiele razy dla jednego
 852                 obiektu <classname>Zend_Db_Select</classname>. Zapytanie wynikowe łączy wszystkie
 853                 warunki używając wyrażenia <acronym>AND</acronym>.
 854             </para>
 855
 856             <example id="zend.db.select.building.where.example-and">
 857
 858                 <title>Przykład wywołania metody where() wiele razy</title>
 859
 860                 <programlisting language="php"><![CDATA[
 861 // Tworzenie zapytania:
 862 //   SELECT product_id, product_name, price
 863 //   FROM "products"
 864 //   WHERE (price > 100.00)
 865 //     AND (price < 500.00)
 866
 867 $minimumPrice = 100;
 868 $maximumPrice = 500;
 869
 870 $select = $db->select()
 871              ->from('products',
 872                     array('product_id', 'product_name', 'price'))
 873              ->where('price > ?', $minimumPrice)
 874              ->where('price < ?', $maximumPrice);
 875 ]]></programlisting>
 876
 877             </example>
 878
 879             <para>
 880                 Jeśli istnieje potrzeba połączenia warunków za pomocą wyrażenia
 881                 <acronym>OR</acronym> należy użyć metody <methodname>orWhere()</methodname>.
 882                 Można jej używać w taki sam sposób jak metody <methodname>where()</methodname>.
 883                 W wynikowym poleceniu warunki zostaną połączone wyrażeniem <acronym>OR</acronym>
 884                 zamiast <acronym>AND</acronym>.
 885             </para>
 886
 887             <example id="zend.db.select.building.where.example-or">
 888
 889                 <title>Przykład użycia metody orWhere()</title>
 890
 891                 <programlisting language="php"><![CDATA[
 892 // Tworzenie zapytania:
 893 //   SELECT product_id, product_name, price
 894 //   FROM "products"
 895 //   WHERE (price < 100.00)
 896 //     OR (price > 500.00)
 897
 898 $minimumPrice = 100;
 899 $maximumPrice = 500;
 900
 901 $select = $db->select()
 902              ->from('products',
 903                     array('product_id', 'product_name', 'price'))
 904              ->where('price < ?', $minimumPrice)
 905              ->orWhere('price > ?', $maximumPrice);
 906 ]]></programlisting>
 907
 908             </example>
 909
 910             <para>
 911                 <classname>Zend_Db_Select</classname> automatycznie umieszcza wyrażenia podane
 912                 do metod <methodname>where()</methodname> lub <methodname>orWhere()</methodname>
 913                 w nawiasach. Dzięki temu kolejność wykonywania działań logicznych nie spowoduje
 914                 nieoczekiwanych rezultatów.
 915             </para>
 916
 917             <example id="zend.db.select.building.where.example-parens">
 918
 919                 <title>Przykład umieszczania wyrażeń w nawiasach</title>
 920
 921                 <programlisting language="php"><![CDATA[
 922 // Tworzenie zapytania:
 923 //   SELECT product_id, product_name, price
 924 //   FROM "products"
 925 //   WHERE (price < 100.00 OR price > 500.00)
 926 //     AND (product_name = 'Apple')
 927
 928 $minimumPrice = 100;
 929 $maximumPrice = 500;
 930 $prod = 'Apple';
 931
 932 $select = $db->select()
 933              ->from('products',
 934                     array('product_id', 'product_name', 'price'))
 935              ->where("price < $minimumPrice OR price > $maximumPrice")
 936              ->where('product_name = ?', $prod);
 937 ]]></programlisting>
 938
 939             </example>
 940
 941             <para>
 942                 W powyższym przykładzie zapytanie bez nawiasów przyniosłoby inny rezultat ponieważ
 943                 <acronym>AND</acronym> ma wyższy priorytet niż <acronym>OR</acronym>.
 944                 Dzięki nawiasom <classname>Zend_Db_Select</classname> sprawia, że każde
 945                 wywołanie metody <methodname>where()</methodname> łączy zawarte w niej warunki
 946                 z wyższym priorytetem niż <acronym>AND</acronym> który łączy poszczególne warunki.
 947             </para>
 948
 949         </sect3>
 950
 951         <sect3 id="zend.db.select.building.group">
 952
 953             <title>Dodanie klauzuli GROUP BY</title>
 954
 955             <para>
 956                 W <acronym>SQL</acronym>, klauzula <command>GROUP BY</command> pozwala na
 957                 ograniczenie wierszy wyników zapytania do jednego wiersza na każdą unikalną wartość
 958                 znalezioną w kolumnie podanej przy klauzuli <command>GROUP BY</command>.
 959             </para>
 960
 961             <para>
 962                 Aby określić kolumny używane do podzielenia wyników na grupy w
 963                 <classname>Zend_Db_Select</classname> należy użyć metody
 964                 <methodname>group()</methodname>.
 965                 Jako argument podaje się kolumnę lub tablicę kolumn, które mają trafić
 966                 do klauzuli <command>GROUP BY</command>.
 967             </para>
 968
 969             <example id="zend.db.select.building.group.example">
 970
 971                 <title>Przykład użycia metody group()</title>
 972
 973                 <programlisting language="php"><![CDATA[
 974 // Tworzenie zapytania:
 975 //   SELECT p."product_id", COUNT(*) AS line_items_per_product
 976 //   FROM "products" AS p JOIN "line_items" AS l
 977 //     ON p.product_id = l.product_id
 978 //   GROUP BY p.product_id
 979
 980 $select = $db->select()
 981              ->from(array('p' => 'products'),
 982                     array('product_id'))
 983              ->join(array('l' => 'line_items'),
 984                     'p.product_id = l.product_id',
 985                     array('line_items_per_product' => 'COUNT(*)'))
 986              ->group('p.product_id');
 987 ]]></programlisting>
 988
 989             </example>
 990
 991             <para>
 992                 Podobnie jak w przypadku metody <methodname>from()</methodname> w argumencie można
 993                 używać aliasów tabel a nazwy są umieszczane w cudzysłowach jako identyfikatory
 994                 chyba że łańcuch znaków zawiera nawiasy lub jest
 995                 obiektem <classname>Zend_Db_Expr</classname>.
 996             </para>
 997
 998         </sect3>
 999
1000         <sect3 id="zend.db.select.building.having">
1001
1002             <title>Dodanie klauzuli HAVING</title>
1003
1004             <para>
1005                 W <acronym>SQL</acronym>, klauzula <constant>HAVING</constant> wprowadza
1006                 ograniczenie w stosunku do grup wierszy. Jest to podobne do sposobu w jaki klauzula
1007                 <constant>WHERE</constant> ogranicza wiersze ogólnie. Te klauzule są różne ponieważ
1008                 warunki <constant>WHERE</constant> są oceniane prze definiowaniem grup, podczas gdy
1009                 warunki <constant>HAVING</constant> nakładane są po uformowaniu grup.
1010             </para>
1011
1012             <para>
1013                 W <classname>Zend_Db_Select</classname> można określić warunki dotyczące
1014                 grup wierszy za pomocą metody <methodname>having()</methodname>.
1015                 Użycie jej jest podobne do metody <methodname>where()</methodname>. Pierwszy
1016                 argument to string zawierający wyrażenie <acronym>SQL</acronym>. Opcjonalny
1017                 drugi argument to wartość używana do zamienienia pozycyjnych parametrów w
1018                 wyrażeniu <acronym>SQL</acronym>. Wyrażenia umieszczone w wielu wywołaniach
1019                 metody <methodname>having()</methodname> są łączone za pomocą operatora
1020                 <acronym>AND</acronym> lub <acronym>OR</acronym> - jeśli zostanie użyta metoda
1021                 <methodname>orHaving()</methodname>.
1022             </para>
1023
1024             <example id="zend.db.select.building.having.example">
1025
1026                 <title>Przykład użycia metody having()</title>
1027
1028                 <programlisting language="php"><![CDATA[
1029 // Tworzenie zapytania:
1030 //   SELECT p."product_id", COUNT(*) AS line_items_per_product
1031 //   FROM "products" AS p JOIN "line_items" AS l
1032 //     ON p.product_id = l.product_id
1033 //   GROUP BY p.product_id
1034 //   HAVING line_items_per_product > 10
1035
1036 $select = $db->select()
1037              ->from(array('p' => 'products'),
1038                     array('product_id'))
1039              ->join(array('l' => 'line_items'),
1040                     'p.product_id = l.product_id',
1041                     array('line_items_per_product' => 'COUNT(*)'))
1042              ->group('p.product_id')
1043              ->having('line_items_per_product > 10');
1044 ]]></programlisting>
1045
1046             </example>
1047
1048             <note>
1049
1050                 <para>
1051                     W metodach <methodname>having()</methodname> oraz
1052                     <methodname>orHaving()</methodname> nie jest stosowane umieszczanie
1053                     identyfikatorów w cudzysłowach. Jeśli nazwa kolumny tego wymaga należy użyć
1054                     metody <methodname>quoteIdentifier()</methodname> podczas tworzenia parametru
1055                     warunku.
1056                 </para>
1057
1058             </note>
1059
1060         </sect3>
1061
1062         <sect3 id="zend.db.select.building.order">
1063
1064             <title>Dodanie klauzuli ORDER BY</title>
1065
1066             <para>
1067                 W <acronym>SQL</acronym>, klauzula <acronym>ORDER BY</acronym>
1068                 określa jedną bądź więcej
1069                 kolumn lub wyrażeń według których zbiór wynikowy jest posortowany. Jeśli poda się
1070                 wiele kolumn to sortowanie odbywa się w pierwszej kolejności na podstawie wcześniej
1071                 podanej kolumny. Jeśli istnieją wiersze o takiej samej wartości w danej kolumnie
1072                 to do sortowania używana jest kolejna klumna klauzuli <code>ORDER BY</code>.
1073                 Domyślny kierunek sortowania to od najmniejszej wartości do największej.
1074                 Można sortować w przeciwnym kierunku przez użycie słowa kluczowego
1075                 <constant>DESC</constant> po nazwie kolumny sortowania.
1076             </para>
1077
1078             <para>
1079                 W <classname>Zend_Db_Select</classname> można użyć metody
1080                 <methodname>order()</methodname> i podać kolumnę lub tablicę kolumn
1081                 według których sortowanie ma przebiegać. Każdy z elementów tablicy
1082                 powinien być łańcuchem znaków określającym kolumnę. Opcjonalnie można dodać
1083                 słowa kluczowe <constant>ASC</constant> lub <constant>DESC</constant>
1084                 oddzielone od kolumny spacją.
1085             </para>
1086
1087             <para>
1088                 Podobnie jak przy metodach <methodname>from()</methodname> oraz
1089                 <methodname>group()</methodname> nazwy kolumn są otaczane cudzysłowami, chyba że
1090                 zawierają nawiasy lub są obiektami klasy <classname>Zend_Db_Expr</classname>.
1091             </para>
1092
1093             <example id="zend.db.select.building.order.example">
1094
1095                 <title>Przykład użycia metody order()</title>
1096
1097                 <programlisting language="php"><![CDATA[
1098 // Tworzenie zapytania:
1099 //   SELECT p."product_id", COUNT(*) AS line_items_per_product
1100 //   FROM "products" AS p JOIN "line_items" AS l
1101 //     ON p.product_id = l.product_id
1102 //   GROUP BY p.product_id
1103 //   ORDER BY "line_items_per_product" DESC, "product_id"
1104
1105 $select = $db->select()
1106              ->from(array('p' => 'products'),
1107                     array('product_id'))
1108              ->join(array('l' => 'line_items'),
1109                     'p.product_id = l.product_id',
1110                     array('line_items_per_product' => 'COUNT(*)'))
1111              ->group('p.product_id')
1112              ->order(array('line_items_per_product DESC',
1113                            'product_id'));
1114 ]]></programlisting>
1115
1116             </example>
1117
1118         </sect3>
1119
1120         <sect3 id="zend.db.select.building.limit">
1121
1122             <title>Dodanie klauzuli LIMIT</title>
1123
1124             <para>
1125                 Niektóre systemy zarządzania bazą danych (<acronym>RDBMS</acronym>) rozszerzają
1126                 <acronym>SQL</acronym> za pomocą klauzuli <constant>LIMIT</constant>. Za jej
1127                 pomocą można ograniczyć ilość wierszy zwracanych w zapytaniu do podanej ilości.
1128                 Można również określić ilość wierszy, która ma zostać opuszczona przed
1129                 rozpoczęciem zwracania wyników zapytania. Dzięki temu można w łatwy sposób
1130                 uzyskać podzbiór ze zbioru wynikowego. Może to być przydatne
1131                 np. przy wyświetlaniu rezultatów zapytania z podziałem na strony.
1132             </para>
1133
1134             <para>
1135                 W <classname>Zend_Db_Select</classname> można użyć metody
1136                 <methodname>limit()</methodname> aby określić ilość wierszy do zwrócenia oraz do
1137                 opuszczenia. <emphasis>Pierwszy</emphasis> argument metody to ilość wierszy
1138                 jaka maksymalnie ma zostać zwrócona. <emphasis>Drugi</emphasis> argument to ilość
1139                 wierszy do opuszczenia.
1140             </para>
1141
1142             <example id="zend.db.select.building.limit.example">
1143
1144                 <title>Przykład użycia metody limit()</title>
1145
1146                 <programlisting language="php"><![CDATA[
1147 // Tworzenie zapytania:
1148 //   SELECT p."product_id", p."product_name"
1149 //   FROM "products" AS p
1150 //   LIMIT 10, 20
1151 // Equivalent to:
1152 //   SELECT p."product_id", p."product_name"
1153 //   FROM "products" AS p
1154 //   LIMIT 20 OFFSET 10
1155
1156 $select = $db->select()
1157              ->from(array('p' => 'products'),
1158                     array('product_id', 'product_name'))
1159              ->limit(20, 10);
1160 ]]></programlisting>
1161
1162             </example>
1163
1164             <note>
1165
1166                 <para>
1167                     Polecenie <constant>LIMIT</constant> nie jest wspierane przez wszystkie rodzaje
1168                     baz danych. Niektóre z nich wymagają innej składni dla uzyskania
1169                     podobnego efektu. Każda z klas <classname>Zend_Db_Adapter_Abstract</classname>
1170                     zawiera metodę tworzącą polecenie <acronym>SQL</acronym> odpowiednie dla danego
1171                     <acronym>RDBMS</acronym>.
1172                 </para>
1173
1174             </note>
1175
1176             <para>
1177                 Można użyć metody <methodname>limitPage()</methodname> jako alternatywy
1178                 do określania ilości wierszy do zwrotu i do pominięcia. Ta metoda pozwala
1179                 na podzielenie zbioru wynikowego na wiele podzbiorów o stałej wielkości
1180                 i zwrócenie jednego z nich.
1181                 Innymi słowy należy określić długość jednej "strony" z wynikami zapytania
1182                 oraz liczbę porządkową określającą stronę, która ma zostać zwrócona.
1183                 Numer strony stanowi pierwszy argument metody
1184                 <methodname>limitPage()</methodname> a długość strony to drugi argument.
1185                 Obydwa argumenty są wymagane - nie mają wartości domyślnych.
1186             </para>
1187
1188             <example id="zend.db.select.building.limit.example2">
1189
1190                 <title>Przykład użycia metody limitPage()</title>
1191
1192                 <programlisting language="php"><![CDATA[
1193 // Tworzenie zapytania:
1194 //   SELECT p."product_id", p."product_name"
1195 //   FROM "products" AS p
1196 //   LIMIT 10, 20
1197
1198 $select = $db->select()
1199              ->from(array('p' => 'products'),
1200                     array('product_id', 'product_name'))
1201              ->limitPage(2, 10);
1202 ]]></programlisting>
1203
1204             </example>
1205
1206         </sect3>
1207
1208         <sect3 id="zend.db.select.building.distinct">
1209
1210             <title>Dodanie słowa kluczowego DISTINCT do zapytania</title>
1211
1212             <para>
1213                 Metoda <methodname>distinct()</methodname> pozwala na dodanie słowa
1214                 kluczowego <constant>DISTINCT</constant> do zapytania <acronym>SQL</acronym>.
1215             </para>
1216
1217             <example id="zend.db.select.building.distinct.example">
1218
1219                 <title>Przykład użycia metody distinct()</title>
1220
1221                 <programlisting language="php"><![CDATA[
1222 // Tworzenie zapytania:
1223 //   SELECT DISTINCT p."product_name"
1224 //   FROM "products" AS p
1225
1226 $select = $db->select()
1227              ->distinct()
1228              ->from(array('p' => 'products'), 'product_name');
1229 ]]></programlisting>
1230
1231             </example>
1232
1233         </sect3>
1234
1235         <sect3 id="zend.db.select.building.for-update">
1236
1237             <title>Dodanie słowa kluczowego FOR UPDATE do zapytania</title>
1238
1239             <para>
1240                 Metoda <methodname>forUpdate()</methodname> pozwala na dodanie słowa
1241                 kluczowego <acronym>FOR UPDATE</acronym> do zapytania <acronym>SQL</acronym>.
1242             </para>
1243
1244             <example id="zend.db.select.building.for-update.example">
1245
1246                 <title>Przykład użycia metody forUpdate()</title>
1247
1248                 <programlisting language="php"><![CDATA[
1249 // Tworzenie zapytania:
1250 //   SELECT FOR UPDATE p.*
1251 //   FROM "products" AS p
1252
1253 $select = $db->select()
1254              ->forUpdate()
1255              ->from(array('p' => 'products'));
1256 ]]></programlisting>
1257
1258             </example>
1259
1260         </sect3>
1261
1262         <sect3 id="zend.db.select.building.union">
1263             <title>Tworzenie zapytania z UNION</title>
1264
1265             <para>
1266                 Z <classname>Zend_Db_Select</classname> można łączyć zapytania poprzez
1267                 przekazanie tablicy obiektów <classname>Zend_Db_Select</classname>
1268                 lub łańcuchów zapytań <acronym>SQL</acronym>
1269                 do metody <methodname>union()</methodname>.
1270                 Jako drugi parametr można podać stałe
1271                 <constant>Zend_Db_Select::SQL_UNION</constant>
1272                 lub <constant>Zend_Db_Select::SQL_UNION_ALL</constant>
1273                 aby określić rodzaj połączenia jaki chce się uzyskać.
1274             </para>
1275
1276             <example id="zend.db.select.building.union.example">
1277                 <title>Przykład użycia metody union()</title>
1278
1279                 <programlisting language="php"><![CDATA[
1280 $sql1 = $db->select();
1281 $sql2 = "SELECT ...";
1282
1283 $select = $db->select()
1284     ->union(array($sql1, $sql2))
1285     ->order("id");
1286 ]]></programlisting>
1287             </example>
1288         </sect3>
1289
1290     </sect2>
1291
1292     <sect2 id="zend.db.select.execute">
1293
1294         <title>Wykonywanie zapytań Select</title>
1295
1296         <para>
1297             Poniższa część opisuje jak wywołać zapytanie zawarte w obiekcie
1298             <classname>Zend_Db_Select</classname>.
1299         </para>
1300
1301         <sect3 id="zend.db.select.execute.query-adapter">
1302
1303             <title>Wykonywanie zapytań Select z poziomu adaptera bazy danych</title>
1304
1305             <para>
1306                 Zapytanie zawarte w obiekcie <classname>Zend_Db_Select</classname> można wywołać
1307                 poprzez podanie obiektu jako pierwszego argumentu
1308                 metody <methodname>query()</methodname>
1309                 obiektu <classname>Zend_Db_Adapter_Abstract</classname>.
1310                 Zalecane jest używanie obiektów <classname>Zend_Db_Select</classname>
1311                 zamiast łańcuchów znaków z zapytaniem.
1312             </para>
1313
1314             <para>
1315                 Metoda <methodname>query()</methodname> w zależności od typu adaptera bazy danych
1316                 zwraca obiekt klasy <classname>Zend_Db_Statement</classname> lub PDOStatement.
1317             </para>
1318
1319             <example id="zend.db.select.execute.query-adapter.example">
1320
1321                 <title>Przykład użycia metody query() adaptera bazy danych</title>
1322
1323                 <programlisting language="php"><![CDATA[
1324 $select = $db->select()
1325              ->from('products');
1326
1327 $stmt = $db->query($select);
1328 $result = $stmt->fetchAll();
1329 ]]></programlisting>
1330
1331             </example>
1332
1333         </sect3>
1334
1335         <sect3 id="zend.db.select.execute.query-select">
1336
1337             <title>Wykonywanie zapytań Select z samego obiektu</title>
1338
1339             <para>
1340                 Jako alternatywny sposób w stosunku do użycia
1341                 metody <methodname>query()</methodname> adaptera bazy danych,
1342                 można użyć metody o takiej samej nazwie obiektu
1343                 <classname>Zend_Db_Select</classname>. Obydwie metody zwracają obiekt klasy
1344                 <classname>Zend_Db_Statement</classname> lub PDOStatement w zależności od typu
1345                 użytego adaptera.
1346             </para>
1347
1348             <example id="zend.db.select.execute.query-select.example">
1349
1350                 <title>Przykład użycia metody obiektu Zend_Db_Select</title>
1351
1352                 <programlisting language="php"><![CDATA[
1353 $select = $db->select()
1354              ->from('products');
1355
1356 $stmt = $select->query();
1357 $result = $stmt->fetchAll();
1358 ]]></programlisting>
1359
1360             </example>
1361
1362         </sect3>
1363
1364         <sect3 id="zend.db.select.execute.tostring">
1365
1366             <title>Zamiana obiektu Select w łańcuch polecenia SQL</title>
1367
1368             <para>
1369                 Jeśli niezbędny jest dostęp do polecenia <acronym>SQL</acronym> w postaci łańcucha
1370                 znaków zawartego w obiekcie <classname>Zend_Db_Select</classname>, należy użyć
1371                 metody <methodname>__toString()</methodname>.
1372             </para>
1373
1374             <example id="zend.db.select.execute.tostring.example">
1375
1376                 <title>Przykład użycia metody __toString()</title>
1377
1378                 <programlisting language="php"><![CDATA[
1379 $select = $db->select()
1380              ->from('products');
1381
1382 $sql = $select->__toString();
1383 echo "$sql\n";
1384
1385 // Wyjściowy string:
1386 //   SELECT * FROM "products"
1387 ]]></programlisting>
1388
1389             </example>
1390
1391         </sect3>
1392
1393     </sect2>
1394
1395     <sect2 id="zend.db.select.other">
1396
1397         <title>Inne metody</title>
1398
1399         <para>
1400             Ta część opisuje inne metody klasy <classname>Zend_Db_Select</classname>, które nie
1401             zostały wymienione wcześniej: <methodname>getPart()</methodname> oraz
1402             <methodname>reset()</methodname>.
1403         </para>
1404
1405         <sect3 id="zend.db.select.other.get-part">
1406
1407             <title>Uzyskanie części obiektu Select</title>
1408
1409             <para>
1410                 Metoda <methodname>getPart()</methodname> zwraca postać łańcucha
1411                 znaków odpowiadającą jednej części polecenia <acronym>SQL</acronym>.
1412                 Można użyć tej metody aby uzyskać tablicę warunków klauzuli
1413                 <constant>WHERE</constant>, tablicę kolumn (lub wyrażeń)
1414                 zawartych w liście <constant>SELECT</constant> albo wartości ilości wierszy
1415                 klauzuli <constant>LIMIT</constant>.
1416             </para>
1417
1418             <para>
1419                 Wartością zwracaną nie jest string zawierający składnię <acronym>SQL</acronym>.
1420                 Zamiast tego zwracana jest wewnętrzna postać danych, co przeważnie oznacza tablicę
1421                 zawierającą wartości i wyrażenia. Każda część zapytania ma inną strukturę.
1422             </para>
1423
1424             <para>
1425                 Jedynym argumentem metody <methodname>getPart()</methodname> jest łańcuch znaków
1426                 identyfikujący żądaną część zapytania. String <command>'from'</command>
1427                 odpowiada części
1428                 obiektu <classname>Zend_Db_Select</classname>, która przechowuje informacje
1429                 o tabelach (włączając w to tabele połączone) w klauzuli <constant>FROM</constant>.
1430             </para>
1431
1432             <para>
1433                 Klasa <classname>Zend_Db_Select</classname> definiuje stałe, których można użyć
1434                 jako oznaczeń zapytania <acronym>SQL</acronym>. Dozwolone jest stosowanie tych
1435                 stałych bądź nazw dosłownych.
1436             </para>
1437
1438             <table id="zend.db.select.other.get-part.table">
1439
1440                 <title>Stałe używane przez metody getPart() oraz reset()</title>
1441
1442                 <tgroup cols="2">
1443                     <thead>
1444                         <row>
1445                             <entry>Stała</entry>
1446                             <entry>Wartość dosłowna</entry>
1447                         </row>
1448                     </thead>
1449
1450                     <tbody>
1451                         <row>
1452                             <entry><constant>Zend_Db_Select::DISTINCT</constant></entry>
1453                             <entry><command>'distinct'</command></entry>
1454                         </row>
1455
1456                         <row>
1457                             <entry><constant>Zend_Db_Select::FOR_UPDATE</constant></entry>
1458                             <entry><command>'forupdate'</command></entry>
1459                         </row>
1460
1461                         <row>
1462                             <entry><constant>Zend_Db_Select::COLUMNS</constant></entry>
1463                             <entry><command>'columns'</command></entry>
1464                         </row>
1465
1466                         <row>
1467                             <entry><constant>Zend_Db_Select::FROM</constant></entry>
1468                             <entry><command>'from'</command></entry>
1469                         </row>
1470
1471                         <row>
1472                             <entry><constant>Zend_Db_Select::WHERE</constant></entry>
1473                             <entry><command>'where'</command></entry>
1474                         </row>
1475
1476                         <row>
1477                             <entry><constant>Zend_Db_Select::GROUP</constant></entry>
1478                             <entry><command>'group'</command></entry>
1479                         </row>
1480
1481                         <row>
1482                             <entry><constant>Zend_Db_Select::HAVING</constant></entry>
1483                             <entry><command>'having'</command></entry>
1484                         </row>
1485
1486                         <row>
1487                             <entry><constant>Zend_Db_Select::ORDER</constant></entry>
1488                             <entry><command>'order'</command></entry>
1489                         </row>
1490
1491                         <row>
1492                             <entry><constant>Zend_Db_Select::LIMIT_COUNT</constant></entry>
1493                             <entry><command>'limitcount'</command></entry>
1494                         </row>
1495
1496                         <row>
1497                             <entry><constant>Zend_Db_Select::LIMIT_OFFSET</constant></entry>
1498                             <entry><command>'limitoffset'</command></entry>
1499                         </row>
1500                     </tbody>
1501                 </tgroup>
1502             </table>
1503
1504             <example id="zend.db.select.other.get-part.example">
1505
1506                 <title>Przykład użycia metody getPart()</title>
1507
1508                 <programlisting language="php"><![CDATA[
1509 $select = $db->select()
1510              ->from('products')
1511              ->order('product_id');
1512
1513 // Można użyć dosłownej nazwy żądanej części
1514 $orderData = $select->getPart( 'order' );
1515
1516 // Alternatywnie można posłużyć się stałą
1517 $orderData = $select->getPart( Zend_Db_Select::ORDER );
1518
1519 // Wartość zwrotna może nie być stringiem a tablicą.
1520 // Każda część zapytania może mieć inną strukturę.
1521 print_r( $orderData );
1522 ]]></programlisting>
1523
1524             </example>
1525
1526         </sect3>
1527
1528         <sect3 id="zend.db.select.other.reset">
1529
1530             <title>Czyszczenie części obiektu Select</title>
1531
1532             <para>
1533                 Metoda <methodname>reset()</methodname> umożliwia wyczyszczenie podanej części
1534                 lub całości (jeśli nie poda się argumentu) zapytania <acronym>SQL</acronym>.
1535             </para>
1536
1537             <para>
1538                 Jedyny argument jest opcjonalny. Można podać w nim część zapytania przeznaczoną
1539                 do wyczyszczenia używając tych samych łańcuchów co w przypadku metody
1540                 <methodname>getPart()</methodname>. Podana część zapytania jest ustawiana w stan
1541                 domyślny.
1542             </para>
1543
1544             <para>
1545                 Jeśli nie poda się parametru, metoda <methodname>reset()</methodname> ustawia
1546                 wszystkie części zapytania w ich stan domyślny. Przez to używany obiekt
1547                 <classname>Zend_Db_Select</classname> odpowiada nowemu obiektowi, tak jakby
1548                 został on dopiero utworzony.
1549             </para>
1550
1551             <example id="zend.db.select.other.reset.example">
1552
1553                 <title>Przykład użycia metody reset()</title>
1554
1555                 <programlisting language="php"><![CDATA[
1556 // Tworzenie zapytania:
1557 //   SELECT p.*
1558 //   FROM "products" AS p
1559 //   ORDER BY "product_name"
1560
1561 $select = $db->select()
1562              ->from(array('p' => 'products')
1563              ->order('product_name');
1564
1565 // Zmienione wymagania, sortowanie wg. innej kolumny:
1566 //   SELECT p.*
1567 //   FROM "products" AS p
1568 //   ORDER BY "product_id"
1569
1570 // Wyczyszczenie jednej części aby można było ją ponownie zdefiniować
1571 $select->reset( Zend_Db_Select::ORDER );
1572
1573 // Podanie nowej kolumny sortowania
1574 $select->order('product_id');
1575
1576 // Wyczyszczenie wszystkich części zapytania
1577 $select->reset();
1578 ]]></programlisting>
1579
1580             </example>
1581
1582         </sect3>
1583
1584     </sect2>
1585
1586 </sect1>
1587 <!--
1588 vim:se ts=4 sw=4 et:
1589 -->