UPDATE

UPDATE - polecenie używane do aktualizacji istniejących w tabeli rekordów.

Postać instrukcji UPDATE jest następująca:

UPDATE tabela
SET kolumna_1=wartosc, kolumna_2=wartosc_2,...
WHERE jakas_kolumna=jakas_wartosc


W określonej przez nas tabeli zostaną zaktualizowane tylko kolumny, które zostały określone przez nas. Pozostałe kolumny nie ulegną zmianie (przykład 1).


UWAGA!!!
Należy zwrócić uwagę na klauzulę WHERE. Bez użycia jej zostaną zmodyfikowane wszystkie rekordy w tabeli. (przykład 2)

Często zachodzi sytuacja, iż chcemy zaktualizować tylko jeden rekord.
Najlepszym rozwiązaniem w takiej sytuacji jest użycie WHERE określając klucz główny (jest on unikalną wartością - mamy pewność, iż dokładnie jeden rekord zostanie zaktualizowany).



Dla poniższych przykładów utworzono nową tabelę o nazwie TEST:


CREATE TABLE TEST (
id int,
nazwa VARCHAR2(20)
);


SELECT * FROM TEST;

ID NAZWA
---------------------- --------------------

0 rows selected



Przykład 1.

Na początek, abyśmy mogli zmodyfikować jakiekolwiek wiersze, należy dodać kilka rekordów.

INSERT INTO TEST VALUES('1', 'nazwa 1');
INSERT INTO TEST VALUES('2', 'nazwa 2');

SELECT * FROM TEST;

ID NAZWA
---------------------- --------------------
1 nazwa 1
2 nazwa 2

2 rows selected



UPDATE TEST SET NAZWA='nazwa zmieniona' WHERE ID='2';

1 rows updated


SELECT * FROM TEST;

ID NAZWA
---------------------- --------------------
1 nazwa 1
2 nazwa zmieniona

2 rows selected




Przykład 2.

UWAGA!
W tym przykładzie zostanie przedstawione użycie polecenia UPDATE bez klauzuli WHERE (zostaną zmodyfikowane wszystkie rekordy).

INSERT INTO TEST VALUES('1', 'nazwa 1');
INSERT INTO TEST VALUES('2', 'nazwa 2');

1 rows inserted
1 rows inserted

SELECT * FROM TEST;

ID NAZWA
---------------------- --------------------
1 nazwa 1
2 nazwa 2

2 rows selected


UPDATE TEST SET NAZWA='tekst';
2 rows updated


SELECT * FROM TEST;

ID NAZWA
---------------------- --------------------
1 tekst
2 tekst

2 rows selected

SELECT

SELECT - polecenie, które jest najczęściej używaną instrukcją SQL. SELECT służy głównie do pobierana danych z tabeli lub kilku tabel.


Postać instrukcji SELECT jest następująca:
SELECT kolumna FROM tabela;

Można też wybierać kilka tabel z tabeli.
SELECT kolumna1, kolumna2, kolumna3 FROM tabela;


Warto też dodać, iż SQL pozwala na używanie dużych jak i małych liter do budowania zapytań. Polecenie
SeLeCt kolumna fRoM tabela;
również będzie porawne.



Poleceniem SELECT można również pobrać wszystkie dane z tabeli.
SELECT * FROM tabela;



Instrukcja SELECT daje nam możliwość pobierania danych z kilku kolumn oraz kilku tabel jednocześnie.
Można to uczynić wykonując polecenie.

SELECT tabela.kolumna, tabela2.kolumna2 FROM tabela, tabela2;

Nazwę tabeli piszemy w pierwszej kolejności, następnie stawiamy kropkę oraz wpisujemy nazwę kolumny (bez spacji).

Należy jednak pamiętać, iż powtarzające się dane z jednej tabeli będą wiązane z danymi z drugiej tabeli.
Jeżeli na przykład nasza tabela DEPT posiada 4 rekordy oraz tabela EMP 13 rekordów, to zapytanie

SELECT DEPT.deptno, EMP.empno FROM DEPT, EMP;

zwróci nam 52 wiersze (4x13).

Zapytanie
SELECT DEPT.deptno, EMP.empno FROM DEPT, EMP WHERE DEPT.DEPTNO=EMP.DEPTNO;
pozwoli na rozwiązanie tego problemu, gdyż zadbaliśmy o to, aby DEPTNO z tabeli DEPT był taki sam jak DEPTNO z tabeli EMP (użycie WHERE).
Wynikiem tego zapytania było 13 rekordów.



Przykład 1.
Wyświetlenie całej zawartości tabeli EMP.

SELECT * FROM EMP;

EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO
---------------------- --------------- --------------- ---------------------- ------------------------- ---------------------- ---------------------- ----------------------
7369 SMITH CLERK 7902 80/12/17 800 20
7499 ALLEN SALESMAN 7698 81/02/20 2400 300 30
7521 WARD SALESMAN 7698 81/02/20 1875 500 30
7566 JONES MANAGER 7839 81/04/02 2975 20
7654 MARTIN SALESMAN 7698 81/09/28 1875 1400 30
7698 BLAKE MANAGER 7839 81/05/01 2850 30
7782 CLARK MANAGER 7839 81/06/09 2450 10
7788 SCOTT ANALYST 7566 82/12/09 3000 20
7839 KING PRESIDENT 81/11/17 5000 10
7876 ADAMS CLERK 7788 83/01/12 1100 20
7900 JAMES CLERK 7698 81/12/03 950 30
7902 FORD ANALYST 7566 81/12/03 3000 20
7934 MILLER CLERK 7782 82/01/23 1300 10

13 rows selected


Przykład 2.
Wyświetlenie danych z tabeli EMP z kolumny EMPNO.

SELECT empno FROM EMP;

EMPNO
----------------------
7369
7499
7521
7566
7654
7698
7782
7788
7839
7876
7900
7902
7934

13 rows selected



Przykład 3.
Wyświetlenie danych z tabeli DEPT z kolumny DEPTNO oraz DNAME.

SELECT deptno, dname FROM DEPT;

DEPTNO DNAME
---------------------- -------------------------
10 ACCOUNTING
20 RESEARCH
30 SALES
40 OPERATIONS

4 rows selected


Przykład 4.
Wyświetlenie danych z tabeli DEPT z kolumny DEPTNO oraz DNAME (nazwa tabeli dodana do nazwy kolumny).
Polecenie to daje taki sam wynik jak wynik z przykładu 3.

SELECT DEPT.deptno, DEPT.dname FROM DEPT;

DEPTNO DNAME
---------------------- -------------------------
10 ACCOUNTING
20 RESEARCH
30 SALES
40 OPERATIONS

4 rows selected

ORDER BY

ORDER BY - klauzula ta służy do sortowania danych. Dane można sortować rosnąco, malejąco lub używając obu warunków jednocześnie względem kilku kolumn.

Składnia polecenia jest następująca:

SELECT kolumna FROM tabela ORDER BY kolumna ASC|DESC
(przykład 1, przykład 2)

możemy definiować sortowanie względem kilku tabel, np:

SELECT kolumna1, kolumna2, FROM tabela ORDER BY kolumna1 ASC|DESC, kolumna2 ASC|DESC;
(przykład 3)



ASC i DESC oznacza sposób sortowania:
ASC - sortowanie rosnąco,
DESC - sortowanie malejąco.


UWAGA!
Możemy użyć klauzuli ORDER BY nie podawając sposobu sortowania. Domyślnym sposobem sortowania jest wtedy sortowanie rosnące (ASC).



