#100
Część II
Pobieranie danych z bazy danych

#103
Rozdział 5.
Instrukcja SELECT

Po zaprojektowaniu, utworzeniu i wypełnieniu bazy danych następny krok polega na uzyskaniu dostępu do danych. Język SQL oferuje instrukcję SELECT, która służy do wyszukiwania danych. Podstawowa składnia instrukcji jest wręcz podejrzanie prosta. Jednak jak, pokażę w dalszej części tego rozdziału, można przy jej pomocy bardzo precyzyjnie wybierać pożądane rekordy.
Instrukcja SELECT składa się z wielu klauzuli, z których część jest opcjonalna. Zanim przejdziemy do zaawansowanych technik wyszukiwania danych, pokażę najprostsze wersje instrukcji SELECT. W tym rozdziale zamierzam omówić instrukcję SELECT w jej najprostszej postaci i pokazać, jak przy jej pomocy wyszukujemy potrzebne dane z label bazy danych. W kolejnych rozdziałach pokażę bardziej zaawansowane techniki użycia instrukcji SELECT.

Budowa instrukcji SELECT

Zanim omówię szczegóły składni, pozwolę sobie zaprezentować typową instrukcję SELECT. Listing 5.1. zawiera instrukcję SELECT i wynik wykonania tej instrukcji.
-------------------------
Listing 5.1. Prosta instrukcja SELECT

SELECT raovie_title, studio_id
FROM Movies
WHERE movie title - 'The Code Warrior'

MOVIE_TITLE STUDIO_ID
------------ --------
The Code Warrior 4
-----------------------

Jak widać, w wyniku wykonania tego zapytania zwrócone zostały dwa pola z jednego rekordu. W bazie danych zostało przeszukane pole title (tytuł)z tabeli Movies (Filmy) w poszukiwaniu nazwy "The Code Warrior". Dla znalezionego rekordu wybrano dwa pola movie_title (tytuł filmu) oraz studio id i wyświetlono na ekranie razem z nagłówkami pól.
#104
A oto prosta składnia instrukcji SELECT:

SELECT lista_pól
FROM tabela [, tabela, ...]
[WHERE warunek]
====================
Uwaga
Przedstawiona składnia instrukcji SELECT zawiera tylko najbardziej podstawowe klauzule instrukcji, występujące niemal w każdym zapytaniu. Istnieje oczywiście wiele dodatkowych klauzuli, które mogą być wykorzystane. Ich omówieniem zajmuje się cała druga część tej książki.
====================

Element lista_pól umożliwia wypisanie pól, które mają być przez zapytanie pobrane, z kolei element tabela określa, z jakiej tabeli lub tabel pobierane są dane. Sekcja WHERE umożliwia filtrowanie wyników poprzez porównanie z zadanym wzorcem. W przypadku, gdy chcemy otrzymać wszystkie wiersze z tabeli nie używamy sekcji WHERE.
=====================
Rada
Mam nawyk pisania kolejnych członów zapytania od nowej linii. Jak wyjaśniłem wcześniej, język SQL jest pod tym względem bardzo tolerancyjny, stąd też zalecam różnicowanie zapisu instrukcji w celu podniesienia ich czytelności. Wraz ze wzrostem złożoności zapytania rośnie ilość klauzul w instrukcjach. Umieszczanie ich w osobnych wierszach ułatwia kontrolę poprawności i zwiększa czytelność.
===========================

Określanie kolumn do pobrania

Instrukcja SELECT listingu 5.1 zawierała opcjonalną sekcję z WHERE, aby ograniczyć ilość rekordów zwracanych przez zapytanie. Jak widać na listngu 5.2, sekcja WHERE nie występuje. Pojawiają się tylko nazwy kolumn i nazwa tabeli, z której dane są pobierane.
--------------------------
Listing 5.2. Instrukcja SELECT, która wybiera wszystkie wiersze z tabeli Movies (Filmy)

SELECT movie_title
FROM Movies
-----------------
MOVIE_TITLE
Vegetable House
Prince Kong
The Code Warrlor
Bili Durham
Codependence Day
The Linux Flles
SQL Strikes Back
The Progranmer
Hard Code
The Rear Windows

10 rows selected
--------------------------
#105
Przeanalizujmy kolejne człony zapytania. Pierwszy element zapytania to instrukcja SELECT, następny to lista kolumn (w naszym wypadku to tylko jedna kolumna), które mają zostać wybrane. Element trzeci, klauzula FROM, oddziela listę kolumn od elementu czwartego, nazwy tabeli, z której dane są wyszukiwane. Kilka tabel może się znaleźć w jednej instrukcji SELECT. Metoda wykonania takiej instrukcji jest opisana w rozdziale 8.
Porównując wyniki zapytań z listingu 5.3 i 5.4 widzimy, że zmiana kolejności kolumn w zapytaniu powoduje zmianę w wyświetlanym wyniku zapytania. Jest to jedna z metod, która umożliwia dostosowanie wyglądu danych w raportach.
--------------------------
Listing 5.3. Zapytanie wybierające kilka kolumn

SELECT movie_title,
studio_id FROM Movies

MOVIE_TITLE STUDIO_ID
------------- -----------
Vegetable House 1
Prince Kong 2
The Code Warrior 4
Bili Durham 3
Codependence Day 1
The Linux Files 2
SQL Strikes Back 3
The Programmer 3
Hard Code 4
The Rear Windows 1

10 rows selected
--------------------------
--------------------------
Listing 5.4. Zapytanie wybierające kolumny w innej kolejności

SELECT studlo_id, movie_title
FROM Movies

STUDIO_ID MOVIE_TITLE
--------- ----------------
1 Vegetable House
2 Prince Kong
4 The Code Warrior
3 Bili Durham
1 Codependence Day
2 The Linux Files
3 SQL Strikes Back
3 The Programmer
4 Hard Code
1 The Rear Windows

10 rows selected
--------------------------

Użycie znaku "*" do wybrania wszystkich kolumn

Aby wybrać wszystkie kolumny można użyć symbolu "*", zamiast wypisywać kolejno wszystkie nazwy pól w postaci listy. Zamiast pisać:

SELECT nazwa_studio, miasto_studio, stan_studio, studio_d
FROM Studia

można napisać

SELECT *
FROM Studia
#106
Można by pomyśleć, że te dwa zapytania dadzą ten sam wynik. Sprawdźmy to na listingach 5.5 i 5.6.
--------------------------
Listing 5.5. Zapytanie wybierające wszystkie kolumny z tabeli Studios

SELECT studio_name, studio_city, studio_state, studio_id
FROM Studios

STUDIO_NAME STUDIO_CITY ST
------------- ------------- ---
Giant Los Angeles CA
MPM Burbank CA
FKG Apex NC
Delighted Artists Austin TX
Mataversal Studios Los Angeles CA
--------------------------
--------------------------

