SQL*Plus
Wprowadzenie
SQL*Plus to podstawowe narzędzie stosowane do pracy z serwerem Oracle. Pozwala ono na wykonywanie komend SQL oraz programów PL/SQL. Istnieje również interfejs WWW - iSQL, który ma bardzo podobne możliwości do SQL*Plus.
Połączenie do bazy za pomocą SQL*Plus
Aby się połączyć do bazy danych za pomocą SQL*Plus należy z linii komend wykonać:
sqlplus użytkownik@nazwaPołączenia
po chwili zostaniemy poproszeni o podanie hasła
Proszę podać hasło:
Po podaniu poprawnego hasła widzimy prompt SQL*Plus
SQL>
Przykład:
sqlplus hr@baza
Jeżeli nie chcemy być proszeni o podanie hasła możemy się połączyć z bazą w ten sposób:
sqlplus uzytkownik/hasło@baza
Przykład:
sqlplus hr/hr@baza
Jeżeli w czasie trwania połączenia z bazą danych chcemy się połączyć do innej bazy korzystamy z instrukcji CONNECT:
connect użytkownik@nazwaPołączenia
po napisaniu której zostaniemy poproszeni o podanie hasła.
Jeśli chcemy tego uniknąć możemy skorzystać z konstrukcji podobnej do tej, którą wykorzystywaliśmy przy wywołaniu SQL*Plus:
connect użytkownik/hasło@nazwaPołączenia
Przykłady:
connect scott@data
connect scott/tiger@data
Przerywanie połączenia
Aby przerwać połączenie z bazą danych wystarczy wydać komendę DISCONNECT. Jeżeli posiadamy system Windows możemy korzystać z graficznego interfejsu SQL*Plus.
Podstawy
Zmiana hasła
Jedną z rutynowych czynności wykonywanych przez użytkowników jest zmiana hasła. Służy do tego komenda PASSWORD nazwaUżytkownika. Zostaniemy poproszeni o podanie nowego hasła a potem jego potwierdzenie.
Przykład:
password hr
New password:
Confirm new password:
Wykonywanie instrukcji
SQL*Plus służy do wykonywania komend SQL, programów PL/SQL i pozwala na korzystanie z komend SQL*Plus np. w celu przygotowania raportów. Aby wykonać komendę wpisaną do bufora należy zakończyć ją średnikiem (wtedy wpisujemy go w tej samej linii co komendę).
SQL> select *
from locations;
Komendę można również wykonać poprzez umieszczenie znaku slash w nowej linii za komendą.
SQL> select *
2 from locations
3 /
Istnieje jeszcze jeden sposób: możemy wprowadzić komendę, a następnie wcisnąć dwa razy ENTER, co powoduje umieszczenie komendy w buforze SQL*Plus (należy pamiętać że dwa poprzednie sposoby wprowadzały komendę do bufora jednocześnie ją wykonując). UWAGA! polecenia SQL*Plus nie są przechowywane w buforze. W buforze znajdują się tylko komendy SQL i teksty programów PL/SQL.
SQL> select *
2 from locations
3
Po wprowadzeniu komendy do bufora możemy ją wykonać wydając polecenie run.
SQL> run
Operacje na buforze SQL*Plus
SQL*Plus pozwala dokonywać zmian w swoim buforze co znacznie skraca czas pracy np. nad kwerendą. Nie musimy wpisywać całego zapytania jeszcze raz, tylko możemy poprawić to już znajdujące się w buforze. W buforze przechowywana jest również informacja co wpisaliśmy w danej linii. Posłużmy się przykładem
SQL> select employee_id, first_name || ' ' || last_name as "Name", salary
2 from employees
3 where job_id like '%MAN%'
4 or salary > 11000
Kolejne numery pod promptem SQL*Plus to numery linii w buforze SQL*Plus. Należy pamiętać, że w buforze SQL*Plus znajduje się tylko ostania instrukcja SQL bądź program PL/SQL. Do wypisania zawartości bufora służy komenda LIST [n] [m],- możemy korzystać też ze skrótu tej komendy, czyli L.
Przykład:
SQL> LIST
1 select employee_id, first_name || ' ' || last_name as "Name", salary
2 from employees
3 where job_id like '%MAN%'
4* or salary > 11000
Ważne jest, aby zapamiętać, że gwiazdka pokazuje nam aktywną linię w buforze, czyli tą której tyczą się wszystkie komendy do edycji bufora, które zostaną zaprezentowane za chwilę. Komenda LIST daje nam również możliwość wybrania linii, które chcemy wyświetlić. Np. Aby wyświetlić linię trzecią podajemy LIST 3, bądź L 3.
Przykład:
SQL> l 3
3* where job_id like '%MAN%'
Możemy również wyświetlić zakres linii z bufora - należy się wtedy posłużyć obydwoma parametrami komendy LIST
Przykład:
SQL> list 1 3
1 select employee_id, first_name || ' ' || last_name as "Name", salary
2 from employees
3* where job_id like '%MAN%'
Posłużmy się przykładem, aby zaprezentować komendy wykorzystywane do edycji zawartości bufora.
SQL> select first_name, last_name, salary, department_id
2 from employees
3 where salary > 8000
FIRST_NAME LAST_NAME SALARY DEPARTMENT_ID
-------------------- ------------------------- ---------- -------------
Steven King 24000 90
Neena Kochhar 17000 90
Lex De Haan 17000 90
Alexander Hunold 9000 60
Nancy Greenberg 12000 100
Daniel Faviet 9000 100
(reszta wydruku obcięta dla lepszej czytelności)
33 rows selected.
Załóżmy, że chcemy dopisać jeszcze jeden warunek do klauzuli where, np. żeby pracownik pracował w dziale 50 lub 60, czyli department_id in (50,60). W tym celu możemy posłużyć się komendą APPEND
SQL> append and department_id in (50, 60)
3* where salary > 8000 and department_id in (50, 60)
Uwaga! Między append a and są dwie spacje, gdyż w przeciwnym wypadku otrzymalibyśmy następującą komendę where salary > 8000and department_id in (50, 60)
Wynik:
FIRST_NAME LAST_NAME SALARY DEPARTMENT_ID
---------- ---------- ---------- ---------------
Alexander Hunold 9000 60
Adam Fripp 8200 50
Zamiast wpisywać całą komendę APPEND, możemy posłużyć się skrótem, A.
SQL> select last_name, salary, job_id
2 from employees
3 where job_id like '%MAN%'
4 /
LAST_NAME SALARY JOB_ID
----------- ---------- ----------
Raphaely 11000 PU_MAN
Weiss 8000 ST_MAN
Fripp 8200 ST_MAN
Kaufling 7900 ST_MAN
Vollman 6500 ST_MAN
Mourgos 5800 ST_MAN
Russell 14000 SA_MAN
Partners 13500 SA_MAN
Errazuriz 12000 SA_MAN
Cambrault 11000 SA_MAN
Zlotkey 10500 SA_MAN
LAST_NAME SALARY JOB_ID
------------ ---------- ----------
Hartstein 13000 MK_MAN
12 rows selected.
SQL> a and salary > 10500
3* where job_id like '%MAN%' and salary > 10500
SQL> /
LAST_NAME SALARY JOB_ID
---------- -------- ----------
Raphaely 11000 PU_MAN
Russell 14000 SA_MAN
Partners 13500 SA_MAN
Errazuriz 12000 SA_MAN
Cambrault 11000 SA_MAN
Hartstein 13000 MK_MAN
6 rows selected.
Kolejną przydatną komendą jest INPUT, - pozwala ona na dopisywanie do zawartości bufora.
Przykład: Załóżmy, że chcemy poszerzyć poprzednie zapytanie o jeszcze jeden warunek np. nazwisko musi zawierać literę r. Postępujemy tak:
SQL> i
4 and last_name like '%r%'
5 /
LAST_NAME SALARY JOB_ID
---------- -------- ---------
Partners 13500 SA_MAN
Errazuriz 12000 SA_MAN
Cambrault 11000 SA_MAN
Hartstein 13000 MK_MAN
4 rows selected.
Jak widać nie musimy wpisywać całego input, możemy się posłużyć skrótem i.
Czasami zdarza się, że z bufora trzeba usunąć jakieś linie. Służy do tego komenda DEL. Komenda DEL użyta sama bądź w formie DEL * kasuje nam zawartość całego bufora (więc zalecana jest ostrożność). Pełna komenda to:
DEL [n] [m] - Komenda DEL pozwala nam na skasowanie dokładnie jednej linii. Wtedy korzystamy z DEL n, gdzie n to numer linii. Chcąc skasować zakres linii piszemy DEL n m, gdzie n to numer początkowej linii, a m to numer końcowej linii.
Przykład:
Wypiszmy najpierw zawartość bufora
SQL> l
1 select last_name, salary, job_id
2 from employees
3 where job_id like '%MAN%' and salary > 10500
4* and last_name like '%r%'
Skasujmy teraz linię z warunkiem, że nazwisko ma zawierać literę 'r'.
SQL> del 4
Ponownie wypiszmy bufor.
SQL>l
1 select last_name, salary, job_id
2 from employees
3* where job_id like '%MAN%' and salary > 10500
i wykonajmy zawartość bufora.
SQL>/
LAST_NAME SALARY JOB_ID
---------- ------ -----------
Raphaely 11000 PU_MAN
Russell 14000 SA_MAN
Partners 13500 SA_MAN
Errazuriz 12000 SA_MAN
Cambrault 11000 SA_MAN
Hartstein 13000 MK_MAN
6 rows selected.
Załóżmy, że chcemy teraz dodać warunek, iż pensja musi być mniejsza od 13000
SQL>input
4 and salary < 13000
5
SQL> l
1 select last_name, salary, job_id
2 from employees
3 where job_id like '%MAN%' and salary > 10500
4* and salary < 13000
SQL>/
LAST_NAME SALARY JOB_ID
********** ******** ********
Raphaely 11000 PU_MAN
Errazuriz 12000 SA_MAN
Cambrault 11000 SA_MAN
3 rows selected.
A teraz chcemy się pozbyć wszystkich warunków, czyli całej klauzuli where
SQL> del 3 4
SQL> l
1 select last_name, salary, job_id
2* from employees
Gdy piszemy instrukcje SQL, dość często zdarza się nam popełniać literówki.
SQL> select lsst_name, salary
2 from employees
3 where department_d = 20
4 /
where department_d = 20
*
ERROR at line 3:
ORA-00904: "DEPARTMENT_D": invalid identifier
W powyższej instrukcji są dwa błędy. Pierwszy to ten, który zwrócił serwer, czyli że nie istnieje kolumna department_d, co oczywiście jest prawdą, gdyż nasza kolumna nazywa się department_id.
Do zmiany tekstu w buforze służy komenda CHANGE/tekstDoZastapienia/nowyTekst. Uwaga komenda CHANGE działa na aktywnej linii, czyli tej, która jest zaznaczona * w buforze.
Przykład:
Spróbujmy teraz poprawić nasz błąd. Najpierw wypiszmy zawartość bufora
SQL> l
1 select lsst_name, salary
2 from employees
3* where department_d = 20
Widzimy, że 3 linia jest linią aktywną, więc od razu wydajemy komendę:
SQL> change/_d/_id
3* where department_id = 20
Uwaga: Konieczne było podanie jako tekstu do zastąpienia '_d', gdyż komenda change zastępuje pierwsze wystąpienie danego tekstu, czyli, jeżeli podalibyśmy change/d/id, uzyskalibyśmy idepartment_d - co nie było naszym celem.
Spróbujmy teraz wykonać nasze polecenie
SQL>/
select lsst_name, salary
*
ERROR at line 1:
ORA-00904: "LSST_NAME": invalid identifier
Serwer poinformuje nas, że kolumna lsst_name nie istnieje - zgadza się, gdyż nasza nazwa to last_name. Naprawiamy to w sposób następujący: najpierw wyświetlamy zawartość bufora:
SQL> l
1 select lsst_name, salary
2 from employees
3* where department_id = 20
Potem przechodzimy do linii pierwszej (linia pierwsza staje się linią aktywną), w której jest błąd:
SQL> 1
1* select lsst_name, salary
i dokonujemy zmiany z 'ss' na 'as'
SQL> c/ss/as
1* select last_name, salary
Następnie, aby potwierdzić, że wszystko jest poprawnie, wypisujemy cały bufor i wykonujemy zapytanie.
SQL> l
1 select last_name, salary
2 from employees
3* where department_id = 20
SQL>/
LAST_NAME SALARY
*********** **********
Hartstein 13000
Fay 6000
2 rows selected.
Komendy SQL*Plus'a
SQL*Plus korzysta ze zmiennych środowiskowych, które kontrolują jego działanie. Jeżeli chcemy obejrzeć ich listę wraz z aktualnym ustawieniem możemy wykorzystać polecenie SHOW ALL. Jeżeli korzystamy z wersji okienkowej dla systemu z rodziny Windows możemy skorzystać z menu Opcje | Środowisko.
SQL> show all
appinfo jest OFF i ustawione na "SQL*Plus"
arraysize 15
autocommit OFF
autoprint OFF
autorecovery OFF
(reszta wydruku obcięta dla zwiększenia czytelności)
W celu obejrzenia aktualnego ustawienia konkretnej zmiennej możemy użyć komendy show nazwaZmiennejSrodowiskowej
Przykad:
SQL> show time
time OFF
Do ustawienia wartości zmiennych środowiskowych można użyć komendy SET
SET nazwaZmiennejSrodowiskowej wartość
Uwaga! W większości przypadków można zamiast podawać pełną nazwę zmiennej użyć jej skrótu.
Poniżej przedstawię kilka najważniejszych zmiennych środowiskowych. Opis wszystkich można znaleźć na stronie dokumentacji Oracla.
ARRAY[SIZE] { n } - zmienna ta pozwala ustawić ile wierszy zwróconych przez serwer jest przesyłanych naraz do SQL*Plus. Domyślnie ustawiona jest wartość 15. Zmienna ta jest istotna, jeżeli liczba wierszy, która ma być przesłana jest duża. Determinuje ona jak szybko klient zobaczy wyniki. Poprawny zakres wartości to od 1 do 5000.
[AUTO]COMMIT {OFF | ON | IMMEDIATE | n} - kontroluje czy SQL*Plus zatwierdza automatycznie zmiany dokonywane w bazie. Domyślne jest ustawienie OFF, czyli trzeba explicite zatwierdzić zmiany. Ustawienie na ON powoduje automatyczne zatwierdzanie zmian przez SQL*Plus. Równoważną opcją jest opcja IMMEDIATE. n może przyjmować wartości z zakresu od 1 do 2 000 000 i powoduje zatwierdzenie transakcji po wykonaniu pomyślnie przez serwer n operacji SELECT, INSERT, UPDATE. (A Delete?)
COLSEP {_ | tekst} - ustawia znak bądź tekst, który jest wyświetlany między kolumnami kiedy wykonujemy SELECT. Domyślnie jest to spacja.
Przykad:
SQL> select department_id, department_name
2 from departments
3 /
DEPARTMENT_ID DEPARTMENT_NAME
------------- ------------------------------
10 Administration
20 Marketing
50 Shipping
60 IT
80 Sales
90 Executive
110 Accounting
190 Contracting
8 wierszy zostało wybranych.
SQL> set colsep "||"
Najpierw ustawiamy separator kolumn, a potem wykonujemy jeszcze raz to samo zapytanie.
SQL> select department_id, department_name
2 from departments
3 /
DEPARTMENT_ID||DEPARTMENT_NAME
-------------||------------------------------
10||Administration
20||Marketing
50||Shipping
60||IT
80||Sales
90||Executive
110||Accounting
190||Contracting
8 wierszy zostało wybranych.
AUTOT[RACE] {OFF | ON | TRACEONLY } [EXPLAIN][STATISTICS] - ustawienie tej zmiennej daje nam możliwość obejrzenia raportu po każdym wykonaniu instrukcji DML. Raport może zawierać zarówno plan wykonania instrukcji, jak i statystyki. Domyślne ustawienie, czyli OFF, powoduje, że ani plan wykonania, ani statystyki nie zostaną wyświetlone. Ustawienie na ON powoduje wyświetlenie zarówno planu, jak i statystyk. Takie samo zachowanie obserwujemy przy ustawieniu na TRACEONLY, tylko że wtedy nie zostaną wyświetlone żadne dane (np. z instrukcji SELECT).
DEF[INE] {'&' | c | OFF | ON } - korzystając z tej zmiennej możemy włączać i wyłączać korzystanie z zastępowania zmiennych (substitution variables) w SQL*Plus - opcja ON | OFF. Domyślnie te zmienne są włączone. Możemy też zdefiniować znak, którym się posłużymy oznaczając zmienną. Znakiem domyślnym jest ampersand (&).
Przykład:
SQL> select department_name
2 from departments
3 where department_id = &dep_no
4 /
Enter value for dep_no: 20
old 3: where department_id = &dep_no
new 3: where department_id = 20
DEPARTMENT_NAME
----------------
Marketing
Teraz pokażemy jak zmienić znak przed zmienną do zastąpienia (substitution variable).
SQL> set define '^'
SQL> select department_name
2 from departments
3 where department_id = ^dep_no
4 /
Enter value for dep_no: 20
old 3: where department_id = ^dep_no
new 3: where department_id = 20
DEPARTMENT_NAME
----------------
Marketing
ECHO {OFF | ON} - ta zmienna mówi nam, czy SQL*Plus wypisuje komendy użyte w skrypcie, który uruchamiamy komendą START lub @.
ESC[APE] {\ | c | OFF | ON} -zmienna ta pozwala nam zdefiniować znak, który będzie używany do zaznaczania (escape) znaków specjalnych. Pozwala nam też na włączanie i wyłączanie tego zachowania. Używa się tego np. w skryptach wykorzystujących zmienne do zastąpienia (substitution variables).
Przykład:
SQL> show escape
escape OFF
SQL> accept zmienna prompt 'Podaj wartość dla &1'
Enter value for 1: 45
Podaj wartość dla 45
W tym przykładzie &1 została potraktowana jako zmienna do zastąpienia. Natomiast jeżeli zdefiniujemy znak do zaznaczania (escape) znaków specjalnych, to
SQL> set escape '^'
SQL> show escape
escape "^" (hex 5e)
SQL> accept zmienna prompt 'Podaj wartość dla ^&1'
Podaj wartość dla &1 45
zauważymy, że symbol & został potraktowany jak zwyczajny znak.
FEEDBACK { n | OFF | ON } - zmienna ta ustala, czy SQL*Plus wyświetla liczbę zwróconych wierszy - opcje ON i OFF włączają i wyłączają to zachowanie. W miejsce n możemy podać liczbę, dopiero po osiągnięciu której zostanie wyświetlona liczba wierszy. Domyślnym ustawieniem jest 6, co oznacza, że podsumowanie ile wierszy zostało zwróconych, ukaże się, jeżeli zwróconych zostanie 6 lub więcej wierszy.
Przykład:
SQL> set feedback off
SQL> select region_name
2 from regions
3 /
REGION_NAME
-------------------------
Europe
Americas
Asia
Middle East and Africa
SQL> set feedback on
SQL> select region_name
2 from regions
3 /
REGION_NAME
-------------------------
Europe
Americas
Asia
Middle East and Africa
4 rows selected.
(Coś jest źle, bo nie ustawialiśmy feedbacku na 4, a 4 to mniej niż 6)
HEA[DING] {OFF | ON} - zmienna ta kontroluje, czy wyświetlane są nagłówki kolumn.
Przykład:
SQL> show heading
heading ON
SQL> select region_id, region_name
2 from regions
3 /
REGION_ID REGION_NAME
---------- -------------------------
1 Europe
2 Americas
3 Asia
4 Middle East and Africa
4 rows selected.
SQL> set heading off
SQL> select region_id, region_name
2 from regions
3 /
1 Europe
2 Americas
3 Asia
4 Middle East and Africa
4 rows selected.
HEADS[EP] {'|' | c | OFF | ON} - zmienna pozwala na zdefiniowanie znaku, który powoduje wyświetlanie nagłówka kolumny w więcej niż jednej linii. Przykłady będą podane w części dotyczącej tworzenia raportów za pomocą SQL*Plus.
LIN[ESIZE] {80 | N} - zmienna ta definiuje długość linii wykorzystywaną w SQL*Plus. Jeżeli wartość ta zostanie przekroczona SQL*Plus przechodzi do nowej linii.
Przykład:
SQL> set linesize 30
SQL> select first_name, last_name, salary
2 from employees
3 where department_id = 60
4 /
FIRST_NAME
--------------------
LAST_NAME
-------------------------
SALARY
----------
Alexander
Hunold
9000
Bruce
Ernst
6000
(Reszta wydruku obcięta dla zwiększenia czytelności)
5 rows selected.
Natomiast jeśli powiększymy LINESIZE nasz wydruk będzie wyglądał "ładnie" i poprawi to jego czytelność.
SQL> set linesize 200
SQL> select first_name, last_name, salary
2 from employees
3 where department_id = 60
4 /
FIRST_NAME LAST_NAME SALARY
----------- --------- ---------
Alexander Hunold 9000
Bruce Ernst 6000
David Austin 4800
Valli Pataballa 4800
Diana Lorentz 4200
5 rows selected.
LONG {80 | N} - zmienna ta ustawia maksymalną wartość (podajemy w bajtach), jaką SQL*Plus wyświetla dla kolumn typu CLOB, NCLOB, XMLType i LONG. Dodatkowo definiuje wartość maksymalną wykorzystywaną przy kopiowaniu kolumn typu LONG (wykorzystanie tego typu kolumn nie jest zalecane w wydaniach Oracle od wersji 9i).
NEWPAGE {1 | N | NONE} - zmienna ta pozwala na ustawienie liczby pustych linii, które SQL*Plus zwraca pomiędzy stronami raportów.
Uwaga! Warto zwrócić uwagę na ustawienie PAGASIZE, gdyż to ono definiuje ile linii zawiera się na stronie.
Przykład:
Dla czytelności wydruku zmieniłem PAGESIZE na 4
SQL>set pagesize 4
pagesize 4
SQL> show newpage
newpage 1
SQL> select department_id, department_name
2 from departments
3 /
DEPARTMENT0_ID DEPARTMENT_NAME
------------- ------------------------------
10 Administration
DEPARTMENT_ID DEPARTMENT_NAME
------------- ------------------------------
20 Marketing
DEPARTMENT_ID DEPARTMENT_NAME
------------- ------------------------------
30 Purchasing
DEPARTMENT_ID DEPARTMENT_NAME
------------- ------------------------------
40 Human Resources
DEPARTMENT_ID DEPARTMENT_NAME
------------- ------------------------------
50 Shipping
(reszta wydruku obcięta dla polepszenia czytelności)
W wydruku powyżej nie widzimy, gdzie się kończy jedna strona raportu, a gdzie zaczyna się nowa. Żeby to zmienić korzystamy z poniższych komend.
SQL> set newpage 2
SQL> select department_id, department_name
2 from departments
3 /
DEPARTMENT_ID DEPARTMENT_NAME
------------- ------------------------------
10 Administration
20 Marketing
30 Purchasing
40 Human Resources
DEPARTMENT_ID DEPARTMENT_NAME
------------- ------------------------------
50 Shipping
60 IT
70 Public Relations
(reszta wydruku obcięta dla polepszenia czytelności)
W tym przypadku bez problemu zauważamy gdzie kończy się pierwsza strona i zaczyna druga.
NULL {tekst} - zmienna ta pozwala ustawić tekst, który będzie się pojawiał zamiast wartości NULL w wydrukach SQL*Plus. Domyślnie jest ustawiona na spację.
Przykład:
SQL> select first_name || ' ' || last_name Osoba, manager_id
2 from employees
3 where manager_id is null
4 /
OSOBA MANAGER_ID
---------------------------------------------- ----------
Steven King
1 row selected.
Jak widzimy Steven King nie ma kierownika i SQL*Plus wypisał spację w miejsce gdzie powinien być numer kierownika. Jeżeli chcemy zmienić wypisywanie wartości NULL na tekst BRAK, to korzystamy z poniższego przykładu.
SQL> set null 'BRAK'
SQL> select first_name || ' ' || last_name Osoba, manager_id
2 from employees
3 where manager_id is null
4 /
OSOBA MANAGER_ID
---------------------------------------------- ----------
Steven King BRAK
1 row selected.
NUMF[ORMAT] {format} - zmienna ta definiuje domyślny sposób formatowania liczb przez SQL*Plus. Omówienie formatowania liczb można znaleźć w części dotyczącej formatowania raportów.
NUM[WIDTH] {10 | N} - zmienna definiuje szerokość kolumn w SQL*Plus dla kolumn typu NUMBER. Domyślną wartością jest 10.
PAGE[SIZE] {14 | N}- zmienna definiuje ile linii z SQL*Plus to jedna strona raportu. Domyślnie jest to 14 linii.
PAU[SE] {OFF | ON | text} - ustawienie tej zmiennej na ON (domyślnie OFF) pozwala na kontrolowanie wydruków z SQL*Plus wydruk się będzie zatrzymywał, kiedy liczba linii osiągnie PAGESIZE. Możemy też podać tekst, który pojawi się w miejscu gdy skończy się strona.
Przykłady:
SQL> set pause on
SQL> select department_id, department_name
2 from departments
3 /
<Enter>
DEPARTMENT_ID DEPARTMENT_NAME
------------- ------------------------------
10 Administration
20 Marketing
30 Purchasing
40 Human Resources
50 Shipping
60 IT
70 Public Relations
80 Sales
90 Executive
100 Finance
<Enter>
DEPARTMENT_ID DEPARTMENT_NAME
------------- ------------------------------
110 Accounting
(reszta wydruku obcięta dla polepszenia czytelności)
Spróbujmy zasymulować teraz działanie Unix'owego more.
SQL> set pause '--More--'
SQL> select department_id, department_name
2 from departments
3 /
--More--
DEPARTMENT_ID DEPARTMENT_NAME
------------- ------------------------------
10 Administration
20 Marketing
SERVEROUT[PUT] {OFF | ON} - zmienna ta pozwala określić, czy SQL*Plus wypisuje wydruki z programów PL/SQL, czyli wywołania DBMS_OUTPUT.PUT_LINE. Istnieje jeszcze kilka ustawień tej zmiennej, które można odszukać w dokumentacji Oracle.
SQLN[UMER] {OFF | ON} - pozwala określić, czy SQL*Plus wyświetla numery linii, kiedy nasza instrukcja SQL rozciąga się na wiele linii. Domyślne ustawienie to ON.
Przykład:
SQL> show sqlnumber
sqlnumber ON
SQL> select region_id,
2 region_name
3 from regions
4 /
SQL> set sqlnumber off
SQL> select region_id,
region_name
from regions
/
SQLP[ROMPT] {SQL> | tekst} - zmienna ta pozwala ustawić prompt SQL*Plus. Domyślnie jest to SQL>, ale jak nam się nie podoba to możemy to zmienić.
Przykład:
SQL> set sqlprompt mobsql$
mobsql$ select *
2 from countries
3 /
TI[ME] {OFF | ON} - zmienna określa, czy SQL*Plus będzie wypisywał aktualny czas przed promptem SQL*Plus. Domyślnie zmienna ta jest ustawiona na OFF.
Przykład:
SQL> set time on
19:29:32 SQL>
TIMI[NG] {OFF | ON} - zmienna ta określa, czy wyświetlane będą statystyki czasowe naszych instrukcji SQL - opcja ON włącza to zachowanie, OFF wyłącza.
Przykład:
SQL> set timing on
SQL> select department_name
2 from departments
3 where department_id = 20
4 /
DEPARTMENT_NAME
------------------------------
Marketing
1 row selected.
Elapsed: 00:00:01.54
UND[ERLINE] { - | c | ON | OFF } - zmienna ta określa znak, który służy SQL*Plus jako podkreślenie nazw kolumn w wydruku (Uwaga opcja HEADING musi być ustawiona na ON, żebyśmy mogli dostrzec różnicę. Domyślne ustawienie to znak '-'.
Przykład:
SQL> select region_name
2 from regions
3 /
REGION_NAME
-------------------------
Europe
(reszta wydruku obcięta dla polepszenia czytelności)
(Brakuje zmiany opcji underline)
SQL> select region_name
2 from regions
3 /
REGION_NAME
*************************
Europe
(reszta wydruku obcięta dla polepszenia czytelności)
VER[IFY] {ON | OFF} - zmienna kontroluje, czy SQL*Plus wyświetla tekst przed i po tym, jak wyświetli prośbę o podanie wartości zmiennej zastępowanej (substitution variable). Domyślne ustawienie to ON.
Przykład:
SQL> show verify
verify ON
SQL> select first_name || ' ' || last_name Nazwa
2 from employees
3 where employee_id = &empno
4 /
Enter value for empno: 206
old 3: where employee_id = &empno
new 3: where employee_id = 206
NAZWA
**********************************************
William Gietz
1 row selected.
W przykładzie powyżej widzimy, że SQL*Plus wyświetla linie ze zmienną zastępowalną dwa razy: starą wersję i nową. Jeżeli chcemy tego uniknąć( często przydaje się w skryptach), korzystamy z następnego przykładu.
SQL> set verify off
SQL> select first_name || ' ' || last_name
2 from employees
3 where employee_id = &empno
4 /
Enter value for empno: 206
FIRST_NAME||''||LAST_NAME
**********************************************
William Gietz
1 row selected.