Przykład 1.
Wybieramy numery departamentów oraz nazwy departamentów sortując względem numeru departamentów (rosnąco).

SELECT DEPTNO, DNAME FROM DEPT ORDER BY DEPTNO ASC;

lub

SELECT DEPTNo, DNAME FROM DEPT ORDER BY DEPTNO;


DEPTNO DNAME
---------------------- -------------------------
10 ACCOUNTING
20 RESEARCH
30 SALES
40 OPERATIONS

4 rows selected


Przykład 2.
Wybieramy numery departamentów oraz nazwy departamentów sortując względem numeru departamentów (malejąco).

SELECT DEPTNo, DNAME FROM DEPT ORDER BY DEPTNO DESC;s

EPTNO DNAME
---------------------- -------------------------
40 OPERATIONS
30 SALES
20 RESEARCH
10 ACCOUNTING

4 rows selected



Przykład 3.

Wybieramy wynagrodzenie (wyższe lub równe od 3000 - WHERE SAL=>'3000'), numer pracownika oraz nazwę sortując dane względem wynagrodzenia - malejąco oraz numeru pracownika - rosnąco.

SELECT SAL, EMPNO, ENAME FROM EMP WHERE SAL>='3000' ORDER BY SAL DESC, EMPNO ASC;


SAL EMPNO ENAME
---------------------- ---------------------- ---------------
5000 7839 KING
3000 7788 SCOTT
3000 7902 FORD

3 rows selected

DISTINCT

DISTINCT - polecenie, które służy do wyświetlania unikalnych (niepowtarzających się) wartości w naszym zapytaniu.

Postać instrukcji zawierającej DISTINCT jest następująca:
SELECT DISTINCT kolumna FROM tabela;

lub

SELECT DISTINCT(kolumna) FROM tabela;


UWAGA!
Polecenie DISTINCT wyświetla również puste rekordy (patrzy przykład 2).


Przykład 1.
Rozważmy następującą sytuację. Chcemy wyświetlić wszystkie unikalne nazwy zawodów naszych pracowników. W tym celu tworzymy zapytanie:

SELECT DISTINCT EMP.JOB FROM EMP;

JOB
---------------
CLERK
SALESMAN
PRESIDENT
MANAGER
ANALYST

5 rows selected

Wynikiem jest 5 rekordów, gdyż tylko tyle różnych stanowisk posiadamy w naszej bazie danych. (przypominam, że liczba rekordów w tabeli EMP jest równa 13).



Przykład 2.
Polecenie
SELECT DISTINCT EMP.MGR FROM EMP;
zwróci 7 rekordów (proszę zwrócić uwagę na rekord drugi).

MGR
----------------------
7839

7782
7698
7902
7566
7788

7 rows selected

DELETE

DELETE - polecenie używane do usuwania isteniejących w tabeli rekordów.

Postać instrukcji DELETE jest następująca:

DELETE FROM tabela WHERE kolumna=wartosc;

UWAGA!!!
Należy zwrócić uwagę na klauzulę WHERE. Bez jej użycia zostaną usunięte wszystkie rekordy w tabeli. (przykład 2).

Często zachodzi sytuacja, iż chcemy usunąć tylko jeden rekord.
Najlepszym rozwiązaniem w takiej sytuacji jest użycie WHERE określając klucz główny (jest on unikalną wartością - mamy pewność, iż dokładnie jeden rekord

zostanie usunięty).



Dla poniższych przykładów utworzono nową tabelę o nazwie TEST:

CREATE TABLE TEST (
id int,
nazwa VARCHAR2(20)
);


SELECT * FROM TEST;

ID NAZWA
---------------------- --------------------

0 rows selected





Przykład 1.

Na początek, abyśmy mogli usunąć jakiekolwiek wiersze, należy dodać kilka rekordów.

INSERT INTO TEST VALUES('1', 'do usuniecia 1');
1 rows inserted
INSERT INTO TEST VALUES('2', 'do usuniecia 2');
1 rows inserted

SELECT * FROM TEST;

ID NAZWA
---------------------- --------------------
1 do usuniecia 1
2 do usuniecia 2

2 rows selected


DELETE FROM TEST WHERE ID='1';
1 rows deleted



SELECT * FROM TEST;

ID NAZWA
---------------------- --------------------
2 do usuniecia 2

1 rows selected




Przykład 2.

UWAGA!!!
Usuwamy wszytkie rekordy (nie ma określonej klauzuli WHERE).


DELETE FROM TEST


ID NAZWA
---------------------- --------------------

0 rows selected

INSERT

INSERT - polecenie to służy do dodawania rekordów do tabeli.

Postać instrukcji INSERT jest następująca:

INSERT INTO tabela
VALUES (wartosc1, wartosc2, wartosc3,...)

lub

INSERT INTO tabela (nazwa_kolumny_1, nazwa_kolumny_2, nazwa_kolumny_3,...)
VALUES (wartosc1, wartosc2, wartosc3,...)



UWAGA!
Jeżeli chcemy wprowadzić wartość pustą (null) musimy użyć operacji INSERT określając nazwy kolumy (kolumn).
W poleceniu

INSERT INTO tabela VALUES(wartosci....);
musimy podać wszystkie wartości. W przeciwnym wypadku otrzymamy błąd. (przykład 2, przykład 3)



Przykład 1.

Wyświetlamy zawartość tabeli DEPT, następnie dodajemy rekord pierwszym sposobem.
W dalszej kolejności ponownie wyświetlamy zawartość tabeli, aby sprawdzić efekt działania polecenia INSERT.
Czynność tą powtarzamy dodając rekord drugim sposobem (uwzględniając nazwy kolumn w  poleceniu INSERT).


SELECT * FROM DEPT;

DEPTNO                 DNAME                     LOC                      
---------------------- ------------------------- -------------------------
10                     ACCOUNTING                NEW YORK                 
20                     RESEARCH                  DALLAS                   
30                     SALES                     CHICAGO                  
40                     OPERATIONS                DENVER                   

4 rows selected



INSERT INTO DEPT VALUES('50', 'NOWY WPIS 1', 'LOKALIZACJA 1');
1 rows inserted



SELECT * FROM DEPT;
DEPTNO                 DNAME                     LOC                      
---------------------- ------------------------- -------------------------
10                     ACCOUNTING                NEW YORK                 
20                     RESEARCH                  DALLAS                   
30                     SALES                     CHICAGO                  
40                     OPERATIONS                DENVER                   
50                     NOWY WPIS 1               LOKALIZACJA 1            

5 rows selected




INSERT INTO DEPT (DEPTNO, DNAME, LOC) VALUES('60', 'NOWY WPIS 2', 'LOKALIZACJA 2');
1 rows inserted




SELECT * FROM DEPT;

DEPTNO                 DNAME                     LOC                      
---------------------- ------------------------- -------------------------
10                     ACCOUNTING                NEW YORK                 
20                     RESEARCH                  DALLAS                   
30                     SALES                     CHICAGO                  
40                     OPERATIONS                DENVER                   
50                     NOWY WPIS 1               LOKALIZACJA 1            
60                     NOWY WPIS 2               LOKALIZACJA 2            

6 rows selected



Przykład 2.


INSERT INTO DEPT (DEPTNO)  VALUES('90');

DEPTNO                 DNAME                     LOC                      
---------------------- ------------------------- -------------------------
10                     ACCOUNTING                NEW YORK                 
20                     RESEARCH                  DALLAS                   
30                     SALES                     CHICAGO                  
40                     OPERATIONS                DENVER                           
90                     (null)                    (null)                               