Listing 5.6. Zapytanie wybierające wszystkie kolumny z tabeli Studios z użyciem " * "
SELECT *
FROM Studios

STUDIPO_ID STUDIO_NAME STUDIO_CITY ST
----------------------------------------------
1 Giant Los Angeles CA
2 MPM Burbank CA
4 FKG Apex NC
3 Delighted Artists Austin TX
5 Mataversal Studios Los Angeles CA
--------------------------

Jak widać, w każdym zapytaniu kolumny pojawiają się w innym porządku. Zapytanie, które wykorzystuje symbol "*" do specyfikacji wszystkich kolumn, pokazuje kolumny w kolejności, w jakiej były wprowadzane przy użyciu instrukcji CREATE TABLE. Podanie wprost nazw kolumn w zapytaniu umożliwia określenie odpowiedniej ich kolejności w wyniku zapytania.
Z użyciem instrukcji SELECT * wiążą się dwa problemy. Pierwszy polega na utrzymaniu przejrzystości zapytania. Użycie instrukcji SELECT * nie daje informacji, jakie właściwie kolumny są wykorzystywane.
Problemy pojawiają się, gdy trzeba zmienić zapytanie w związku ze zmianami w strukturze bazy danych. Z tego powodu wypisywanie nazw kolumn w zapytaniu ułatwia jego analizę i modyfikację.
Drugi problem wiąże się z wydajnością. Znacznie szybciej wykonują się zapytania z listą nazw kolumn niż z użyciem symbolu "*". Zasada ta dotyczy także przypadków, gdy lista obejmuje nazwy wszystkich kolumn z tabeli, tak jak na listingu 5.5.
Instrukcja SELECT * jest często wykorzystywana do szybkiego przeglądu zawartości bazy danych. Jest również przydatna w przypadku, gdy nie znamy dokładnie struktury tabel lub przeglądamy zawartość przed napisaniem odpowiedniego zapytania, innymi słowy, jest wygodnym skrótem.
#107
Wykonywanie obliczeń na danych

Wykorzystując język SQL możemy wykonywać obliczenia na danych i pokazywać wyniki w postaci wykonanych zapytań. Wykonanie obliczeń polega na zastąpieniu pozycji z listy nazw kolumn przez wyrażenie algebraiczne, które zawiera nazwy kolumn i liczby.

Użycie wyrażeń w instrukcji SELECT

Wyrażenie zawarte w zapytaniu nie musi koniecznie zawierać nazw kolumn. W instrukcji SELECT można używać tylko liczb, albo wyrażeń algebraicznych lub łańcuchów znaków. Wynik będzie zaprezentowany, tak jak wynik normalnego zapytania. Pokazuje to listing 5.7.
---------------
Listing 5.7. Zapytanie zawierające -wyrażenia algebraiczne

SELECT 'Przypadkowy tekst', movie_title, 2+2
FROM Movies

'PRZYPADKOWYTEKST' MOVIE_TITLE 2 + 2
-----------------------------------------
Przypadkowy tekst Vegetable House 4
Przypadkowy tekst Prince Kong 1
Przypadkowy tekst The Code Warrior 4
Przypadkowy tekst Bili Durham 4
Przypadkowy tekst Codependence Day 4
Przypadkowy tekst The Linux Files 4
Przypadkowy tekst SQL Strikes Back 4
Przypadkowy tekst The Programmer 4
Przypadkowy tekst Hard Code 4
Przypadkowy tekst The Rear Windows 4

10 rows selected
---------------

Oczywiście zapytanie z listingu 5.7 jest kompletnie bezwartościowe. Łańcuch Przypadkowy tekst i liczba 4 są wypisane jak kolumny. Łańcuch znaków w odróżnieniu od innych nagłówków kolumn rozpoczyna się od pojedynczego cudzysłowu. Wyrażenie matematyczne jest wyliczane. Gdyby wyrażenie matematyczne zawrzeć wewnątrz pojedynczego cudzysłowu, to zamiast wyniku w postaci liczby 4 pojawiłby się łańcuch 2+2. To samo dotyczy nazw kolumn. Zasadę prezentuje przykład z listingu 5.8.
---------------
Listing 5.8. Wyrażenia w cudzysłowach są traktowane jak zwykłe łańcuchy znaków

SELECT 'Przypadowy tekst', 'movie_title', '2 + 2'
FROM Filmy

'PRZYPADKOWYTEKST' MOVIE_TITLE 2+2'
---------------------------------------------
Przypadkowy tekst movie_title '2+2'
Przypadkowy tekst movie_title '2+2'
Przypadkowy tekst movie_title '2+2'
Przypadkowy tekst movie_title '2+2'
Przypadkowy tekst movie_title '2+2'
Przypadkowy tekst movie_title '2+2'
#108
Przypadkowy tekst movie_title '2+2'
Przypadkowy tekst movie_title '2+2'
Przypadkowy tekst movie_title '2+2'
Przypadkowy tekst movie_title '2+2'

10 rows selected
---------------

Nazwy kolumn w wyrażeniach

Możemy używać nazw kolumn w wyrażeniach wewnątrz instrukcji SELECT. Podobnie jak wykonujemy operacje dodawania 2 + 2, możemy wykonywać obliczenia typu 2 * budżet, które zwraca podwojoną wartość z pola budżet. Można również używać wielu nazw kolumn w jednym wyrażeniu.
Załóżmy, że chcemy mieć możliwość przeliczenia przychodów, jakie osiągnęły filmy z dolarów na funty brytyjskie. Przechowywanie nowej wartości w dodatkowej kolumnie nie jest specjalnie sensowne. Z powodu zmiany kursu, wartości w tej kolumnie musiałyby być ciągle aktualizowane.
Rozwiązanie jest proste. Polega na wyliczaniu bieżącej wartości w funtach przez mnożenie wartości w dolarach przez aktualny kurs (pamiętajmy, że w przykładowej bazie danych podawane są wartości w milionach dolarów). Operację można wykonać, tak jak pokazano na listingu 5.9.
---------------
Listing 5.9. Zapytanie wykonujące obliczenia na danych z kolumny

SELECT movie_title, gross, gross * 1.5
FROM Movies

MOVIE_TITLE GROSS GROSS*1.5
------------------------------
Vegetable House 30 45
Prince Kong 51.5 77.25
The Code Warrlor 17.8 26.7
Bili Durham 15.6 23.4
Codependence Day 30 45
The Linux Files 17.5 26.25
SQL Strikes Back 10 15
The Programmer 45.3 67.95
Hard Code 30 45
The Rear Windows 17.5 26.25

10 rows selected
---------------