7 rows selected



Przykład 3.

INSERT INTO DEPT VALUES('100');

Error starting at line 1 in command:
INSERT INTO DEPT  VALUES('100')
Error at Command Line:1 Column:12
Error report:
SQL Error: ORA-00947: not enough values
00947. 00000 -  "not enough values"
*Cause:   
*Action:

Otrzymujemy błąd - not enough values!!!


Błąd jest spowodowany tym, iż struktura tabeli DEPT zawiera 3 kolumny (DEPTNO, DNAME, LOC), a w naszym INSERT została określona tylko jedna wartość.

AND i OR

AND i OR - operatory używane do wyświetlania danych, w zależności od wartości logicznych operatorów.

AND
Wyświetla dane, jeżeli warunki zawarte w AND są poprawne (zwracają true).

OR
Wyświetla dane, jeżeli przynajmniej jeden z warunków zawarty w OR jest poprawny (zwraca true).


Postać instrukcji zawierającej AND i OR może wyglądać następująca:

SELECT kolumna FROM TABELA WHERE kolumna1='wartosc' AND kolumna2='wartosc';

SELECT kolumna FROM TABELA WHERE kolumna1='wartosc' OR kolumna2='wartosc';

Można łączyć warunki w jeden większy warunek:

SELECT kolumna FROM TABELA WHERE (kolumna1='wartosc' AND kolumna2='wartosc') OR kolumna3='wartosc';




Wartości logiczne AND:

PRAWDA AND PRAWDA = PRAWDA (TRUE)
PRAWDA AND FAŁSZ = FAŁSZ (FALSE)
FAŁSZ AND PRAWDA = FAŁSZ (FALSE)
FAŁSZ AND FAŁSZ = FAŁSZ (FALSE)


Wartości logiczne OR:

PRAWDA OR PRAWDA = PRAWDA (TRUE)
PRAWDA OR FAŁSZ = PRAWDA (TRUE)
FAŁSZ OR PRAWDA = PRAWDA (TRUE)
FAŁSZ OR FAŁSZ = FAŁSZ (FALSE)


Najlepiej zobrazują to praktyczne przykłady.


Przykład 1.
Wyświetlamy imię oraz stanowisko osoby, której zarobki wynoszą 5000 ORAZ (!!!) stanowiskiem, które obejmuje dana osoba jest PRESIDENT.

SELECT ENAME, JOB FROM EMP WHERE SAL='5000' AND JOB='PRESIDENT';

ENAME           JOB            
--------------- ---------------
KING            PRESIDENT      

1 rows selected

Zapytanie zwróciło rekord, gdyż istnieje osoba, której zarobki wynoszą 5000 (SAL='5000' - zwróciło TRUE) oraz stanowiskiem jest PRESIDENT (JOB='PRESIDENT' - zwróciło TRUE).



Spróbujmy teraz wykonać następujące polecenie:

SELECT ENAME, JOB FROM EMP WHERE SAL='4000' AND JOB='PRESIDENT';

ENAME           JOB            
--------------- ---------------

0 rows selected

Zapytanie nie zwróciło rekordów, gdyż warunki zawarte pomiędzy AND nie zwróciły wartości TRUE (brak jest osób, które zarabiają 4000 - zwróciło FALSE). Mimo tego, iż istnieje osoba na stanowisku PRESIDENT wartość logiczna TRUE AND FALSE zwraca FALSE.




Przykład 2.

Wyświetlamy imię oraz stanowisko osoby, której zarobki wynoszą 3000 LUB (!!!) stanowiskiem, które obejmuje dana osoba jest SALESMAN.

SELECT SAL, JOB FROM EMP WHERE SAL='3000' OR JOB='SALESMAN';

SAL                    JOB            
---------------------- ---------------
2400                   SALESMAN       
1875                   SALESMAN       
1875                   SALESMAN       
3000                   ANALYST        
3000                   ANALYST        

5 rows selected


Pierwsze trzy rekordy zostają wyświetlone dla warunku JOB='SALESMAN' (zauważmy, że zarobki są inne niż 3000), zaś ostatnie dwa rekordy zawierają inną nazwę stanowiska, jednakże zarobki wynoszą 3000.



Przykład 3.

Wyświetlamy zarobki oraz nazwę stanowiska na podstawie dwóch warunków:
- zarobki równe 5000 ORAZ nazwa stanowiska - PRESIDENT,
- zarobki mniejsze niż 1000.

SELECT SAL, JOB FROM EMP WHERE (SAL='5000' AND JOB='PRESIDENT') OR SAL < 1000;

SAL                    JOB            
---------------------- ---------------
800                    CLERK          
5000                   PRESIDENT      
950                    CLERK          

3 rows selected

WHERE

WHERE - klauzula używana do wybierania rekordów, które pasują do zadanych przez nas kryteriów.

W poleceniu tym możemy wybierać rekordy na różne sposoby określając konkretne warunki, które muszą spełniać nasze dane.

Składnia instrukcji WHERE jest następująca:

SELECT kolumna FROM tabela WHERE kolumna operator wartość.


Możliwe operatory to:
=      równe (Przykład 1)
<> (lub) !=     różne (Przykład 2)
>     większe niż  (Przykład 3)
<     mniejsze niż (Przykład 4)
>=     większe lub równe niż (Przykład 5)
<=     mniejsze lub równe niż (Przykład 6)
BETWEEN     pomiędzy (Przykład 7)
LIKE     jest "podobne" do (Przykład 8)
IN     równe jednej lub kilku wartości (Przykład 9)
NOT IN  różne od jednej lub kilku wartości (Przykład 10)



Uwaga!

Operator <> lub != może być obsługiwany w zależności od wersji SQL.

W klauzuli BEETWEEN będziemy określali zakres dolny (podawany jako pierwszy) oraz górny (podawany jako drugi).


W przykładach zwróćmy uwagę na pojedyncze cudzysłowy ('').


Zachęcham do dokładnego przeczytania przykładów, gdyż są one opatrzone dodatkowymi uwagami.




Przykład 1.

Wyświetlamy nazwę zawodu osoby, której numer identyfikacyjny (EMPNO) jest równy 7788.

SELECT JOB FROM EMP WHERE EMPNO = '7788';

JOB           
---------------
ANALYST       

1 rows selected




Przykład 2.

wyświetlamy nazwę (nazwy) zawodu (zawodów) różną od SALESMAN.

SELECT JOB FROM EMP WHERE JOB <> 'SALESMAN';

lub

SELECT JOB FROM EMP WHERE JOB != 'SALESMAN';

JOB           
---------------
CLERK         
MANAGER       
MANAGER       
MANAGER       
ANALYST       
PRESIDENT     
CLERK         
CLERK         
ANALYST       
CLERK         

10 rows selected




Przykład 3.

Wyświetlamy imię oraz wynagrodzenie pracowników, którzy zarabiają więcej niż 2500.

SELECT ENAME, SAL FROM EMP WHERE SAL > 2500;

lub

SELECT ENAME, SAL FROM EMP WHERE SAL > '2500';


ENAME           SAL                  
--------------- ----------------------
JONES           2975                 
BLAKE           2850                 
SCOTT           3000                 
KING            5000                 
FORD            3000                 

5 rows selected




Przykład 4.

Wyświetlamy imię oraz wynagrodzenie pracowników, którzy zarabiają mniej niż 1000.

SELECT ENAME, SAL FROM EMP WHERE SAL < 1000;