Jak widać, wynik składa się z 3 kolumn: tytułu filmu, przychodów z filmu oraz przychodów z filmu pomnożonych przez 1.5. Uwzględniając kurs, który wynosi 1.5 funta za dolara, otrzymujemy wynik w dwóch walutach. Zmiany kursu powinny być uwzględniane przez współczynnik, który obecnie wynosi 1.5.
Równie proste jest wykonywanie obliczeń wykorzystujących dane z kilku kolumn. Chcąc określić dochodowość poszczególnych filmów, należy wykonać odejmowanie budżetu od ogólnych przychodów, jakie film osiągnął. Listing 5.10 zawiera zapytanie, które taką operację wykonuje.
#109
---------------
Listing 5.10. Zapytanie wyliczające zyski dla poszczególnych filmów

SELECT movie_title, gross, budget, gross - budget
FROM Movies

MOVIE_TITLE GROSS BUDGET GROSS-BUDGET
------------------------------------------------------------
Vegetable House 30 20 10
Prince Kong 51.5 3.25 48.25
The Code Warrior 17.8 10.3 7.5
Bili Durham 15.6 10.1 5.5
Codependence Day 30 15 15
The Linux Files 17.5 22.2 -4.7
SQL Strikes Back 10 5 5
The Programmer 45.3 50 -4.7
Hard Code 30 77 -47
The Rear Windows 17.5 50 -32.5

10 rows selected
---------------

Czwarta kolumna tego zapytania pokazuje dochodowość filmów. Liczba ujemna w tej kolumnie informuje, że film przyniósł straty.
Przedstawione przykłady wyjaśniają wykonywanie prostych obliczeń w instrukcjach SQL. Jednak nie tylko obliczenia arytmetyczne mogą być wykonywane w zapytaniach SQL. Można również przeprowadzać obliczenia agregujące, które zostaną omówione w rozdziale 7. Te funkcje umożliwiają znajdowanie wartości średniej, maksymalnej, minimalnej i zliczają wartości w wybranych polach.
Większość baz danych dostarcza również biblioteki funkcji, które umożliwiają modyfikację danych zwracanych przez zapytanie. Część z nich będzie omówiona w rozdziale 6., a wszystkie szczegółowo w rozdziale 12.

Operatory arytmetyczne obsługiwane przez SQL

Pora na omówienie operatorów arytmetycznych dostępnych w SQL. Możemy je wykorzystać przy obliczeniach na danych w zapytaniach, jak również w filtrach ograniczających ilość danych zwracanych przez zapytania.
Tabela 5.1 zawiera listę operatorów arytmetycznych obsługiwanych przez SQL.

Tabela 5.1 Operatory arytmetyczne obsługiwane przez SQL umieszczone w kolejności wykonywania działań
Operator Działanie

() Nawiasy
/ Dzielenie
* Mnożenie
- Odejmowanie
+ Dodawanie
#110
Podczas stosowania wyrażeń arytmetycznych należy przestrzegać kolejności wykonywania działań. Mnożenie i dzielenie mają wyższy priorytet niż dodawanie i odejmowanie. W przypadku, gdy wykonywane jest mnożenie z dzieleniem lub dodawanie z odejmowaniem, działania wykonywane są kolejno od strony lewej do prawej.
Jak wyjaśniłem w rozdziale 1., nawiasy stosujemy do grupowania wyrażeń w celu ustalenia odpowiedniej kolejności wykonywania działań. Nawiasy mogą być wykorzystane w wyrażeniu SELECT do przekształcania danych w złożonych formułach. Mając na przykład bazę danych ze średnią temperaturą lipca w stolicach europejskich, chcielibyśmy przeliczyć temperaturę ze stopni Celsjusza na Farenheita. Możemy to wykonać w zapytaniu jak na listingu 5.11.
---------------
Listing 5.11. Zapytanie zamieniające temperaturę ze stopni Celsjusza na Farenheita

SELECT city, ((1.8 * avg_temp) + 32)
FROM Temperatures

CITY ((1.8*AVG TEMP)+32)
------------------------------
London 61.7
Berlin 64 .4
Paris 66.2
----------------------

Jak widać, użycie nawiasów w łatwy sposób umożliwiło wykonanie odpowiednich przeliczeń. Wykorzystanie nawiasów obrazowo wyjaśnia kolejność wykonywanych działań, chociaż w tym wypadku instrukcja bez nawiasów również wylicza poprawnie wynik.
====================
Rada
Nawiasy mogą być stosowane również do podniesienia czytelności pisanego kodu, nawet gdy nie są wymagane ze względu na poprawność pisanych wyrażeń. Grupując w nawiasach części wyrażenia możemy pokazać kolejność wykonywanych operacji oraz powiązania między poszczególnymi elementami.
=========================

Użycie słowa kluczowego AS do nadawania nazw kolumnom i wyrażeniom

W zapytaniu można użyć słowa kluczowego AS, aby przypisać nazwy kolumnom i wyrażeniom. Nazwy te mogą być wykorzystane, aby poprawić czytelność prezentowania danych zwracanych przez zapytanie. Drugi powód to przypisanie nazwy wyrażeniu algebraicznemu, żeby można się do niego odwołać przez nazwę. Składnia instrukcji wygląda następująco:

SELECT wyrażenie [ AS alias ], wyrażenie2 [AS alias] [, ...]
FROM table [, tabela, ...]
[ WHERE warunek ]
#111
Jak widać na listingu 5.11, użycie wyrażeń matematycznych w instrukcji SELECT powoduje, że nagłówki kolumn wyglądają dość nieczytelnie. Wyświetlenie w nagłówku kolumny nazwy pola jest odpowiednie poza przypadkami, gdy w polu jest złożone wyrażenie algebraiczne.
Problem pojawia się, gdy chcemy wynik zapytania zaprezentować w postaci raportu, a mamy bardzo nieczytelny nagłówek. Inna sytuacja, to gdy w programie odwołujemy się do wyników obliczeń przeprowadzonych w zapytaniu. Jak tu się odwołać do kolumny ((1.8* TEMP) + 32)?
Na szczęście język SQL dostarcza słowo kluczowe AS, które umożliwia rozwiązanie tych problemów. Przy pomocy AS możemy przypisać alias do wybranej kolumny. Listing 5.12 zawiera instrukcję SELECT z poprzedniego przykładu z zastosowaniem AS.
----------------------
Listing 5.12. Przyporządkowanie wyrażeniu nazwy
SELECT city, ((1.8 * avg_temp) + 32) AS temperature
FROM Temperatures

CITY TEMPERATURE
------------------------------
London 61.7
Berlin 64 .4
Paris 66.2
----------------------

Jak widać wyniki zapytania pozostają niezmienione, ale nagłówek drugiej kolumny ma nazwę Temperature. Poza zwiększeniem czytelności wyników takiego zapytania, mamy możliwość odwoływania się do wybranej kolumny poprzez jej nazwę. Przydatność konstrukcji z AS będzie jeszcze prezentowana w rozdziale 1. Możemy również przypisywać kolumnie nazwę wieloczłonową wpisując ją w podwójnym cudzysłowie, jak pokazano na listingu 5.13.
-----------------------------
Listing 5.13. Użycie wieloczłonowych nazw kolumn