lub

SELECT ENAME, SAL FROM EMP WHERE SAL < '1000';

ENAME           SAL                  
--------------- ----------------------
SMITH           800                  
JAMES           950                  

2 rows selected




Przykład 5.

Wyświetlamy imię oraz wynagrodzenie pracowników, którzy zarabiają kwotę równą bądź większą niż 3000.

SELECT ENAME, SAL FROM EMP WHERE SAL >= 3000;

lub

SELECT ENAME, SAL FROM EMP WHERE SAL >= '3000';

ENAME           SAL                  
--------------- ----------------------
SCOTT           3000                 
KING            5000                 
FORD            3000                 

3 rows selected




Przykład 6.

Wyświetlamy imię oraz wynagrodzenie pracowników, którzy zarabiają kwotę równą bądź mniejszą niż 1100.

SELECT ENAME, SAL FROM EMP WHERE SAL <= 1100;

lub

SELECT ENAME, SAL FROM EMP WHERE SAL <= '1100';

ENAME           SAL                  
--------------- ----------------------
SMITH           800                  
ADAMS           1100                 
JAMES           950                  

3 rows selected





Przykład 7.

Wyświetlamy imię oraz wynagrodzenie pracowników, którzy zarabiają kwotę z przedziału 2500-6000.


SELECT ENAME, SAL FROM EMP WHERE SAL BETWEEN 2500 and 6000;

lub

SELECT ENAME, SAL FROM EMP WHERE SAL BETWEEN '2500' and '6000';

ENAME           SAL                  
--------------- ----------------------
JONES           2975                 
BLAKE           2850                 
SCOTT           3000                 
KING            5000                 
FORD            3000                 

5 rows selected


UWAGA!

Polecenie
SELECT ENAME, SAL FROM EMP WHERE SAL BETWEEN 6000 and 2500;
wyświetli 0 rekordów, gdyż zakres górny i dolny został niepoprawnie sformułowany.


KLAUZULA BETWEEN w naszym przykładzie zastępuje polecenie,

SELECT ENAME, SAL FROM EMP WHERE SAL > 2500 AND SAL < 6000;

które wyświetli taki sam wynik jak

SELECT ENAME, SAL FROM EMP WHERE SAL BETWEEN 2500 and 6000;




Przykład 8.

Wyświetlamy imię oraz wynagrodzenie pracowników, którzy zarabiają kwotę 2400.

SELECT ENAME, SAL FROM EMP WHERE SAL LIKE '2400';

ENAME           SAL                  
--------------- ----------------------
ALLEN           2400                 

1 rows selected



Klauzula LIKE ma jednak szersze zastosowanie. Używając znaku % możemy zastępować dowolny ciąg znaków.
Polecenie
SELECT ENAME, SAL FROM EMP WHERE SAL LIKE '24%';

wyświetli nam rekordy, gdzie zarobki będą równe 24, 240, 2400, 2411, 2432, 2423123, 24131231 itp.


ENAME           SAL                  
--------------- ----------------------
ALLEN           2400                 
CLARK           2450                 

2 rows selected


Znaku % można używać zarówno na początku jak i na końcu naszego warunku.

SELECT ENAME, SAL FROM EMP WHERE SAL LIKE '0';

ENAME           SAL                  
--------------- ----------------------
SCOTT           3000                 
KING            5000                 
FORD            3000                 

3 rows selected



Przykład 9.
Wyświetlamy imię oraz wynagrodzenie pracowników, którzy zarabiają kwotę 2400.

SELECT ENAME, SAL FROM EMP WHERE SAL IN '2400';

ENAME           SAL                  
--------------- ----------------------
ALLEN           2400                 

1 rows selected



W klauzuli IN możemy jednak wprowadzić więcej warunków, według których przeszukujemy nasze dane. W tym celu w nawiasie wprowadzamy warunki (po przecinku).

SELECT ENAME, SAL FROM EMP WHERE SAL IN ('2400', '2450', '5000');

ENAME           SAL                  
--------------- ----------------------
ALLEN           2400                 
CLARK           2450                 
KING            5000                 

3 rows selected

UWAGA!
W klauzuli IN musimy dokładnie określić dane, według których przeszukujemy nasze tabele, gdyż znak % nie jest obsługiwany w tego typu zapytaniach i użyty zwróci błąd.



SELECT ENAME, SAL FROM EMP WHERE SAL IN ('%', '2400');

Oto błąd:
Error starting at line 1 in command:
SELECT ENAME, SAL FROM EMP WHERE SAL IN ('%', '2400')
Error report:
SQL Error: ORA-01722: invalid number
01722. 00000 -  "invalid number"
*Cause:  
*Action:



Przykład 10.
Wyświetlamy imię oraz nazwy zawodów pracowników, których stanowisko jest inne niż SALESMAN.


SELECT ENAME, JOB FROM EMP WHERE JOB NOT IN ('SALESMAN');

ENAME           JOB           
--------------- ---------------
SMITH           CLERK         
JONES           MANAGER       
BLAKE           MANAGER       
CLARK           MANAGER       
SCOTT           ANALYST       
KING            PRESIDENT     
ADAMS           CLERK         
JAMES           CLERK         
FORD            ANALYST       
MILLER          CLERK         

10 rows selected

ORACLE - SOUNDEX()

SOUNDEX()


SOUNDEX(string)



Opis algorytmu SOUNDEX:
Soundex używany jest do porównywania słów w języku angielskim. Słowa podobnie brzmiące (np. Robert i Rupert) będą miały ten sam 4-znakowy kod Soundex (w tym przypadku R163). Jest wykorzystywany m.in. przy poszukiwaniach genealogicznych różnych wariantów tego samego nazwiska, a obliczenie kodu Soundex umożliwiają niektóre programy genealogiczne.

Dokładny opis algorytmu:

1. Pierwsza litera wyrazu staje się pierwszym znakiem kodu.
2. Spośród pozostałych liter usuwane są a, e, h, i, o, u, w i y.
3. Pozostałym literom przypisuje się następujące liczby:
1. b, f, p, v
2. c, g, j, k, q, s, x, z
3. d, t,
4. l
5. m, n
6. r
4. Spośród kolejnych wystąpień tego samego kodu w kolejnych literach wyrazu po usunięciu h lub w usuwane są wszystkie poza pierwszym.
5. Jeżeli pozostaje więcej, niż trzy cyfry to następne są usuwane. Jeżeli jest ich mniej niż trzy, to dodawane są zera.
6. Kodem Soundex wyrazu jest jego pierwsza litera i trzy uzyskane powyżej cyfry.

(wikipedia.pl)


Przykład 1:
SELECT SOUNDEX('SMITH') FROM DUAL;

SOUNDEX('SMITH')
----------------
S530


Przykład 2:
SELECT SOUNDEX('SMYTH') FROM DUAL;

SOUNDEX('SMYTH')
----------------
S530


Zgodnie z działaniem algorytmu KOD SOUNDEX jest taki sam.


Działanie algorytmu krok po kroku:
1. Pierwsza litera - pierwszy znak kodu (S).
2. Usuwamy litery z kroku drugiego - SMT
3. Przypisujemy dla M - 5, dla T - 3.
4. Cyfr jest mniej niż 3 - dodawane jest 0.
5. Ostateczny kod to S530.

ORACLE - RTRIM()

RTRIM()


RTRIM(string, znaki)

Funkcja RTRIM usuwa wszystkie "znaki" ze "string" zaczynając od PRAWEJ strony.

UWAGA!!!
Funkcja usuwa znaki do czasu wystąpienia innego znaku w "string", niż te zdefiniowane w "znaki". (PATRZ PRZYKŁADY!!!)

Jeżeli parametr "znaki" zostanie pominięty standardowo usuwane będą spacje.


Przykład 1:
Drugi parametr nie został okreslony, dlatego z tekstu 'Jakis tekst ' zostały usunięte wszystkie spacje z pewej strony.

SELECT rtrim('Jakis tekst ') FROM DUAL;

RTRIM('JAKISTEKST')
-------------------
Jakis tekst

Nasz tekst włącznie ze spacjami ma długość 16 znaków.
Po użyciu funkcji rtrim (usuwamy wszystkie spacje z prawej) nasz tekst ma długość 11 znaków.

SELECT LENGTH(rtrim('Jakis tekst ')) FROM DUAL;

LENGTH(RTRIM('JAKISTEKST'))
---------------------------
11


Przykład 2:
Funkcja usunie wszystkie znaki 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 z prawej strony stringu, do czasu wystąpienia innego znaku niż te zdefioniowane w drugim parametrze.
Funkcja napotyka na literę "A", która nie jest przez nas zdefiniowana, zatem usuwanie znaków jest przerywane. (patrz również przykład nastepny.

SELECT rtrim('123AAAAA123', '1234567890') FROM DUAL;

RTRIM('123AAAAA123','1234567890')
---------------------------------
123AAAAA


Przykład 3:

SELECT rtrim('123BAAAA123', '1234567890A') FROM DUAL;

RTRIM('123BAAAA123','1234567890A')
----------------------------------
123B

ORACLE - RPAD()

RPAD()


RPAD(string, dlugosc, string1)

Funkcja stosowana głównie do formatowania wyświetlanych wyników.


string - string do przetworzenia,

dlugosc - liczba znaków, które zwracamy. Jeżeli "dlugosc" jest mniejsza, niż długość "string", to "string" będzie obcięty do liczby znaków "dlugosc".

string1 - string którym zastąpimy znaki z prawej strony, w przypadku, gdy nasz string jest krótszy niż "dlugosc". Parametr ten jest opcjonalny. Jeżeli nie zostanie podany, zostaną wstawione spacje.

Działanie funkcji najlepiej zobrazują poniższe przykłady:


Przykład 1:
Wyświetlamy tylko dwa pierwsze znaki z tekstu, stąd wynikiem będzie "12".

SELECT rpad('1234', 2,'0') FROM DUAL;

RPAD('1234',2,'0')
------------------
12


Przykład 2:
Tekst "1234" zajmuje tylko 4 pola. Chcemy wyświetlić ten tekst w 5 polach, zatem jedno pole z lewej strony zostanie puste. W naszym przypadku puste pole zastępujemy znakiem "x", więc otrzymanym wynikiem jest "x1234".

SELECT rpad ( '1234', 5, 'x') FROM DUAL;

RPAD('1234',5,'X')
------------------
1234x

ORACLE - REPLACE()

REPLACE()


REPLACE(string, szukany_string, string_zamiana)

Funkcja zamienia w stringu "string" dany ciąg znaków (pojedynczy znak) na inny.

string - string, w którym poszukujemy ciągu "szukany_string",
szukany_string - string, pod kątem przeszukujemy "string", aby dokonać zamiany,
string_zamiana - string, na który zamieniamy wszystkie wystąpienia "szukany_string".\


UWAGA!!!
Funkcja rozróżnia duże i małe litery.


Przykład 1:
SELECT REPLACE('Zamieniamy wszystkie litery a na 1','a','1') FROM DUAL;

REPLACE('ZAMIENIAMYWSZYSTKIELITERYANA1','A','1')
------------------------------------------------
Z1mieni1my wszystkie litery 1 n1 1

ORACLE - NLS_SORT

NLS_SORT

nlsparam może przyjąć formę (parametr ten jest opcjonalny):
NLS_SORT = sort

gdzie sort określa formę sortowania w zależności od wartości podanej jako "sort".

Dostępne formy sortowania możemy wyświetlić za pomocą:

SELECT * FROM v$nls_valid_values;


Zmianę NLS_SORT wykonujemy poleceniem:

ALTER SESSION SET NLS_SORT=sortowanie;



Na przykład dla różnych wartości NLS_SORT znaki zostaną posortowane w różny sposób:

nls_sort=binary
E
Z
e
é
e


nls_sort=binary_ci
e
é
e
E
Z


nls_sort=binary_ai
é
e
e
E
Z

ORACLE - NLS_LOWER()

NLS_LOWER()

NLS_LOWER(string, nlsparam)

Funkcja zwraca string pisany małymi literami.


Przykład 1:
SELECT NLS_LOWER('TeKSt') FROM DUAL;

NLS_LOWER('TEKST')
------------------
tekst


Przykład 2:
SELECT NLS_LOWER('abc') FROM DUAL;

NLS_LOWER('ABC')
----------------
abc

ORACLE - NLS_INITCAP()

NLS_INITCAP()


NLS_INITCAP(string, nlsparam)

Funkcja NLS_INITCAP() zwraca string, w którym pierwszy znak jest pisany wielką literą, kolejne małymi literami.

(nlsparam - patrz NLSSORT)


Przykład 1:
SELECT NLS_INITCAP ('Tekst') FROM DUAL;

NLS_INITCAP('TEKST')
--------------------
Tekst

ORACLE - LTRIM()

LTRIM()


LTRIM(string, znaki)

Funkcja LTRIM usuwa wszystkie "znaki" ze "string" zaczynając od lewej strony.

UWAGA!!!
Funkcja usuwa znaki do czasu wystąpienia innego znaku w "string", niż te zdefiniowane w "znaki". (PATRZ PRZYKŁADY!!!)

Jeżeli parametr "znaki" zostanie pominięty standardowo usuwane będą spacje.


Przykład 1:
Drugi parametr nie został okreslony, dlatego z tekstu ' Jakis tekst' zostały usunięte wszystkie spacje z lewej strony.

SELECT ltrim(' Jakis tekst') FROM DUAL;

LTRIM('JAKISTEKST')
-------------------
Jakis tekst


Przykład 2:
Funkcja usunie wszystkie znaki 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 z lewej strony stringu, do czasu wystąpienia innego znaku niż te zdefioniowane w drugim parametrze.
Funkcja napotyka na literę "T", która nie jest przez nas zdefiniowana, zatem usuwanie znaków jest przerywane. (patrz również przykład nastepny.

SELECT ltrim('123Tekst', '1234567890') FROM DUAL;

LTRIM('123TEKST','1234567890')
------------------------------
Tekst


Przykład 3:

SELECT ltrim('123Tekst', '1234567890T') FROM DUAL;

LTRIM('123TEKST','1234567890T')
-------------------------------
ekst

ORACLE - LPAD()

LPAD()


LPAD(string, dlugosc, string1)

Funkcja stosowana głównie do formatowania wyświetlanych wyników.


string - string do przetworzenia,

dlugosc - liczba znaków, które zwracamy. Jeżeli "dlugosc" jest mniejsza, niż długość "string", to "string" będzie obcięty do liczby znaków "dlugosc".

string1 - string którym zastąpimy znaki z lewej strony, w przypadku, gdy nasz string jest krótszy niż "dlugosc". Parametr ten jest opcjonalny. Jeżeli nie zostanie podany, zostaną wstawione spacje.

Działanie funkcji najlepiej zobrazują poniższe przykłady:


Przykład 1:
Wyświetlamy tylko dwa pierwsze znaki z tekstu, stąd wynikiem będzie "12".

SELECT lpad ( '1234', 2,) FROM DUAL;

LPAD('1234',2,'0')
------------------
12


Przykład 2:
Tekst "1234" zajmuje tylko 4 pola. Chcemy wyświetlić ten tekst w 5 polach, zatem jedno pole z lewej strony zostanie puste. W naszym przypadku puste pole zastępujemy znakiem "x", więc otrzymanym wynikiem jest "x1234".

SELECT lpad ( '1234', 5, 'x') FROM DUAL;

LPAD('1234',5,'X')
------------------
x1234

ORACLE - LOWER()

LOWER()


LOWER(string)

Zwraca "string", pisany wyłącznie małymi literami.


Przykład 1:
SELECT LOWER('DUZE LITERY') FROM DUAL;

LOWER('DUZELITERY')
-------------------
duze litery


Przykład 2:
SELECT LOWER('JaKiS tEkSt') FROM DUAL;

LOWER('JAKISTEKST')
-------------------
jakis tekst

ORACLE - INITCAP()

INITCAP()


INITCAP(string)

Zwraca podany przez nas "string", w którym pierwsza litera W KAŻDYM SŁOWIE jest piasana dużą literą, zaś pozostałe małymi literami.


Przykład 1:
SELECT INITCAP('mala litera') FROM DUAL;

INITCAP('MALALITERA')
---------------------
Mala Litera


Przykład 2:
SELECT INITCAP('Mala Litera') FROM DUAL;

INITCAP('MALALITERA')
---------------------
Mala Litera

ORACLE - CONCAT()

CONCAT()

CONCAT(string, string1)

Funkcja łączy dwa stringi w całości.


Przykład 1:
SELECT CONCAT('Ala', ' ma kota') FROM DUAL;

CONCAT('ALA','MAKOTA')
----------------------
Ala ma kota

ORACLE - CHR()

CHR()


CHR(wartosc)
Funkcja zwraca znak przypisany do danej wartości w kodzie ASCII. (patrz UWAGA)

UWAGA!!!
Jeżeli maszyna używa kodowania EBCDIC zostanie zwrócony znak dla tego właśnie kodowania.



Przykład 1:
Używamy funkcji CHR() dla komputera korzystającego z ASCII.

SELECT CHR(97) FROM DUAL;

CHR(97)
-------
a


Jeżeli użyjemy wartości większej niż 256, wynik zostanie zwrócony używając reszty z dzielenia podanej przez nas wartości przez 256.

SELECT CHR(97+256) FROM DUAL;

CHR(97+256)
-----------
a

ORACLE - WIDTH_BUCKET()

WIDTH_BUCKET()

WIDTH_BUCKET(wartosc1, wartosc2, wartosc3, wartosc4)

Dzieli zbiór na określoną przez nas liczbę podzbiorów.
wartosc1 - określa zbiór, na którym będziemy tworzyli nasze przedziały (np. tabela)
wartosc2 - dolny zakres przedziału.
wartosc3 - górny zakres przedziału.
wartosc4 - liczba przedziałów, na które dzielimy dany przedział

UWAGA!!!
Jako "wartosc1" mogą być brane pod uwagę wartości numeryczne, albo daty.

Liczba przedziałów, na które dzielimy równa się "LICZBA PRZEDZIAŁÓW + 1"!


Poniższy przykład bardzo dobrze zobrazuje działanie funkcji:

Tworzymy tabelę MOJATABELA z jedną kolumną "i" (NUMBER - przechowujemy liczby).
CREATE TABLE MOJATABELA (
i NUMBER
);

Dodajemy rekordy do tabeli:
INSERT INTO MOJATABELA VALUES(10);
INSERT INTO MOJATABELA VALUES(20);
INSERT INTO MOJATABELA VALUES(30);
INSERT INTO MOJATABELA VALUES(40);
INSERT INTO MOJATABELA VALUES(50);


CREATE TABLE succeeded.
1 rows inserted
1 rows inserted
1 rows inserted
1 rows inserted
1 rows inserted


Wyświetlamy zawartość tabeli MOJATABELA;
SELECT * FROM MOJATABELA;

I
----------------------
10
20
30
40
50

5 rows selected


Przykład 1:
SELECT i, WIDTH_BUCKET(i, 10, 50, 4) FROM MOJATABELA;

I WIDTH_BUCKET(I,10,50,4)
---------------------- -----------------------
10 1
20 2
30 3
40 4
50 5

5 rows selected


Liczby 10,20,30,40,50 są dzielone na 5 przedziały (4+1).

Przedział zerowy (..., 10)
Pierwszy przedział <10,20)
Drugi przedział <20, 30)
Trzeci przedział <30, 40)
Czwarty przedział <40, 50)
Piąty przedział <50, ...)