SELECT city, ((1.8 * temp) + 32) AS "Average Temperature"
FROM Temperatures

CITY Average temperature
------------------------------
London 61.7
Berlin 64 .4
Paris 66.2
----------------------
=======================
Rada
Niektóre bazy danych umożliwiają zmianę nazwy kolumny używając znaku "="

SELECT razem = 2+2
FROM jakaś_tabela

Ta technika nie daje żadnych korzyści w porównaniu z pokazaną wcześniej i może nie działać we wszystkich bazach danych. Z tego powodu nawet w przypadku, kiedy twoja baza danych obsługuje składnię ze znakiem "=", zalecam stosowanie metody ze słowem kluczowym AS.
======================
#112
===================
Uwaga
Możliwość stosowania wieloczłonowych nazw dla kolumn została wprowadzona w standardzie SQL-92 i nie jest obsługiwana przez wszystkie bazy danych.
=======================

Filtrowanie wyników zapytania za pomocą klauzuli WHERE

Większość zaprezentowanych dotąd zapytań zwracała wszystkie wiersze z wybranej tabeli. W przypadku, gdy chcemy ilość zwracanych wierszy ograniczyć, używamy w zapytaniu klauzuli WHERE. Klauzula WHERE ogranicza ilość wierszy przez wybieranie tylko wierszy zawierających pewne wartości w określonych polach. Przykład takiego zapytania pokazuje listing 5.14.
----------------------
Listing 5.14. Zapytanie z klauzulą WHERE

SELECT movie_title, studio_id
FROM Movies
WHERE movie_title = ' Codependence Day'

MOVIE_TITLE STUDIO_ID
---------------------------
Codependence Day 1
----------------------

Jak widać zapytanie zwróciło tylko jeden wiersz, zawierający w polu tytuł filmu wartość "Codependence Day". Klauzula WHERE testuje wartość w polu movie_title dla każdego wiersza tabeli Movies i sprawdza, czy jest ona identyczna z "Codependence Day". Jeśli wynik porównania jest pozytywny, to wiersz trafia do wyniku zapytania, jeśli nie, to jest pomijany.
Testowanie, czy dane są identyczne z zadaną wartością jest tylko jedną z wielu opcji dostępnych przy filtrowaniu. Szczegółowo problematyka ta jest omówiona w rozdziale 6.
Zanim przejdziemy do następnych tematów, przedstawię wszystkie operatory dostępne z użyciem klauzuli WHERE. Z kolei w następnym rozdziale pokażę, jak przy ich pomocy tworzyć złożone wyrażenia. Porównując wyniki zapytań z zawartością tabeli Movies możemy prześledzić jak zapytania filtrują dane.
=================
Uwaga
Wszystkie operatory mogą służyć do porównywania danych numerycznych i innych typów, włączając daty. Przedstawione operatory nie współpracują z wartościami null. W następnej części wyjaśnię, dlaczego operatory nie obsługują wartości null, oraz jak wykonywać zapytania z tymi wartościami.
==================
#113
Operatory do porównywania

Przyjrzyjmy się operatorom stosowanym do tworzenia porównań w klauzuli WHERE. Znak "=" porównuje dwie wartości i zwraca wartość prawda, gdy są one identyczne. Możemy go wykorzystać do testowania liczb, łańcuchów i dat. Tabela 5.2. zawiera listę operatorów dostępnych do porównań w języku SQL F.

Tabela 5.2. Operatory porównania obsługiwane przez język SQL

Operator Prawda gdy
= Równy
<>, != Nierówny
> Większy niż
< Mniejszy niż
>= Nie mniejszy
<= Nie większy

Wykonując porównanie wartości numerycznych nie musimy stosować pojedynczych cudzysłowów wokół porównywanych wartości.
----------------------
Listing 5.15. Zapytanie wybierające rekordy w oparciu o porównanie danych numerycznych

SELECT raovie_title, gross
FROM Movies
WHERE gross < 20

MOVIE_TITLE GROSS
-----------------------
The Code Warrior 17.8
Bili Durham 15.6
The Linux Files 17.5
SQL Strikes Back 10
The Rear Windows 17.5
-----------------------

Jak można zauważyć, w wyniku zapytania wybrano tylko filmy, których przychody osiągnęły mniej niż 20 milionów dolarów. Listing 5.16 zawiera to samo zapytanie, tyle że liczba jest wpisana w cudzysłowie.
-----------------------
Listing 5.16. Zapytanie z -wartością typu łańcuch
SELECT movie_title, gross
FROM Movies
WHERE gross < '20'

MOVIE_TITLE GROSS
-----------------------
The Code Warrior 17.8
Bili Durham 15.6
The Linux Files 17.5
SQL Strikes Back 10
The Rear Windows 17.5
-----------------------
#114
Wyniki zapytań są takie same. Widać, że w przypadku danych numerycznych umieszczenie ich w cudzysłowie nie wpływa na wynik.
Sprawdzenie, czy dwie wartości są różne, wymaga użycia jednego z dwóch operatorów: <> lub !=. Ich działanie jest jednakowe, sprawdzają czy dwie wartości są identyczne. Jeżeli nie są identyczne, to wyrażenie zwracająjako wynik wartość prawda.
Wybranie wszystkich filmów poza "Codependence Day" możliwe jest przez jedno z dwóch zaprezentowanych na listingu 5.17 zapytań.
-----------------------
Listing 5.17. Klauzula WHERE sprawdzająca warunek różny (<>, !=)

SELECT movie_title, studio_id
FROM Movies
WHERE movie_title != 'Codependence Day'

SELECT movie_title, studio_id
FROM Movies
WHERE title <> 'Codependence Day'

MOVIE_TITLE STUDIO_ID
----------------------------
Vegetable House 1
Prince Kong 2
The Code Warrior 4
Bili Durham 3
The Linux Files 2
SQL Strikes Back 3
The Programmer 3
Hard Code 4
The Rear Windows 1

9 rows selected
-----------------------

Pozostałe operatory to mniejszy niż (<), większy niż (>), mniejszy lub równy (<=) i większy lub równy (>=). Operator mniejszości zwraca wartość prawda gdy wartość z lewej strony jest mniejsza od wartości z prawej strony. Operator większości zwraca wartość prawda, gdy wartość z lewej strony operatora jest większa od wartości z prawej strony. Łańcuchy znaków są porównywane zgodnie z regułami podanymi na końcu tego rozdziału w sekcji "Ustalanie identyczności łańcuchów".
Wartości z kolumn mogą być porównywane z wartościami z innych kolumn. Pokazuje to przykład na listingu 5.18, w którym wartości z kolumny budget sąporów-nywanez wartościami z kolumny gross.
-----------------------
Listing 5.18. Zapytanie porównujące wartości z dwóch kolumn