ORACLE - TRUNC()

TRUNC()


TRUNC(wartosc,wartosc1)

Zwraca liczbę "wartosc", uciętą do "wartosc1" miejsc "po przecinku".

"wartosc1" jest opcjonalne. Jeżeli nie zostanie podane domyślnie wstawiane jest 0.
Jeżeli "wartosc1", jest liczbą 0, wtedy wynikiem jest liczba zwróciona bez części dziesiętnej. (przykład 3)

UWAGA!!!
"wartosc1" może być też liczbą ujemną. (przykład 2).



Przykład 1:
SELECT TRUNC(13.12, 1 ) FROM DUAL;

TRUNC(13.12,1)
----------------------
13,1


Przykład 2:
SELECT TRUNC(13.12, -1 ) FROM DUAL;

TRUNC(13.12,-1)
----------------------
10


Przykład 3:
SELECT TRUNC(13.12, 0 ) FROM DUAL;

TRUNC(13.12,0)
----------------------
13

ORACLE - TANH()

TANH()


TANH(wartosc)

Zwraca tangens hiperboliczny dla wartości "wartosc".



Przykład 1:
SELECT TANH(0) FROM DUAL;


TANH(0)
----------------------
0

1 rows selected

ORACLE - TAN()

TAN()

TAN(wartosc)

Zwraca tangens z liczby "wartosc".


Przykład 1:
SELECT TAN(0) FROM DUAL;

TAN(0)
----------------------
0

ORACLE - SQRT()

SQRT()


SQRT(wartosc)

Zwraca pierwiastek kwadratowy z liczby "wartosc".

Dla "wartosc = 0" rezultatem jest 0.
Dla "wartosc < 0" rezultatem jest NaN (NOT A NUMBER)


Przykład 1:
SELECT SQRT(4) FROM DUAL;

SQRT(4)
----------------------
2



Przykład 2:
SELECT SQRT(16) FROM DUAL;

SQRT(16)
----------------------
4

ORACLE - SINH()

SINH()


SINH(wartosc)

Zwraca sinus hiperboliczny dla wartości "wartosc".



Przykład 1:
SELECT SINH(0) "sinus hiperboliczny" FROM DUAL;


sinus hiperboliczny
----------------------
0

ORACLE - SIN()

SIN()


SIN(wartosc)

Funkcja zwraca Sinus dla podanej wartosci.


Przykład 1:
SELECT SIN(0) FROM DUAL;

SIN(0)
----------------------
0


Przykład 2:
Sinus 90 stopni wynosi. (wynik wynika z dokładności liczby PI)

SELECT SIN(90 * 3.14159265359/180) FROM DUAL;

SIN(90*3.14159265359/180)
-------------------------
0,9999999999999999999999999946562083337476