SELECT movie_title, gross, budget
FROM Movies
WHERE gross < budget

MOVIE_TITLE GROSS BUDGET
-----------------------
The Linux Files 17.5 22.2
The Programmer 45.3 50
Hard Code 30 77
The Rear Windows 17.5 50
-----------------------
#115
====================
Uwaga
Tylko operator <> jest zgodny ze standardem SQL. Operator != został wprowadzony do wielu baz danych, ale nie odpowiada standardowi. Dobrym nawykiem będzie stosowanie operatora <>.
=====================

Zapytanie porównuje wartości w kolumnie budget i gross. Sprawdzany jest każdy wiersz i w przypadku, gdy spełniony jest warunek, że budget jest większy niż gross, wiersz jest dołączany do wyniku zapytania.
W prezentowanym zapytaniu kolumny budget i gross były zawarte również na liście wyrażenia SELECT. Jednak ich obecność tam nie ma związku z wykorzystaniem ich w klauzuli WHERE. Każda kolumna z tabeli może występować w porównaniach w klauzuli WHERE.

Rozróżnianie wielkości liter w porównaniach

Niektóre bazy danych porównują łańcuchy znaków uwzględniając wielkość liter, inne nie. Od systemu baz danych i ustawień konfiguracji będzie zależało, czy wyrażenie 'sql' jest identyczne z wyrażeniem 'SQL'. Zwykle takie ustawienia w bazie danych są określane przy jej tworzeniu. W przypadku, gdy baza danych rozróżnia wielkość liter, możemy stosować funkcje UPPER () i LOWER (), aby identyfikować poprawnie różne zapisy. Jak pewnie się domyślasz funkcja UPPER () zamienia wszystkie małe litery w łańcuchu na wielkie, a funkcja LOWER () zamienia wszystkie znaki na małe litery. Listing 5.19 zawiera przykład wykorzystania funkcji LOWER () do zapobieżenia problemom z rozróżnianiem dużych i małych liter w bazie danych.
-----------------------
Listing 5.19. Użycie funkcji LOWER() do rozwiązania problemów z wielkością liter

SELECT studio_name
FROM Studdos
WHERE LOWER(studio state) = 'ca'

STUDIO NAME
----------------
Giant
MPM
Mataversal Studios
-----------------------

Jeżeli pracujesz z bazą danych rozróżniającą wielkości liter, a nie jesteś pewien, jak wprowadzano skróty dla określenia stanu, funkcja LOWER () zamieni wszystkie wartości na zapis małymi literami.

Wykonywanie obliczeń w klauzuli WHERE

Podobnie jak możemy wykonywać obliczenia na danych wybranych z tabeli, możemy również wykonywać obliczenia w klauzuli WHERE, aby pomóc w filtrowaniu rekordów.
Zwróć uwagę na listing 5.20, w którym pokazano przykład wykonania obliczeń wewnątrz klauzuli WHERE.
#116
-------------------------
Listing 5.20. Wyrażenie wewnątrz klauzuli WHERE
SELECT movie_title, gross, budget
FROM Movies
WHERE gross > (2 * budget)

MOVIE_TITLE GROSS BUDGET
Prince Kong 51.5 3.25
-------------------------

To zapytanie wyszukuje w bazie danych filmy, które osiągnęły duży sukces finansowy - przychód ponad dwukrotnie przewyższył koszty.

Postępowanie z wartościami null

Pojęcie wartości null zostało wprowadzone w rozdziale 3. Wartości null mogą sprawić trochę kłopotu przy wybieraniu danych, ponieważ nie podlegają żadnym operacjom porównania. Operatory porównania nie obsługują wartości null, ponieważ traktowana jest ona jak wartość nieznana i w związku z tym nie można jej z niczym porównać, nawet z inną wartością null.
==========================
Uwaga
Dla celów dydaktycznych w tym rozdziale zmieniłem wartość w polu gross dla filmów "Bili Durham" i "Prince Kong" na null.
============================

Wyszukiwanie wartości null

Język SQL umożliwia testowanie pól w poszukiwaniu wartości null. Użycie w klauzuli WHERE zwrotu IS NULL jest wykorzystywane do sprawdzania, czy pole zawiera tę wartość. Pokazuje to przykład na listingu 5.21.
-------------------------
Listing 5.21. Wyszukiwanie rekordów z null

SELECT movie_title
FROM Movies
WHERE gross IS NULL

MOVIE_TITLE
-------------
Prince Kong
Bili Durham

W zapytaniu pojawiają się dwa charakterystyczne elementy. Po pierwsze, zamiast standardowego operatora porównania pojawia się słowo IS. Po drugie, słowo null nie jest zawarte w cudzysłów. Słowo null i 'NULL' zapisany w cudzysłowie to dwa zupełnie różne elementy. Możemy również przeszukiwać dane w celu wybrania obiektów różnych niż null. W tym celu używamy wyrażenia l s NOT NULL. Wyrażenie to zwraca jako wynik prawdę, gdy w poszukiwanym polu znajduje się wartość inna niż null. Pokazuje to przykład z listingu 5.22.
#117
-------------------------
Listing 5.22. Użycie klauzuli IS NOT NULL

SELECT movie_title
FROM Movies
WHERE gross IS NOT NULL

MOVIE_TITLE
--------------------
Minerał House
Codependence Day
The Linux Files
SQL Strikes Back
The Programmer
The Rear Windows

6 rows selected
--------------------

Wyszukiwanie null w innych zapytaniach

Jak już pewnie wiesz, wartości null interpretowane są jako wartości nieznane. To odróżnia je od wartości pustych, takich jak ", które zawierają puste łańcuchy lub 0. Te z kolei wartości są znane, ale puste. Null to taka wartość, która może ale nie musi być pusta i jest nieznana. Spróbuję to wyjaśnić trochę dokładniej. Ponieważ null jest nieokreślony, nie mamy podstawy żeby stwierdzić, że jest równy lub od czegoś większy lub mniejszy. Null nie jest po prostu brany pod uwagę przy operacji porównania, poza użyciem klauzuli
is NULL lub is NOT NULL. Listingi 5.23 i 5.24 zawierają przykłady omówionych wcześniej własności.
--------------------
Listing 5.23. Zapytanie wyświetlające informacje o filmach i przychodach

SELECT movle_title, gross
FROM Movies

MOVIE_TITLE GROSS
--------------------
Vegetable House 30
Prince Kong
The Code Warrior 17.8
Bili Durham Codependence Day 30
The Linux Files 17.5
SQL Strikes Back 10
The Programmer 45.3
Hard Code 30
The Rear Windows 17.5

10 rows selected
--------------------

Jak widać, na listingu filmy "Prince Kong" i "Bili Durham" mają wartości null w kolumnie przychód. To oznacza, że przychód dla tych filmów jest nieznany, na przykład z powodu nie rozpoczęcia dystrybucji filmu. W przypadku, gdyby filmy okazały się klapą, to w kolumnie przychód pojawiłyby się wartości 0.
Wynik poniższego zapytania pomija rekordy z filmami "Prince Kong" oraz "Bili Durham".
#118
--------------------
Listing 5.24. Wybieranie rekordów przy użyciu standardowych operatorów porównania

SELECT movie_title, gross
FROM Movies
WHERE gross < 20

MOVIE_TITLE GROSS
--------------------
The Code Warrior 17.8
The Linux Files 17.5
SQL Strikes Back 10
The Rear Windows 17.5

SELECT movie_title, gross
FROM Movies
WHERE gross > 20

MOVIE_TITLE GROSS
--------------------
Vegetable House 30
Codependence Day 30
The Programmer 45.3
Hard Code 30
--------------------

Przy pomocy tych dwóch zapytań nie wybraliśmy wszystkich filmów. Należy jeszcze utworzyć zapytanie wypisujące filmy, dla których w polu przychód może się znajdować null. Pokazuje to listing 5.25.
--------------------
Listing 5.25. Użycie klauzuli ISNULL

SELECT movie_title, gross
FROM Movies
WHERE gross IS NULL

MOVIE_TITLE GROSS
--------------------
Prlnce Kong
Bili Durham
--------------------

Teraz pojawi się przedsmak tematyki rozdziału 6. Zamiast pisać trzecie zapytanie, możemy użyć operatora logicznego OR i wstawić klauzulę is NULL do jednego z dwóch poprzednich zapytań. Pokazano to na listingu 5.26.
--------------------
Listing 5.26. Zapytanie ze złożoną klauzulą WHERE

SELECT movie_title, gross
FROM Movies '
WHERE gross >= 20 OR gross IS NULL

MOVIE_TITLE GROSS
Vegetable House 30
Prince Kong
Bili Durham
Codependence Day 30
The Programmer 45.3
Hard Code 30

6 rows selected
--------------------
#119
Sortowanie wyników zapytania

Cechą charakterystyczną relacyjnych baz danych jest to, że kolejność kolumn i wierszy nie jest istotna. Nie są one traktowane sekwencyjnie, co odróżnia je od systemów plików i arkuszy kalkulacyjnych.
To oznacza, że możemy wybierać rekordy z bazy danych w dowolnym porządku. Domyślnie rekordy pojawiają się w kolejności, w jakiej były wprowadzone do bazy danych. Jednak często przeglądając rekordy chcemy tę kolejność określić, np. względem zawartości jednej z kolumn. Klauzula ORDER BY jest wykorzystywana do sortowania wyników zapytań.

Użycie klauzuli ORDER BY

Składnia instrukcji SELECT używającej klauzuli ORDER BY jest następująca:

SELECT lista
FROM tabela[ , tabela ...]
[WHERE warunek]
[ORDER BY ( kolumna | alias | pozycja) [ASC l DESC ]]

Wyniki zapytania będą uporządkowane względem zawartości kolumny (lub kolumn), które określimy w klauzuli ORDER BY. Listing 5.27 zawiera przykład.
--------------------
Listing 5.27. Użycie klauzuli ORDER BY

SELECT movie_title, studio_id, budget, release_date
FROM Movies
ORDER BY movie title

MOVIE_TITLE STUDIO_ID BUDGET RELEASE_D
--------------------------------------------------
Bili Durham 3 10.1 15-JUL-88
Codependence Day 1 15 01-JUL-97
Hard Code 4 77 18-APR-95
Prince Kong 2 3.25 01-MAY-79
SQL Strikes Back 3 5 01-NOV-98
The Code Warrior 4 10.3 01-SEP-91
The Linux Files 2 22.2 22-AUG-93
The Programiner 3 50 17-APR-93
The Rear Windows 1 50 11-JUL-87
The Vegetable House 1 20 01-JAN-75

10 rows selected
--------------------

Jak widać lista filmów uporządkowana jest alfabetycznie. Możemy również sortować wyniki zapytania względem wartości numerycznych. Pokazuje to listing 5.28.
-------------------------
Listing 5.28. Sortowanie względem pola numerycznego

SELECT movie_title, studio_id, budget, release_date
FROM Movies
ORDER BY budget
#120
MOVIE_TITLE STUDIO_ID BUDGET RELEASE_D
-----------------------------------------------------------
Prince Kong 2 3.25 01-MAY-79
SQL Strikes Back 3 5 01-NOV-98
Bili Durham 3 10.1 15-JUL-88
The Code Warrior 1 10.3 01-SEP-91
Codependence Day 1 15 01-JUL-97
The Vegetable House 1 20 01-JAN-75
The Linux Files Z 22.2 22-AUG-93
The Programmer 3 50 17-APR-93
The Rear Windows 1 50 11-JUL-87
Hard Code 4 77 18-APR-95

10 rows selected
-------------------------

Kolejność kolumn nie zależy od kolumny używanej do sortowania wyników zapytań. Kolumny pozostają zawsze w tym samym porządku, bez względu na kolumnę, której używamy w klauzuli ORDER BY. Możemy również sortować dane względem kolumny zawierającej dane typu data.
Listing 5.29 pokazuje wynik sortowania w oparciu o zawartość pola rele-ase_date (data wejścia na ekrany), które jest polem typu data.
-------------------------
Listing 5.29. Sortowanie zapytania w oparciu o pole typu data

SELECT movie_title, studio_id, budget, release_date
FROM Movies
ORDER BY release date

MOVIE_TITLE STUDIO_ID BUDGET RELEASE_D
--------------------------------------------------
The Vegetable House 1 20 01-JAN-75
Prince Kong 2 3.25 01-MAY-79
The Rear Windows 1 50 11-JUL-87
Bili Durham 3 10.1 15-JUL-88
The Code Warrior 4 10.3 01-SEP-91
The Programmer 3 50 17-APR-93
The Linux Files 2 22.2 22-AUG-93
Hard Code 4 77 18-APR-95
Codependence Day 1 15 01-JUL-97
SQL Strikes Back 3 5 01-NOV-98

10 rows selected
-------------------------

Sortowanie w porządku malejącym

Wyniki zapytań mogą być posortowane zarówno rosnąco, jak i malejąco. Aby wynik zapytania był posortowany malejąco, używamy w klauzuli OREDR BY słowa kluczowego DESC. Pokazuje to listing 5.30.
-------------------------
Listing 5.30. Wynik zapytania posortowany malejąco