ORACLE - SIGN()

SIGN()

SIGN(wartosc)

Zwraca signum liczby.
Signum liczby oznacza znak liczby.

Dla liczb większych od zera wynikiem jest 1.
Dla liczby równej zero wynikiem jest 0.
Dla liczb ujemnych wynikiem jest -1.


Przykład 1:
SELECT SIGN(-10) FROM DUAL;

SIGN(-10)
----------------------
-1



Przykład 2:
SELECT SIGN(5) FROM DUAL;

SIGN(5)
----------------------
1

ORACLE - ROUND()

ROUND()


ROUND(wartosc) lub ROUND(wartosc, wartosc1)

Funkcja ROUND zwraca zaokrągloną liczbę.
"wartosc1" określa do ilu miejsc po przecinku ma być zaokrąglona liczba (gdy "wartosc1" jest dodatnia).
Jeżeli argument "wartosc1" nie jest określony, domyslnie przypisywane jest 0, czyli zaokrąglenie do części całkowitych.


Przykład 1:
SELECT ROUND(1.5) FROM DUAL;

ROUND(1.5)
----------------------
2


SELECT ROUND(1.5, 0) FROM DUAL;

ROUND(1.5,0)
----------------------
2



Przykład 2:
SELECT ROUND(1.1234, 2) FROM DUAL;

ROUND(1.1234,2)
----------------------
1,12


Przykład 3:
SELECT ROUND(1.1264, 2) FROM DUAL;

ROUND(1.1264,2)
----------------------
1,13





Dla "wartosc1" mniejszej od zera zaokrąglamy liczbę od miejsc położonych na lewo od części dziesiętnych.

Przykład 4:
SELECT ROUND(12.1264, -1) FROM DUAL;

ROUND(12.1264,-1)
----------------------
10


Przykład 5:
SELECT ROUND(12.1264, -2) FROM DUAL;

ROUND(12.1264,-2)
----------------------
0

ORACLE - REMAINDER()

REMAINDER()


REMAINDER(wartosc_dzielona,dzielnik)

Zwraca resztę z dzielenie "wartosc_dzielona" przez "dzielnik".

Różnica przy użyciu REMAINDER, zamiast funkcji MOD jest taka, iż REMAINDER korzysta z ROUND(), zaś MOD() z FLOOR() przy ustalaniu wyniku.
(W celu prześledzenia działania funkcji MOD(), ROUND(), FLOOR() zapraszam do przeczytania artykułów opisujących funkcje)



Najlepszym przykładem różnicy działania funkcji będzie opisanie krok po kroku.


SELECT 2/3 FROM dual;

2/3
----------------------
0,6666666666666666666666666666666666666667


Dzielenie liczby 2 przez liczbę 3 daje wynik 0.666

Dla FLOOR(0.666) wynikiem będzie 0.
Dla ROUND(0.666) wynikiem będzie 1.

Jako, że funkcja MOD() korzysta z FLOOR (wynik 0), będziemy mieli 0 i 2 reszty.
Funkcja REMAINDER() korzsyta z ROUND (wynik 1), będziemy mieli 1 i -1 reszty.
1x3 = 3
3+(-1) = 2


SELECT REMAINDER(2,3) FROM dual;

REMAINDER(2,3)
----------------------
-1



SELECT MOD(2,3) FROM dual;

MOD(2,3)
----------------------
2

ORACLE - POWER()

POWER()

POWER(wartosc1, wartosc2)

Funkcja zwraca liczbę "wartosc1" podniesioną do potęgi "wartosc2".

UWAGA!!!
Jeżeli "wartosc1" jest liczbą ujemną, "wartosc2" musi być liczbą całkowita.

SELECT POWER(-2,3.1) FROM DUAL;

SELECT POWER(-2,3.1) FROM DUAL
Error report:
SQL Error: ORA-01428: argument '-2' is out of range
01428. 00000 - "argument '%s' is out of range"
*Cause:
*Action:


Przykład 1:
SELECT POWER(-2,3) FROM DUAL;

POWER(-2,3)
----------------------
-8

1 rows selected


Przykład 2:
SELECT POWER(2,2) FROM DUAL;

POWER(2,2)
----------------------
4

1 rows selected

ORACLE - NANVL()

NANVL()


NANVL(wartosc_sprawdzana, wartosc_zwracana)

Zwraca "wartosc_zwracana" jeżeli "wartosc_sprawdzana" jest wartością NaN. NOT A NUMBER
Używana jest głównie do konwersji NaN na inne wartości.

Funkcja działa tylko na typach BINARY_FLOAT lub BINARY_DOUBLE.


Przykład 1:
CREATE TABLE MOJATABELA (
KOLUMNA BINARY_FLOAT
);


INSERT INTO MOJATABELA VALUES('NaN');
SELECT KOLUMNA, NANVL(KOLUMNA, 0) FROM MOJATABELA;


CREATE TABLE succeeded.
1 rows inserted
KOLUMNA NANVL(KOLUMNA,0)
------- ----------------
NaN 0.0

1 rows selected

ORACLE - MOD()

MOD()

MOD(liczba, dzielenie)

Funkcja zwraca resztę z dzielenia liczby "liczba" przez "dzielenie".

Dla przykładu liczbe 7 dzielimy przez 2.
Wynikiem jest 3.5.

W liczbie 7 liczba 2 "zmieści się" 3 razy. Resztą jest liczba 1.
2x3 + 1 = 7

UWAGA!!!
Jeżeli wartość drugiego argumentu jest równa 0 zwracany jest argument pierwszy.

W funkcji MOD() musza być podane dwa argumenty, w przeciwnym wypadku zostanie zwrócony błąd:

SELECT MOD(-7) FROM DUAL
Error at Command Line:1 Column:7
Error report:
SQL Error: ORA-00909: invalid number of arguments
00909. 00000 - "invalid number of arguments"
*Cause:
*Action:


Przykład 1:
SELECT MOD(7,2) FROM DUAL;

MOD(7,2)
----------------------
1

1 rows selected


UWAGA!!!
Funkcja MOD() dla liczby ujemnej nie zachowuje się w sposób standardowy.

SELECT MOD(-7,-3) FROM DUAL;

MOD(-7,-3)
----------------------
-1

-7 : -3 = 2 reszty -1


Standardowe podejście matematyczne zwróciłoby następujący wynik:

-7 : -3 = 3 reszty -2

ORACLE - LOG()

LOG()


lub LOG(wartosc1, wartosc2)

Funkcja zwraca wartosc logarytmu przy podstawie z wartosc1 z liczby wartosc2.

UWAGA!!!

"wartosc1" musi być liczbą większą od 1.
"wartosc2" musi być liczbą dodatnią.
w przeciwnym wypadku zostanie zwrócony błąd:

SELECT log(1,8) FROM DUAL
Error report:
SQL Error: ORA-01428: argument '1' is out of range
01428. 00000 - "argument '%s' is out of range"
*Cause:
*Action:


W funkcji LOG() muszą być określone dwa argumenty

SELECT log(10) FROM DUAL
Error at Command Line:1 Column:7
Error report:
SQL Error: ORA-00909: invalid number of arguments
00909. 00000 - "invalid number of arguments"
*Cause:
*Action:


Przykład 1:
SELECT log(10,1) "logarytm dziesietny z 1" FROM DUAL;

logarytm dziesietny z 1
-----------------------
0

1 rows selected


Przykład 2:
SELECT log(10,10) "logarytm dziesietny z 10" FROM DUAL;

logarytm dziesietny z 10
------------------------
1

1 rows selected

ORACLE - LN()

LN()

LN(wartosc)

Funkcja zwraca logarytm naturalny z liczby "wartosc".

UWAGA!!!
Jeżeli liczba "wartosc" jest mniejsza lub równa 0 zwrócony zostanie bład.

SELECT LN(0) "logarytm naturalny" FROM DUAL
Error report:
SQL Error: ORA-01428: argument '0' is out of range
01428. 00000 - "argument '%s' is out of range"
*Cause:
*Action:


Przykład 1:
EXP(1) zwraca wartość liczby e.

SELECT LN(EXP(1)) "logarytm naturalny z liczby e" FROM DUAL;

logarytm naturalny z liczby e
-----------------------------
1

1 rows selected

ORACLE - FLOOR()

FLOOR()

FLOOR(wartosc)

Funkcja zwraca liczbę całkowitą nie większą niż "wartosc". (podłoga liczby)


Przykład 1:
SELECT FLOOR(5.31) "podloga liczby" FROM DUAL;

podloga liczby
----------------------
5

1 rows selected


Przykład 2:
SELECT FLOOR(8.31) "podloga liczby" FROM DUAL;

podloga liczby
----------------------
8

1 rows selected

ORACLE - EXP()

EXP()

EXP(wartosc)

Funkcja zwraca wartość liczby e podniesionej do potęgi "wartosc".


EXP(1) = e^1
EXP(0) = e^0


Przykład 1:
SELECT EXP(1) "liczba e" FROM DUAL;

liczba e
----------------------
2,71828182845904523536028747135266249776

1 rows selected

ORACLE - COSH()

COSH()


COSH(wartosc)

Zwraca cosinus hiperboliczny dla wartości "wartosc".



Przykład 1:
SELECT COSH(0) "cosinus hiperboliczny" FROM DUAL;


cosinus hiperboliczny
----------------------
1

1 rows selected

ORACLE - COS()

COS()


COS(wartosc)

Funkcja zwraca cosinus dla podanej wartosci.


Przykład 1:
SELECT COS(1) "cosinus" FROM DUAL;

cosinus
----------------------
0,5403023058681397174009366074429766037354

1 rows selected

ORACLE - CEIL()

CEIL(wartosc)

Zwraca najmniejszą liczbę całkowitą nie mniejszą niż "wartosc".


Przykład 1:
SELECT CEIL(1.5) "Sufit" FROM DUAL;

Sufit
----------------------
2

1 rows selected


Przykład 2:
SELECT CEIL(-1.5) "Sufit" FROM DUAL;

Sufit
----------------------
-1

1 rows selected

ORACLE - BITAND()

BITAND()


BITAND(wartosc1, wartosc2)

Zwraca liczbę całkowitą po operacji koniunkcji liczb "wartosc1" oraz "wartosc2" (w reprezentacji binarnej).



Działanie funkcji BITAND najlepiej zobrazuje poniższy przykład.

BITAND(7,5)

Liczba 7 w systemie dwójkowym wynosi 111
Liczba 5 w systemie dwójkowym wynosi 101

Stosując AND na bitach 111 i 101 otrzymujemy 101, dlaczego ?

111
101

patrząc od prawej 1 i 1 (ostatnia kolumna) - daje nam 1.
następna kolumna - 1 i 0 - wynik 0.
kolumna pierwsza - 1 i 1 - wynik 1.


Liczba 101 w reprezentacji dwójkowej wynosi 5.



SELECT BITAND(7,5) FROM DUAL;


BITAND(7,5)
----------------------
5

1 rows selected



UWAGA!!!
Wartości w funkcji BITAND() mają bardzo duży zakres.
Możemy używać wartości z zakresu (-2)^(n-1) do 2^(n-1) dla n=128.

ORACLE - ATAN2()

ATAN2()


ATAN2(wartosc1, wartosc2)

Funkcja zwraca arcus tangens dla podanych wartosci.

ATAN2(wartosc1, wartosc2) jest równoznaczne z ATAN(wartosc1/wartosc2).


Przykład 1:
SELECT ATAN2(1.5,1.5) "ATAN2" FROM DUAL;

ATAN2
----------------------
0,7853981633974483096156608458198757210546

1 rows selected


Przykład 2:
SELECT ATAN(1.5/1.5) "ATAN" FROM DUAL;

ATAN
----------------------
0,7853981633974483096156608458198757210546

1 rows selected

ORACLE - ATAN()

ATAN()


ATAN(wartosc)

Funkcja zwraca arcus tangens dla podanej wartosci. Zwróciona wartość jest z zakresu od -PI/2 do PI/2 wyrażone w radianach.


Przykład 1:
SELECT ATAN(1) "Arcuc tangens" FROM DUAL;

Arcuc tangens
----------------------
0,7853981633974483096156608458198757210546

1 rows selected


Przykład 2:
SELECT ATAN(-2) "Arcus tangens" FROM DUAL;


Arcus tangens
----------------------
-1,10714871779409050301706546017853704007

1 rows selected

ORACLE - ASIN()

ASIN()


ASIN(wartosc)

Funkcja zwraca arcus sinus dla podanej wartosci. Zwróciona wartość jest z zakresu od -PI/2 do PI/2 wyrażone w radianach.

UWAGA!!!
"wartosc" musi byc z zakresu <-1, 1>. W przeciwnym razie zostanie zwrócony błąd:

SQL Error: ORA-01428: argument 'XXX' is out of range
01428. 00000 - "argument '%s' is out of range"



Przykład 1:
SELECT ASIN(0.5) "Arcus sinus" FROM DUAL;

Arcus sinus
----------------------
0,52359877559829887307710723054658381405

1 rows selected


Przykład 2:
SELECT ASIN(1.01) "Arcus sinus" FROM DUAL;


SELECT ASIN(1.01) "Arcus sinus" FROM DUAL
Error report:
SQL Error: ORA-01428: argument '1.01' is out of range
01428. 00000 - "argument '%s' is out of range"
*Cause:
*Action:

ORACLE - ACOS()

ACOS()


ACOS(wartosc)

Funkcja zwraca arcus cosinus dla podanej wartosci. Zwróciona wartość jest z zakresu od 0 do PI wyrażona w radianach.

UWAGA!!!
"wartosc" musi byc z zakresu <-1, 1>. W przeciwnym razie zostanie zwrócony błąd:

SQL Error: ORA-01428: argument 'XXX' is out of range
01428. 00000 - "argument '%s' is out of range"



Przykład 1:
SELECT ACOS(0.5) "Arcuc cosinus" FROM DUAL;

Arcuc cosinus
----------------------
1,04719755119659774615421446109316762805

1 rows selected


Przykład 2:
SELECT ACOS(1.01) "Arcuc cosinus" FROM DUAL;


SELECT ACOS(1.01) "Arcuc cosinus" FROM DUAL
Error report:
SQL Error: ORA-01428: argument '1.01' is out of range
01428. 00000 - "argument '%s' is out of range"
*Cause:
*Action:

ORACLE - ABS()

ABS()


ABS(wartosc)

Funkcja zwraca wartość bezwzględną "wartosc".


Przykład 1:
SELECT ABS(15) "Wartosc bezwzgledna" FROM DUAL;

Wartosc bezwzgledna
----------------------
15

1 rows selected



Przykład 2:
SELECT ABS(-15) "Wartosc bezwzgledna" FROM DUAL;

Wartosc bezwzgledna
----------------------
15

1 rows selected