SELECT movie_title, studio_id, budget, release_date
FROM Movies
ORDER BY release datę DESC
#121
MOVIE_TITLE STUDIO_ID BUDGET RELEASE_D
--------------------------------------------------
SQL Strikes Back 3 5 01-NOY-98
Codependence Day 1 15 01-JUL-97
Hard Code 4 77 18-APR-95
The Linux Files 2 22.2 22-AUG-93
The Programmer 3 50 17-APR-93
The Code Warrior 4 10.3 01-SEP-91
Bili Durham 3 10.1 15-JUL-88
The Rear Windows 1 50 11-JUL-87
Prince Kong 2 3.25 01-MAY-79
The Vegetable House 1 20 01-JAN-75

10 rows selected
-------------------------

Słowo kluczowe ASC jest używane do sortowania rosnącego, lecz ze względu na to, że jest to domyślny porządek sortowania, słowo to może być pomijane.

Sortowanie wyrażeń

Wyniki zapytań mogą być sortowane na podstawie wartości w kolumnie lub na podstawie wyniku wyliczonego wyrażenia. Dostępne są dwie metody używania klauzuli ORDER BY w przypadku sortowania wyników wyrażeń. Możemy w klauzuli ORDER BY odwołać się do wyrażenia przez jego pozycję na liście instrukcji SELECT, albo nadać wyrażeniu nazwę wykorzystując słowo AS i odwoływać się do tej nazwy w klauzuli ORDER BY.
Niektóre bazy danych umożliwiają wprowadzanie całych wyrażeń w klauzuli ORDER BY, ale nie jest to tak dobra metoda, jak dwie przedstawione wcześniej.
Poniżej podaję przykłady prezentujące obydwie metody. Listing 5.31 pokazuje metodę wykorzystującą odwołanie do wyrażenia przez nadaną nazwę "profits", natomiast listing 5.32 zawiera odwołanie poprzez pozycję na liście SELECT.
-------------------------
Listing S.31. Sortowanie danych na podstawie wyrażenia z wykorzystaniem słowa AS

SELECT movie_title, gross, budget, gross - budget AS profits
FROM Movies
ORDER BY profits

MOVIE_TITLE GROSS BUDGET PROFITS
--------------------------------------------------
Hard Code 30 77 -47
The Rear Windows 17.5 50 -32.5
The Linux Files 17.5 22.2 -4.7
The Prograramer 45.3 50 -4.7
SQL Strikes Back 10 5 5
The Code Warrior 17..8 10.3 7.5
Vegetable House 30 20 10
Codependence Day 30 15 15
Prince Kong - 3.25 -
Bili Durham - 10.1 -

10 rows selected
-------------------------
#122
-------------------------
Listing 5.32. Sortowanie danych na podstawie wyrażenie z wykorzystaniem pozycji na liście
SELECT

SELECT raovie_title, gross, budget, gross - budget
FROM Movies
ORDER BY 4

MOVIE_TITLE GROSS BUDGET GROSS-BUDGET
--------------------------------------------------
Hard Code 30 77 -47
The Rear Windows 17.5 50 -32.5
The Linux Files 17.5 22.2 -4.7
The Programmer 45.3 50 -4.7
SQL Strikes Back 10 5 5
The Code Warrior 17.8 10.3 7.5
Vegetable House 30 20 10
Codependence Day 30 15 15
Prince Kong - 3.25 -
Bili Durham - 10.1 -

10 rows selected
-------------------------

Porównując te dwa przykłady można zauważyć, że zapytanie z listing 5.31 jest znacznie bardziej czytelne niż to z listingu 5.32. Użycie AS w celu nadania nazwy wyrażeniu i następnie sortowanie względem tego wyrażenia jest właśnie zalecaną metodą.
Kolumna gross (przychód) zawiera dwie wartości null. Wyrażenia arytmetyczne nie obsługują null. W tej bazie danych rekordy z null ustawiane są na końcu.

Sortowanie po wielu kolumnach

Możemy zdefiniować więcej niż jedną kolumnę, względem której dane będą sortowane. Pierwsze sortowanie możemy potraktować jako uporządkowanie według kategorii. Kolejne, to sortowanie w obrębie kategorii. Aby wykonać drugie sortowanie musimy po prostu dodać drugi element do klauzuli ORDER BY. Najłatwiej to wyjaśnić na przykładzie.
Listing 5.33 pokazuje posortowane wyniki zapytania względem studia i tytułu filmu.
-------------------------
Listing 5.33. Podwójne sortowanie

SELECT movie_title, studio_id
FROM Movies
ORDER BY studio id, movie_title

MOVIE_TITLE STUDIO_ID
-------------------------
Codependence Day 1
The Rear Windows 1
Vegetable House 1
Prince Kong 2
The Linux Files 2
Bili Durham 3
SQL Strikes Back 3
The Programmer 3
Hard Code 4
The Code Warrior 4

10 rows selected
-------------------------
#123
W przypadku wielokrotnego sortowania możemy wykorzystywać te same techniki, co przy sortowaniu pojedynczym. Można nadawać nazwę wyrażeniom, ustalać porządek słowami kluczowymi ASC, DESC. Listing 5.34 pokazuje jak wykonać podwójne sortowanie, rosnąco i malejąco w tym samym zapytaniu.
-------------------------
Listing 5.34. Sortowanie rosnąco i malejąco w tym samym zapytaniu

SELECT movie_title, studio_id, gross - budget AS profits
FROM Movies
ORDER BY studio_id, profits DESC

MOVIE_TITLE STUDIO_ID PROFITS
--------------------------------------------------
Codependence Day 1 15
Vegetable House 1 10
The Rear Windows 1 -32.5
Prince Kong 2
The Linux Files 2 -4.7
Bili Durham 3
SQL Strikes Back 3 5
The Programmer 3 -4.7
The Code Warrior 4 7.5
Hard Code 4 -47

10 rows selected
-------------------------

Jak widać, nazwy studiów filmowych są posortowane rosnąco, natomiast zyski z filmów w obrębie każdego studia malejąco. W związku z rym rekordy z wartościami null pojawiają się na początku, a nie na końcu posortowanej listy.

Ustalanie identyczności łańcuchów

W większości przypadków porządek sortowania jest zgodny z naszą intuicją. Dla kolumn, które zawierają liczby, kolejność rosnąca szereguje liczby od najmniejszej do największej. Jeżeli kolumny zawierają daty i są posortowane malejąco, to daty ustawiane są od najbliższej do najstarszej.
Niestety, trochę bardziej skomplikowany jest sposób sortowania łańcuchów. Na przykład, czy łańcuch 'AAA' jest większy od 'aaa', czy równy? Albo czy 'BBB' jest większe niż 'aaa'? A czy łańcuchy zaczynające się od liczby są większe, czy mniejsze od tych zaczynających się od liter? Odpowiedzi na te pytania zależą od konkretnej bazy danych. W części VI, "Przegląd baz danych", omawiającej produkty najważniejszych producentów, znajdują się potrzebne informacje dla opisywanych tam baz. Zawsze jednak znajdziesz te informacje w dokumentacji konkretnej bazy danych. Zasady dotyczące sortowania stosują się też przy operacjach porównań. Wynika to stąd, że sortowanie bazuje na wyniku operacji porównania w celu ustawienia wartości w odpowiednim porządku. Możemy zatem reguły sortowania wykorzystać przy określaniu wyniku porównania w klauzuli WHERE. Listing 5.35 zawiera zawartość tabeli, którą utworzyłem w celu przetestowania operacji sortowania łańcuchów (używając do tego celu bazy danych OracleS). Tabela nazywa się sortme i składa się z jednej kolumny o nazwie test typu VARCHAR2(3).
#124
-------------------------
Listing 5.35. Tabela sort me nieuporządkowana

SELECT *
FROM Sortme

TEST
-------
aaa
001
AAA
Aaa
...
BBB
A
B

8 rows selected
-------------------------

Aby zobaczyć w jaki sposób są sortowane łańcuchy spójrz na listing 5.36.
-------------------------
Listing 5.36. Tabela sortme posortowana

SELECT * FROM Sortme
ORDER BY test

TEST
----
...
001
AAA
Aaa
B
BBB
a
aaa

8 rows selected
-------------------------

Jak widać, kolejność posortowanych elementów jest następująca: znaki interpunkcyjne, liczby, wielkie litery, małe litery.

Jak porównujemy łańcuchy

Łańcuchy są porównywane znak po znaku. Pierwszy znak, który jest różny dla dwóch łańcuchów, decyduje o ich kolejności. Określenie, który z dwóch znaków jest większy, polega na odczytaniu ich pozycji w sekwencji sortującej lub w zestawie znaków konkretnej bazy danych.
Metoda sprawdzania łańcuchów znak po znaku jest niezależna od długości sprawdzanych łańcuchów. W przypadku łańcuchów identycznych na początkowych pozycjach, za większy uważany jest ten dłuższy,
Ilustruje to przykład dwóch łańcuchów 'Kowal' i 'Kowalski'. 'Kowalski' uważany jest za większy, gdyż 's' na 6-tej pozycji jest większe niż nic.
#125
Sortowanie z pominięciem znaczenia wielkości liter

Chcąc posortować listę łańcuchów nie uwzględniając wielkości liter możemy w klauzuli ORDER BY użyć funkcji LOWER (). Pokazuje to listing 5.37.
-------------------------
Listing 5.37. Użycie funkcji LOW'ERO

SELECT *
FROM Sortme
ORDER BY LOWER(test)

TEST
----
....
001
a
aaa
AAA
Aaa
B
BBB

8 rows selected
-------------------------

Jak pokazuje listing, wyniki są posortowane tak, jak gdyby wszystkie litery były małe. Łańcuchy 'aaa', 'Aaa', 'AAA'sa traktowane jak identyczne, a 'a'jest mniejsze niż 'B'.

Zestaw znaków

Łańcuchy są sortowane zgodnie z podanym wcześniej opisem, ponieważ ich kolejność jest zdefiniowana przez zestaw znaków ASCII. Znakom drukowanym przypisane są liczby z zakresu od O do 255. Znaki od O do 127 zawsze podlegają ustalonemu standardowi, natomiast te od numeru 128 do 255 mogą się różnić w zależności od platformy sprzętowej, oprogramowania i kraju.
Kiedy baza danych używa zestawu znaków ASCII, to łańcuchy są sortowane na podstawie pozycji znaku w tabeli znaków ASCII. Znak 'a' ma wartość 97, a 'B' ma wartość 66. Stąd wynika, że 'B' jest uszeregowane przed 'a'. Zestaw znaków ASCII nie jest jedynym istniejącym zestawem znaków. Komputery IBM typu mainframe używają zestawu znaków EBCDIC, który porządkuje znaki w innej kolejności niż zestaw ASCII.

W praktyce

Jednym z najważniejszych zagadnień w praktycznym zastosowaniu języka SQL jest minimalizacja ilości zapytań. Po prostu im mniej zapytań ma do wykonania baza danych, tym lepszą osiąga wydajność. Tak jest w większości wypadków, choć zdarzają się sytuacje, że lepiej jedno, bardzo skomplikowane zapytanie podzielić na kilka prostszych.
#126
Jednak, jeżeli zapytania są proste, ich ilość ma negatywny wpływ na wydajność aplikacji. Celem tej sekcji jest wyjaśnienie, jak stosowanie pewnych zaawansowanych technik może ograniczyć czas programowania i czas wykonywania aplikacji.
W tym rozdziale pokazałem jedynie najprostsze typy instrukcji SELECT. Zapytania składały się z listy kolumn, nazwy tabeli z której pobierano dane oraz z prostych porównań umieszczanych w klauzuli WHERE. Niestety nowicjusze, a nawet średnio zaawansowani programiści mają zwyczaj używania znacznie większej liczby zapytań, niż to jest konieczne do wykonania określonego zadania. Następne trzy rozdziały omawiają różne techniki stosowania instrukcji SELECT w celu trafnego i precyzyjnego wyszukiwania rekordów.
Istnieją dwa różne obszary zastosowania złożonych zapytań. Pierwszy dotyczy wybierania danych z kilku tabel. Weźmy pod uwagę zapytanie, które wyszukuje listę plenerów dla wszystkich filmów z bazy danych. Wykorzystując złączenia opisane w rozdziale 8., wynik może być uzyskany przez jedno zapytanie. Nowicjusze mogliby próbować utworzyć najpierw zapytanie, które tworzy listę identyfikatorów filmów f ilm_id z tabeli Movies (Filmy). Następny krok polegałby na utworzeniu pętli, która na podstawie listy identyfikatorów filmów wybiera plenery dla każdego filmu.
Drugi obszar zastosowań, gdzie programiści mogliby pokusić się o podział zadania na kilka zapytań, to porównywanie danych z tabeli z innymi danymi z tej samej tabeli. Wyobraźmy sobie sytuację, że chcemy znaleźć listę stanów, w których mieszka więcej niż l osoba. Dane osób znajdują się w tabeli People (Osoby). Zadanie to można wykonać wybierając listę stanów i nazwisk osób z tabeli People. Następny krok to zdefiniowanie pętli, która sprawdza czy jeszcze inna osoba mieszka w tym samym stanie, co osoba aktualnie wybrana z listy. Metoda ta jest wolna i nieporęczna do wykonania tego zadania. Dwie lepsze metody opisałem w kolejnych rozdziałach. Pierwsza polega na utworzeniu złączenia tabeli z samą sobą (metoda opisana w rozdziale 8.), druga wykorzystuje ideę podzapytań (w rozdziale 9.).