ATNEL tech-forum

Re: SQL - ORACLE

2014-05-20T22:35:11+01:00

Nadal uważam że zmienna o tak dużej dokładności jest zbędna
Ale to nie ja projektuję więc ........

A co do jednej kolumny z czasem to przecież nie problem bo zawsze można walnąć

np.:
[syntax=sql]select to_char(SYSDATE, 'YYYY-MM-DD ') as "Data",to_char(SYSDATE, 'HH24:MM:SS ') as "Time" from dual;[/syntax]
(Pisane z głowy)

Co do poradnika do już od jakiegoś czasu noszę się z tym aby go skończyć , ale jakoś nie mogę się zmusić do powtórnego zainstalowania Oracle

Statystyki: Napisane przez Malutki_27 — 20 maja 2014, o 22:35

Re: SQL - ORACLE

2014-05-20T20:27:16+01:00

Dzięki wielkie za odpowiedź!
Nie było innej możliwości i po prostu zamiast osobnych kolumn "data" i "godzina", mam kolumnę "czas" typu TIMESTAMP
Pozdrawiam!

Statystyki: Napisane przez DonieQ — 20 maja 2014, o 20:27

Re: SQL - ORACLE

2014-05-18T14:12:16+01:00

Jeżeli chodzi o Oracle to niestety nie występuje typ Time znany o ile mnie pamięć nie myli w MySql.

Co do przechowywania godziny , bo domniemam że o nią chodzi , to masz dwie możliwości albo użyć typu Date który także ma możliwość przechowywania czasu oprócz daty. I osobiście chyba poszedłbym w tym kierunku.
Druga możliwość to przechowywanie czasu jako varchar2 ale taki sposób tworzy raczej więcej problemów niż to jest warte
I oczywiście pozostaje ci także tym timestamp który przechowuje dokładnie to samo co typ date ale robi to bardziej dokładnie.

Statystyki: Napisane przez Malutki_27 — 18 maja 2014, o 14:12

Re: SQL - ORACLE

2014-05-18T01:59:17+01:00

Witam! Mam problem z datą, a dokładniej nie da się w tworzonej tabeli dać typu TIME, wyskakuje błąd "invalid datatype" bardzo proszę o dokończenie wątku, bo akurat na datach stanęło Z góry dziękuję za odpowiedź!

Statystyki: Napisane przez DonieQ — 18 maja 2014, o 01:59

Re: SQL - ORACLE

2013-09-27T14:57:09+01:00

Tym razem zajmieny się funkcjami skalarnymi związanymi z liczbami, tekstem, datami, porównującymi, konwersji i co tam jeszcze wymyślono.
Radzę się dobrze z nimi zapoznać, bo według mnie to własnie one są istotą baz danych

Hmmm ... może zacznijmy od tych co znają wszyscy

Trunc(p1,p2) - definicja mówi że obcina liczbę p1 do p2 miejsc po przecinku, co nie do końca jest prawdą

Weźmy sobie przykład który jest nie jako przełożeniem definicji
[syntax=sql]SELECT Trunc(112.123456,3) AS trunc FROM dual;[/syntax]
Działa jak powiedzieli ale sprawdździe co się stanie jeśli obetniecie tą liczbę np: do -2 czy do -3
Wniosek jest jeden, można można obcinać cześci ułamkowe, ale też dziesiątki, setki itd...

Round(p1,p2) - zaokrągla liczbę p1, do p2 miejsc (specjalnie nie napisałem "miejsc dzisiętnych" bo z zaokrągleniami sytuacja jest analogiczna co w TRUNC)
[syntax=sql]SELECT round(112.123456,2) AS trunc FROM dual;[/syntax]

MOD(p1,p2) - zwraca resztę z dzielania całkowitego p1 przez p2

Przykład
[syntax=sql]SELECT Mod(14589,5)AS mod FROM dual;[/syntax]

I bardziej pokręcony przykład(Wybieramy co piąty wiersz z tabeli elementy):
[syntax=sql]SELECT *
FROM (
SELECT ROWNUM AS lp,
p.*
FROM elementy p) tab
WHERE Mod( lp , 5 ) = 0;[/syntax]

ABS(p1) - zwraca wartość bezwzględną liczby

[syntax=sql]SELECT ABS(14) AS DODATNIA,
ABS(-14) AS UJEMNA
FROM dual;[/syntax]

SIGN(p1) - zwarca znak liczby, przy dodatniej wynikiem będzie 1, przy ujemnej wynikiem będzie -1

[syntax=sql]SELECT SIGN(14) AS DODATNIA,
SIGN(0) AS ZEROWA,
SIGN(-14) AS UJEMNA
FROM dual;[/syntax]

SQRT(p1) - zwraca pierwiastek kwadratowy z liczby p1

[syntax=sql]SELECT Sqrt(9) AS Sqrt FROM dual;[/syntax]
A właśnie, pierwiastek kwadratowy możemy obliczyć bo mamy do tego opdowiednią funkcję, a jak obliczyć dowolnego stopnia ? o tym za chwilę

POWER(p1,p2) - zwraca liczbę p1 podniesioną do potęgi p2

[syntax=sql]SELECT Power(10,3) AS Potega FROM dual;[/syntax]

A teraz pierwisatek dowolnego stopnia
[syntax=sql]SELECT Power(Power(10,3),1/3) AS "Pierwiastek dowolnego stopnia" FROM dual;[/syntax]
Dlaczego tak ? Bo przecież pierwiastek jest odwrotnością potęgi więc po co wymyślać jakąś dodatkową funkcje

Jednak jak już uruchomimy to zapytanie to sie okaże że wynik jest jakis dziwny (ci co odpalili zapytanie wiedzą o czym mówię), a ja zapewniam was że wynik jest prawidłowy z punktu widzenia programowania i pozwólcie
że tym razem nie wyjaśnie dlaczego tak się dzieje, niech to będzie hmmm.... wasze zadanie domowe
Powiem tylko tyle że dosyć często ten bardzo boli programostów nie tylko w sql ale wszędzie gdzie się używa liczb w programach.

No dobra z cyferkami już skończyliśmy teraz czas wziąc się za tekst.

Na początek weżmy pod lupę trzy funkcje, są nimi:

UPPER(ciąg_znaków) - ZMIENIA WSZYSTKIE LITERY NA DUŻE
LOWER(ciąg_znaków) - zmienia wszytskie litery na małe
INITCAP(ciąg_znaków) - Pierwsza Litera Każdego Wyrazu Jest Z Dużej Litery

Hehehe no to załatwimy te trzy funkcje jednym przykładem
[syntax=sql]SELECT opis AS "Nie zmieniony",
Upper(opis) AS "WSZYSTKIE DUŻE",
Lower(opis) AS "wszystkie małe",
InitCap(opis) AS "Pierwsza Litera Z Dużej"
FROM projekty;[/syntax]

No może jeszcze jednym ale ten będzie bardziej praktyczny, taka trochę inna forma DISTINCT
[syntax=sql]SELECT Upper(producent) AS Producent
FROM elementy
GROUP BY Upper(producent);[/syntax]

Skoro już wywołaliśmy DISTINCT do tablicy to czemu nie użyć
[syntax=sql]SELECT DISTINCT Upper(producent) AS Producenci FROM elementy;[/syntax]

Dobrze jak się już pobawiliśmy, to jedziemy dalej.

Następne w kolejce są LPAD i RPAD.
LPAD (ciąg_znaków,p1[,ciąg_znaków_2]) - wynikiem tej funkcji jest ciąg znaków o długości p1 który zostaje utworzony przez dodatnie z lewej strony znaków z ciągu_znaków_2.
Jeżeli ciąg ten nie zostanie zdefinowany wtedy zostaną użyte spacje.
LPAD (ciąg_znaków,p1[,ciąg_znaków_2]) - ta samo historia co z LPAD tylko wszytsko się dzieje po prawej stronie

[syntax=sql]SELECT ID,
LPad(id,20,'0') AS "Uzupełnienie z lewej",
RPad(id,20,'0') AS "Uzupełnienie z prawej"
FROM autorzy;[/syntax]

Dalej mamy LTRIM i RTRIM które są dokładnie odwrotnością LPAD oraz RPAD, mają postać

LTRIM(ciąg_znaków[,ciąg_znaków_2]) - usuwa z ciąg_znaków z lewej strony znaki zawarte w ciąg_znaków_2
RTRIM(ciąg_znaków[,ciąg_znaków_2]) - to samo co wyżej tylko że po prawej stronie
I dla obydwóch przypadków jeżeli nie wymienimy ciąg_znaków_2 to domyślnie będą usuwane spacje.

[syntax=sql]SELECT ID,
LTrim(LPad(id,20,'0'),'0') AS "Obcięcie z lewej",
RTrim(RPad(id,20,'0'),'0') AS "Obcięcie z prawej"
FROM projekty;[/syntax]
Ciekawe kto zauważy co z tym zapytaniem jest nie tak

Dobrze, to pozostały nam jeszcze:

SUBSTR(ciąg_znaków,p1[,p2]) - wybiera z ciąg_znaków, p2 znaków od pozycji p1 , w przypadku braku p2 wybiera zanki do końca(ale prąbana definicja)
W praktyce to jest tak, podajesz pozycję od której ma pobierać znaki i ile znaków ma pobrać, co w praktyce wygląda tak:
[syntax=sql]SELECT opis,
substr(opis,2,5) AS "Fragment tekstu",
substr(opis,2) AS "Od znaku do końca"
FROM projekty;[/syntax]

INSTR(ciąg_znaków,ciąg_znaków_2[,p1,p2]) - Szuka p2-wystąpienia ciąg_znaków_2 w ciągu_znaków od pozycji p1. Domyślnie p1 i p2 mają wartość 1.
W praktyce podaje nam pozycję na której znajduje się początek ciągu znaków.
[syntax=sql]SELECT opis,
InStr(opis,'ray',5) AS "Fragment tekstu"
FROM projekty[/syntax]

LENGTH(ciąg_znaków) - zwarca długość ciągu znaków
[syntax=sql]SELECT opis , Length(opis) AS "długość opisu" FROM projekty;[/syntax]

REPLACE(ciąg_znaków,ciąg_znaków_2[,ciąg_znaków_3]) - zmienia wszytskie wystąpienia ciąg_znaków_2 w ciąg_znaków na ciąg_znaków_3, wprzypadku braku ciąg_znakó_3 wstawia pusty znak czi nic
[syntax=sql]SELECT opis, REPLACE(opis,'Zasil',' AAAAAAAAA ') FROM projekty;[/syntax]

TRANSLATE(ciąg_znaków,ciąg_znaków_2,ciąg_znaków_3) - zmienia ciąg_znaków_2 na ciąg_znaków_3 w ciąg_znaków
A po ludzku, można napisać tak, że np: ciąg_znaków_2 = "ABC" natomiast ciąg_znaków_2 = "123" to A zostanie zastąpine przez 1, B przez 2, C przez 3
[syntax=sql]SELECT opis,
Translate(opis,'stab','STAB') AS "s = S, t = T, a = A, b = B",
Translate(opis,'P','8') AS "P = 8",
Translate(opis,'aL','WX') AS "a = W, L = X"
FROM projekty;[/syntax]
No dobra i chyba na tym etapie zakończymy poznawanie funkcji tekstowych, pozostaje nam jeszcze zabawa z datami, ale o tym napiszę już innym razem.

Statystyki: Napisane przez Malutki_27 — 27 wrz 2013, o 14:57

Re: SQL - ORACLE

2013-09-27T11:28:28+01:00

SELEKCJA

A cóż to takiego ?
Jest to wyświetlenie a raczej ograniczanie zapytania tylko do tych wierszy które spełniają określony warunek lub warunki, natomiast pozostałe zostają odfiltrowane.
Warunek selekcji może przyjąć jedną z trzech możliwych wartości, są nimi:
- true - wiersz jest zwracany jako wynik
- false - wiersz jest pomijany
- null - wiersz jest pomijany

Do utworzenia warunku selekcji wykorzystujemy operatory:
- porównań
- Dopasowania wzorca
- Logiczne
- Sprawdzenia wartości null

Co to dla nas oznacza ?
W praktyce oznacza to tylko tyle że na podstawie określonych warunków logicznych możemy wyselekcjonować sobie te wiersze które nas interesują.
Ponieważ tutaj sprawa jest prosta to pokażę kilka przykładów zamiast się rozpisywać

Wyświetla wszystkie elementy z lokalizacji 10
[syntax=sql]SELECT * FROM elementy WHERE lokalizacja_id=10;[/syntax]

Wyświetla wszystkie elementy z lokalizacji 11 które mają ilość wiekszą niż 30
[syntax=sql]SELECT * FROM elementy WHERE ilosc > 30 AND lokalizacja_id = 11;[/syntax]

Wyświetla wszystkie elementy które mają pustą kolumnę Producent
[syntax=sql]SELECT * FROM elementy WHERE producent IS null;[/syntax]
Tutaj podam jeszcze błędne zapytanie które nie generuje błędu ale wyświetla zły wynik
[syntax=sql]SELECT * FROM elementy WHERE producent = '';[/syntax]
Dlaczego tak się dzieje ? Dlatego że pusty ciąg znaków nie jest wartością null ponieważ null jest równocześnie pusty ale też nie pusty znaczy się taki nie wiadomo jaki.

Wyświetla wszystkie elementy które moją wypełnioną kolumnę Producent
[syntax=sql]SELECT * FROM elementy WHERE producent IS NOT null;[/syntax]

Teraz zajmiemy się operatorem dopasowania LIKE

Dzięki temu operatorowi który ma możliwość przyjęcia w swojej składni tzw. znaków specjalnych % (zastępuje dowolny ciąg znaków) oraz _ (zastępuje pojedynczy znak),
które umożliwiają nam elastyczniejsze podejście do wartości tekstowych podczas filtrowania. Podczas używania LIKE należy pamiętać że wielkość liter ma znaczenie.

[syntax=sql]SELECT * FROM elementy WHERE kod LIKE 'REZ%';[/syntax]

[syntax=sql]SELECT * FROM elementy WHERE Producent LIKE 'SE_KA';[/syntax]

SORTOWANIE

Czasami do prawidłowej prezentacji wyników potrzebne jest nam sortowanie. Okazuje się że taki mechanizm jest wbudowany w sql i ma następującą składnie:

SELECT ... FROM tabela ORDER BY kolumna [ASC | DESC]{,kolumna [ASC | DESC]}

W praktyce użycie tej składni wygląda tak:

[syntax=sql]SELECT * FROM Projekty ORDER BY autor_id ASC, KOD DESC;[/syntax]

Przy sortowaniu należy zwrócić uwagę na kolejność kolumn wymienionych za ORDER BY dlatego że sortowanie będzie się odbywało od lewej do prawej.
Czyli w przypadku jak wyżej, najpierw tabela zostanie posortowana według ID autora, następnie "wewnątrz" danego autora odbędzie się sortowanie projektów według ich kodu

ORDER BY umożliwia nam odwołanie się także po numerze kolumny zamiast po nazwie
[syntax=sql]SELECT * FROM Projekty ORDER BY 4 ASC;[/syntax]

oraz po aliasie kolumny
[syntax=sql]SELECT imie AS IM ,nazwisko AS NAZW FROM autorzy ORDER BY IM ASC;[/syntax]

Należy wspomnieć że nie wymienienie kierunku sortowania skutkuje sortowaniem rosnącym.

PSEUDOKOLUMNY

Najkrócej można by powiedzieć że to taka kolumna którą można wykorzystać w zapytaniu i której wartość jest generowana podczas wykonywania zapytania.
Do takich kolumn należą np:
- ROWNUM
- ROWID
- LEVEL

Na pierwszy ogień weźmiemy ROWNUM, jak sama nazwa wskazuje służy do numeracji wierszy które są wyświetlane w wyniku zapytania.

Jak zwykle przykład wykorzystania
[syntax=sql]SELECT ROWNUM AS lp ,
p.*
FROM projekty p
WHERE autor_id = 1;[/syntax]

Jak wynika z zapytania, wybraliśmy rekordy z tabeli projekty dla autora o id = 1 następnie tym wierszom nadaliśmy liczbę porządkową za pomocą ROWNUM.

Prawda że proste , jednak nie ma róży bez kolców, i tak jest w tym przypadku. Dodajmy do naszego zapytania sortowanie po kolumnie KOD.
[syntax=sql]SELECT ROWNUM AS lp ,
p.*
FROM projekty p
WHERE autor_id = 1
ORDER BY kod;[/syntax]

I co się okazuje że naszą LP szlag trafił , dzieje się tak z kolejności wykonywania poszczególnych składowych zapytania gdzie ROWNUM niestety jest gdzieś po środku, a dokładnie rzecz biorąc jest wykonywane
za przefiltrowaniem rekordów (klauzula WHERE), a sortowaniem (ORDER BY).

No to co teraz ? To znaczy że nie da się użyć ROWNUM ? A jak je użyjemy to nie można sortować ?
Otóż i na to jest rozwiązanie, co prawda troszkę na "okrętkę", ale się da , pomocą przychodzą nam tzw. podzapytania.
Tutaj należy wam się małe wyjaśnienie co to podzapytanie, otóż jest to nic innego jak zapytanie które podstawiamy w nawiasach zamiast tabeli za klauzulą from. Pisząc to jeszcze prościej, jest to "wirtualna tabela" stworzona z naszego zapytania.

A teraz przykład użycia takiego podzapytania razem z naszą pseudo kolumną
[syntax=sql]SELECT ROWNUM AS lp,
p.*
FROM ( SELECT * FROM projekty
WHERE autor_id = 1
ORDER BY kod) p;[/syntax]

Dało się ? Dało

Hmmm ... można zadać pytanie czy ROWNUM tylko do tego służy ? Otóż nie ..., ROWNUM można także użyć do limitowania wierszy.
Jeżeli np. chcemy aby nasze zapytanie w wyniku zwróciło pierwsze trzy wiersze to wystarczy skonstruować odpowiedni warunek WHERE co macie pokazane w kodzie poniżej.
[syntax=sql]SELECT ROWNUM AS lp,
p.*
FROM projekty p
WHERE autor_id=1 AND ROWNUM <= 3;
[/synatx]

Hehehee , ale jak to zwykle bywa i tutaj czyha na nas jakaś pułapka ;) . Spróbujcie wybrać np. drugi wiersz z zapytania, albo wszystkie wiersze które mają wartość rownum większą od 3 na podstawie kodu który podałem wyżej.

No i co ? Nie dało się :( , a dzieje się tak dlatego że w momencie nadania wartości dla ROWNUM jest sprawdzany warunek WHERE dla tej kolumny gdzie wartość będzie zawsze jeden.
To jak sobie z tym poradzić ? No jak to jak .... trzeba znowu użyć podzapytania :P
[syntax=sql]
SELECT * FROM (SELECT ROWNUM AS lp,
p.*
FROM projekty p
WHERE autor_id=1)
WHERE lp > 3;[/syntax]

No dobra poznaliście już użyteczne ROWNUM, to teraz by wypadało opisać ROWID, ale musze się przyznać szczerze że nie bardzo ma pomysł jak to ładnie opisać
Więc na razie napiszę że teoretycznie rowid można użyć jako kluczy głównych w tabelach ponieważ rowid jest znacznie szybsze od dedykowanych kolumn z kluczami głównymi ponieważ rowid fizycznie identyfikuje poszczególne wiersze w bazie danych i może na tą chwile poprzestańmy na tym.

Ok to teraz czas na LEVEL.
Wyobraźmy sobie że mamy tabelę która ma odwołanie (klucz obcy) do samej siebie, w Naszej bazie taką tabelą jest "Lokalizacje", gdzie przechowujemy strukturę naszych magazynów które są wyposażone w regały, a one z kolei mają półki.

Moglibyśmy zapisać te dane w postaci kolumn, gdzie każda następna kolumna byłaby odpowiednikiem naszej półki w regale, pół biedy jak by jeszcze te regały miały taką samą długość i ilość półek, ale już totalną masakrą miały różną ilość (tych półek).
Nie wspomnę już nawet o tym że do dyspozycji mamy ograniczoną ilość kolumn która może się nam skończyć. Wiec co zrobić ?
No skoro nie opłaca się iść wszerz to może pójść wzdłuż, czyli zapisać dane w postaci hierarchicznej wiersz po wierszu, czyli element podrzędny (półka) będzie przechowywał id elementu nadrzędnego (regał) a ten z kolei id swojego elementu nadrzędnego (magazyn).
Jak pewnie zauważyliście taką hierarchię można rozbudowywać w dół do dowolnego poziomu jaki nam będzie potrzebny. No tak ale jak teraz sprawdzić który jest tym ostatnim ? I tu z pomocą przychodzi nam właśnie wspomniana wcześniej pseudo kolumna LEVEL która nam grzecznie poda numer poziomu dla danej gałęzi

Oto przykład kodu
[syntax=sql]SELECT
ID,
super,
Kod,
Nazwa,
LEVEL AS "Poziom w hierarchii"
FROM lokalizacje
CONNECT BY PRIOR
id=super
START WITH super IS NULL
ORDER BY level;[/syntax]

Co prawda składnia jest deczko skomplikowana , ale na szczęście jest tak tylko na pierwszy rzut oka

Składni od SELECT do FROM nie ma co wyjaśniać więc zacznijmy od razu od CONNECT BY PRIOR, jest to nic innego jak podanie złączenia pomiędzy poziomami naszych lokalizacji (czyli łączymy np. magazyn z jego regałami, a regały z półkami)

START WITH super IS NULL - jest to nic innego jak podanie od którego poziomu ma się rozpocząć łączenie. W naszym przypadku jest to wartość null ponieważ nasze magazyny w hierarchii nie mają już nic nad sobą więc nie mają także przypisanego "rodzica".

Należy pamiętać że zamiast wartości null możemy przyporządkować dowolny "poziom" od którego chcemy zacząć np. od magazynu części
[syntax=sql]SELECT
ID,
super,
Kod,
Nazwa,
LEVEL AS "Poziom w hierarchii"
FROM lokalizacje
CONNECT BY PRIOR
id=super
START WITH super = (SELECT id FROM lokalizacje WHERE kod='MAG1')
ORDER BY level;[/syntax]

albo magazynu projektów
[syntax=sql]SELECT
ID,
super,
Kod,
Nazwa,
LEVEL AS "Poziom w hierarchii"
FROM lokalizacje
CONNECT BY PRIOR
id=super
START WITH super = 2
ORDER BY level;[/syntax]

Uhhh ..... , no to pozostała nam do omówienia jeszcze jedna rzecz o której nic nie pisałem, a bez której chyba by nie istniał Oracle

Jest nią bardzo użyteczna tabela dual. Jak się dało zauważyć podczas moich wypocin na temat operatorów arytmetycznych, użyliśmy takiego zapytania
[syntax=sql]SELECT 100 - 9 * 5 / 3 + 15 AS "Wynik" FROM autorzy;[/syntax]

w rezultacie otrzymaliśmy wynik naszych obliczeń, ale zamiast w jednym wierszu, był on widoczny aż w 8. Dlaczego tak się dzieje ? Dlatego że nasz wynik był generowany dla każdego wiersza który jest w tabeli.
No dobrze, a jak byśmy chcieli żeby w jednym wierszu, to co zrobić ? Użyć do tego tabeli dual;
[syntax=sql]SELECT 100 - 9 * 5 / 3 + 15 AS "Wynik" FROM dual;[/syntax]

No ok ... ale dlaczego tak jest ? Dlatego że tak sobie wymyślili twórcy Oracle, że jak w zapytaniu jest SELECT to musi być też informacja skąd wziąć nasze rekordy co oznacza obowiązkową klauzule FROM, skoro już napisaliśmy FROM no to musimy tez podać jakieś źródło rekordów.
Co w oczywisty sposób utrudniło pewne operacje w bazie, dlatego mądrzy ludzie poszli po rozum do głowy i stworzyli tabelę dual
Sama tabela dual nie jest niczym nadzwyczajnym, jest to po prostu tabela która zawiera jedną kolumnę i jeden wiersz w którym jest wpisany "X"

Statystyki: Napisane przez Malutki_27 — 27 wrz 2013, o 11:28

Re: SQL - ORACLE

2013-09-25T12:42:23+01:00

Kolej na następna część

Ale zanim przejdziemy do meritum potrzeba nam będzie jakaś baza danych, dlatego otwórzcie SQLTOOLS, podłączcie się do bazy i odpalcie przez F5
ten skrypt:
[syntax=sql]DROP TABLE dzialy;
CREATE TABLE dzialy(
ID INTEGER NOT null,
KOD VARCHAR2(20) NOT null,
OPIS VARCHAR2(150),
CONSTRAINT dzialy_pk PRIMARY KEY(ID),
CONSTRAINT dzialy_uk UNIQUE(kod)
);

DROP SEQUENCE Dzialy_ID;
CREATE SEQUENCE Dzialy_ID;

INSERT INTO dzialy (ID, KOD, OPIS)
VALUES (dzialy_id.NEXTVAL, 'Rozwoj', 'Dział Rozwoju');
INSERT INTO dzialy (ID, KOD, OPIS)
VALUES (dzialy_id.NEXTVAL, 'Dystrybucja', 'Dział Dystrybucji projektów');
INSERT INTO dzialy (ID, KOD, OPIS)
VALUES (dzialy_id.NEXTVAL, 'Projekty', 'Dział PROJEKTOWY');
INSERT INTO dzialy (ID, KOD, OPIS)
VALUES (dzialy_id.NEXTVAL, 'Wdrażania', 'Dział odPOwiedzialny za WDROŻENIE PROJEKTÓW');

DROP TABLE Autorzy;
CREATE TABLE Autorzy (
ID INTEGER NOT NULL ,
IMIE VARCHAR2(20),
NAZWISKO VARCHAR2(100),
DZIAL INTEGER NOT NULL,
CONSTRAINT Autorzy_pk PRIMARY KEY(ID),
CONSTRAINT Autorzy_uk UNIQUE(IMIE,NAZWISKO)
);

DROP SEQUENCE Autorzy_ID;
CREATE SEQUENCE Autorzy_ID;

INSERT INTO Autorzy (ID,IMIE, NAZWISKO, DZIAL)
VALUES (Autorzy_ID.NEXTVAL, 'Jan', 'Kowalski',1 );
INSERT INTO Autorzy (ID,IMIE, NAZWISKO, DZIAL)
VALUES (Autorzy_ID.NEXTVAL, 'Wirgiliusz', 'IksIński',1 );
INSERT INTO Autorzy (ID,IMIE, NAZWISKO, DZIAL)
VALUES (Autorzy_ID.NEXTVAL, 'Bronisław', 'Kowalski',1 );
INSERT INTO Autorzy (ID,IMIE, NAZWISKO, DZIAL)
VALUES (Autorzy_ID.NEXTVAL, 'Jerzy', 'Nowak',2 );
INSERT INTO Autorzy (ID,IMIE, NAZWISKO, DZIAL)
VALUES (Autorzy_ID.NEXTVAL, 'Katarzyna', 'dąbrowska',2 );
INSERT INTO Autorzy (ID,IMIE, NAZWISKO, DZIAL)
VALUES (Autorzy_ID.NEXTVAL, 'Pelagiusz', 'Dombrowski',3 );
INSERT INTO Autorzy (ID,IMIE, NAZWISKO, DZIAL)
VALUES (Autorzy_ID.NEXTVAL, 'Jeremi', 'Pwosinoga',4 );
INSERT INTO Autorzy (ID,IMIE, NAZWISKO, DZIAL)
VALUES (Autorzy_ID.NEXTVAL, 'Jonasz', 'Waligóra',4 );

DROP TABLE Lokalizacje;
CREATE Table Lokalizacje (
ID INTEGER NOT null,
SUPER INTEGER,
KOD VARCHAR2(200),
Nazwa VARCHAR2(100),
CONSTRAINT Lokal_pk PRIMARY KEY(ID),
CONSTRAINT Lokal_local_fk FOREIGN KEY(SUPER) REFERENCES lokalizacje(ID),
CONSTRAINT Lokal_uk UNIQUE(kod,SUPER)
);

DROP SEQUENCE Lokalizacje_ID;
CREATE SEQUENCE Lokalizacje_ID;

INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,null,'MAG1','Magazyn Części');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,null,'MAG2','Magazyn Projektow');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,1,'REGPROC','Regał procesory');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,1,'REGREZ','Regał rezystory');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,1,'REGKON','Regał Kondensatory');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,2,'REGUKON','Regał z ukończonymi projektami');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,2,'REGTRW','Regał z trwającymi projektami');
INSERT INTO Lokalizacje (ID, SUPER, KOD)
VALUES (Lokalizacje_ID.NEXTVAL,2,'REGODRZ');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,3,'POLKA1','Półka dolna');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,3,'POLKA2','Półka środkowa');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,3,'POLKA3','Półka górna');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,4,'POLKA1','Półka dolna');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,4,'POLKA2','Półka środkowa');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,4,'POLKA3','Półka górna');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,5,'POLKA1','Półka dolna');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,5,'POLKA2','Półka środkowa');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,5,'POLKA3','Półka górna');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,6,'POLKA1','Półka dolna');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,6,'POLKA2','Półka środkowa');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,6,'POLKA3','Półka górna');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,7,'POLKA1','Półka dolna');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,7,'POLKA2','Półka środkowa');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,7,'POLKA3','Półka górna');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,8,'POLKA1','Półka dolna');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,8,'POLKA2','Półka środkowa');
INSERT INTO Lokalizacje (ID, SUPER, KOD, NAZWA)
VALUES (Lokalizacje_ID.NEXTVAL,8,'POLKA3','Półka górna');

DROP TABLE Elementy;
CREATE TABLE Elementy (
ID INTEGER NOT null,
KOD VARCHAR2(20),
OPIS VARCHAR2(200),
Ilosc NUMERIC(10,2),
Producent VARCHAR2(50),
lokalizacja_ID INTEGER NOT NULL,
CONSTRAINT Elementy_pk PRIMARY KEY(ID),
CONSTRAINT Elementy_local_fk FOREIGN KEY(lokalizacja_ID) REFERENCES lokalizacje(ID),
CONSTRAINT Elementy_uk UNIQUE(kod)
);

DROP SEQUENCE Elementy_ID;
CREATE SEQUENCE Elementy_ID;

INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'ATMEGA8','Procesor atemga 8',92,'Atmel',11);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'ATMEGA16','Procesor atemga 16',17,'atmel',11);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'ATMEGA32','Procesor atemga 32',6,'atMEL',9);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'ATMEGA328','Procesor atemga 328',32,'ATMEL',10);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'PIC16F627A','Procesor microchip PIC16F627A',78,'MICROCHIP',10);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'PIC16F887','Procesor MicrChip PIC16F887',69,'microchip',11);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'AT91SAM7XC512','Procesor ARM AT91SAM7XC512',12,null,9);

INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'REZ1.2K','Rezystor smt 1.2k',68,'ELEKTRON',12);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'REZ56K','Rezystor smd 56k',92,'eLEKTRON',12);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'REZ1.4M','Rezystor smt 1.4M',63,'Elektron',14);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'REZ12K','Rezystor smd 12k',76,'elektron',14);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'REZ22K','Rezystor smt 22k',4,'Restor',14);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'REZ120K','Rezystor smd 120k',136,'REstor',14);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'REZ12','Rezystor smd 12',56,'RESTOR',13);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'REZ56','Rezystor smt 56',59,null,12);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'REZ5.6M','Rezystor smd 5.6M',2,'Restor',13);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'REZ10K','Rezystor smt 10k',66,null,14);

INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'KON10UF','Kondensator 10uf',55,'SEIKA',15);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'KON10UP','Kondensator 10up',19,'MITra',15);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'KON22UF','Kondensator 22uf',37,'Seika',15);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'KON1UF','Kondensator 1uf',5,null,15);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'KON18PF','Kondensator 18pf',11,'seika',15);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'KON220UF','Kondensator 220uf',38,'mitra',16);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'KON15F','Kondensator 15f',72,'MITRA',16);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'KON1F','Kondensator 1f',30,null,16);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'KON100NF','Kondensator 100nf',19,'SEiKA',17);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'KON1.5UF','Kondensator 1.5uf',3,null,17);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'KON1.5NF','Kondensator 1.5nf',21,'mitra',17);
INSERT INTO elementy (ID,KOD,OPIS,ILOSC,PRODUCENT,LOKALIZACJA_ID)
VALUES (elementy_ID.NEXTVAL,'KON12PF','Kondensator 12pf',27,'Mitra',17);
/* */

DROP TABLE Projekty;
CREATE TABLE Projekty(
ID INTEGER NOT null,
KOD VARCHAR2(20) NOT null,
OPIS VARCHAR2(200),
DATA_PROJEKT DATE DEFAULT trunc(SYSDATE,'DDD'),
Autor_ID INTEGER NOT null,
Lokalizacja_ID INTEGER NOT NULL,
CONSTRAINT Projekty_pk PRIMARY KEY(ID),
CONSTRAINT Projekty_local_fk FOREIGN KEY(lokalizacja_ID) REFERENCES lokalizacje(ID),
CONSTRAINT Projekty_Autor_fk FOREIGN KEY(Autor_ID) REFERENCES Autorzy(ID),
CONSTRAINT Projekty_uk UNIQUE(kod)

);

DROP SEQUENCE Projekty_ID;
CREATE SEQUENCE Projekty_ID;

INSERT INTO projekty (ID, KOD, OPIS, DATA_PROJEKT, AUTOR_ID, LOKALIZACJA_ID)
VALUES (projekty_ID.NEXTVAL, 'ZASILACZSTAB', 'Zasilacz stabilizowany','2010/05/17',1,23);
INSERT INTO projekty (ID, KOD, OPIS, DATA_PROJEKT, AUTOR_ID, LOKALIZACJA_ID)
VALUES (projekty_ID.NEXTVAL, 'ZASILACZNSTAB', 'Zasilacz nie stabilizowany','2011/12/03',2,24);
INSERT INTO projekty (ID, KOD, OPIS, DATA_PROJEKT, AUTOR_ID, LOKALIZACJA_ID)
VALUES (projekty_ID.NEXTVAL, 'PRZETWORNICA', 'PRZETWORNICA NAPIĘCIA','2003/07/10',2,23);
INSERT INTO projekty (ID, KOD, OPIS, DATA_PROJEKT, AUTOR_ID, LOKALIZACJA_ID)
VALUES (projekty_ID.NEXTVAL, 'MRUGACZ', 'MRUGACZ diodowy','2008/01/29',4,26);
INSERT INTO projekty (ID, KOD, OPIS, DATA_PROJEKT, AUTOR_ID, LOKALIZACJA_ID)
VALUES (projekty_ID.NEXTVAL, 'PRZERYWACZ', 'PRZErywacz zapadkowy','2011/06/24',3,18);
INSERT INTO projekty (ID, KOD, OPIS, DATA_PROJEKT, AUTOR_ID, LOKALIZACJA_ID)
VALUES (projekty_ID.NEXTVAL, 'PEREPTUM', 'PERPETUM DEBI ... TFU MOBILE','2012/08/24',4,22);
INSERT INTO projekty (ID, KOD, OPIS, DATA_PROJEKT, AUTOR_ID, LOKALIZACJA_ID)
VALUES (projekty_ID.NEXTVAL, 'INTERFEjs', 'interfejs szeregowy','2003/06/09',5,20);
INSERT INTO projekty (ID, KOD, OPIS, DATA_PROJEKT, AUTOR_ID, LOKALIZACJA_ID)
VALUES (projekty_ID.NEXTVAL, 'LISTWA', 'LISTWA diodowa','2010/04/01',6,19);
INSERT INTO projekty (ID, KOD, OPIS, DATA_PROJEKT, AUTOR_ID, LOKALIZACJA_ID)
VALUES (projekty_ID.NEXTVAL, 'WysWIETLACZ', 'Wyswietlacz LCD','2013/02/07',8,18);
INSERT INTO projekty (ID, KOD, OPIS, DATA_PROJEKT, AUTOR_ID, LOKALIZACJA_ID)
VALUES (projekty_ID.NEXTVAL, 'DZWONEK', 'Dzwonek do drzwi','2005/09/22',1,19);
INSERT INTO projekty (ID, KOD, OPIS, DATA_PROJEKT, AUTOR_ID, LOKALIZACJA_ID)
VALUES (projekty_ID.NEXTVAL, 'MIERNIK', 'Miernik procesorowy','2009/11/06',6,26);
INSERT INTO projekty (ID, KOD, OPIS, DATA_PROJEKT, AUTOR_ID, LOKALIZACJA_ID)
VALUES (projekty_ID.NEXTVAL, 'UPS', 'Zasilacz awarayjny','2010/05/06',5,25);
INSERT INTO projekty (ID, KOD, OPIS, DATA_PROJEKT, AUTOR_ID, LOKALIZACJA_ID)
VALUES (projekty_ID.NEXTVAL, 'PILOT', 'Pilot daleKiego zasięgu','2011/08/10',2,26);
INSERT INTO projekty (ID, KOD, OPIS, DATA_PROJEKT, AUTOR_ID, LOKALIZACJA_ID)
VALUES (projekty_ID.NEXTVAL, 'TELEFON', 'TElefon','2010/05/17',1,24);
INSERT INTO projekty (ID, KOD, OPIS, DATA_PROJEKT, AUTOR_ID, LOKALIZACJA_ID)
VALUES (projekty_ID.NEXTVAL, 'CUBE', 'Kostka Świecąca','2004/02/18',1,22);
INSERT INTO projekty (ID, KOD, OPIS, DATA_PROJEKT, AUTOR_ID, LOKALIZACJA_ID)
VALUES (projekty_ID.NEXTVAL, 'ZEGAR', 'Zegar elektroniczny','2003/05/12',8,21);
INSERT INTO projekty (ID, KOD, OPIS, DATA_PROJEKT, AUTOR_ID, LOKALIZACJA_ID)
VALUES (projekty_ID.NEXTVAL, 'GLOBUS', 'globus DIODOWY','2012/12/12',8,20);
INSERT INTO projekty (ID, KOD, OPIS, DATA_PROJEKT, AUTOR_ID, LOKALIZACJA_ID)
VALUES (projekty_ID.NEXTVAL, 'DIODA', 'Migająca dioda','2007/09/08',1,18);

DROP TABLE Projekty_szcz;
CREATE TABLE Projekty_szcz(
ID INTEGER NOT null,
SUPER INTEGER,
Element_ID INTEGER NOT null,
Ilosc NUMERIC(10,2),
CONSTRAINT Projekty_szcz_pk PRIMARY KEY(ID),
CONSTRAINT Projekty_szcz_projekty_fk FOREIGN KEY(super) REFERENCES projekty(ID),
CONSTRAINT Projekty_szcz_elementy_fk FOREIGN KEY(Element_ID) REFERENCES Elementy(ID),
CONSTRAINT Projekty_szcz_ck CHECK (ilosc > 0)
);

DROP SEQUENCE Projekty_szcz_ID;
CREATE SEQUENCE Projekty_szcz_ID;

INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,1,3,20);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,17,27,38);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,2,27,28);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,9,16,47);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,15,27,47);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,8,3,83);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,4,16,51);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,6,20,43);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,9,12,80);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,8,6,24);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,7,21,75);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,5,12,73);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,13,26,3);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,18,19,93);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,13,2,85);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,14,5,30);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,18,29,4);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,9,16,50);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,11,23,61);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,7,21,17);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,3,13,26);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,11,2,36);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,9,22,43);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,4,18,44);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,11,11,36);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,2,20,4);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,4,19,9);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,17,18,90);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,4,6,90);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,2,5,9);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,10,4,57);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,16,3,89);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,15,9,65);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,7,29,78);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,9,23,2);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,17,22,38);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,14,15,91);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,11,28,7);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,16,1,52);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,9,20,22);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,14,20,28);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,9,9,58);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,1,20,20);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,8,23,92);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,10,19,8);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,2,29,46);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,1,2,22);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,7,14,76);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,18,16,93);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,4,18,92);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,17,14,90);
INSERT INTO projekty_szcz (ID,SUPER,ELEMENT_ID,ILOSC)
VALUES(projekty_szcz_ID.NEXTVAL,10,13,97);
COMMIT;[/syntax]

Dzisiaj troszkę opiszę instrukcję bez której nie istniał by żaden sql, a zwą ją SELECT.

Składnia instrukcji wygląda tak:

Wygląda groźnie, ale nie martwcie się w rzeczywistości jest prosta jak drut.
Hmmm... w tym momencie warto zadać sobie pytanie co ona właściwie robi ?
Ano jest opowiedzialna za "wyławaianie" interesujących nas infromacji z bazy danych, najprostszym przykładem użycia tej instrukcji jest listing jakiejś tabeli
[syntax=sql]select * from autorzy;[/syntax]
wciskamy F10.

I mamy pięknie wyświetloną zawartość tabeli autorzy.
A co zrobić żeby wyświetliły się tylko imię i nazwisko ?

Nic prostszego należy zamiast * wymienić tylko te kolumny które nas interesują, czyli piszemy:

[syntax=sql]SELECT imie, nazwisko FROM autorzy;[/syntax]
i wciskamy F10 , prawda że proste

Jednak tutaj zatrzymamy się na chwilkę żeby powiedzieć kilka oczywistych rzeczy o SQLTOOLS

Są trzy magiczne przyciski zaznaczone na czerwono które będziemy używać. W kolejności od lewej:
- "Wykonaj bierzący kod" (F10)
- "Wykonaj kod w krokach" (F11)
- "Wykonaj cały skrypt" (F5)

Jednak aby zadziałały prawidłowo, każdy blok kodu musi być zakończony średnikiem, jeżeli tego nie zrobimy to Oracle da nam po łapkach w postaci błędu
"ORA-00933: SQL command not properly ended"

Jak to wygląda w praktyce, wpiszcie poniższy kod to sprawdzimy
[syntax=sql]SELECT * FROM autorzy;
SELECT * FROM dzialy;
SELECT * FROM elementy;[/syntax]

Stawiając kursor w dowolnej linii i wciskając F10, wykona nam się tylko ten blok kodu w którym mamy postawiony kursor,
stawiając kursor w pierwszej linii i wciskając F11, zostanie wykonany blok kodu w którym jesteśmy i następnie kursor przejdzie do następnej linii ale nie wykona jej (przydatna funkcja przy debugowaniu),
natomiast F5 wykona cały skrypt czyli wszytko co mamy w pliku.

Dodatkowo należy wspomnieć że komentarz pojedyńczej linii osiągniemy przy pomocy
-- Komentarz
natomiast cały blok komentujemy jak w C czyli
/* To
jest
komentarz
blokowy */

Dobrze, podstawy obsługi programu mamy już za sobą , więc wróćmy do Oracle.
Skoro już znamy podstawową składnię dla select, czas przedstawić wam funkcję NVL.

NVL(arg1,arg2)

Funkcja ta przyjmuje dwa argumenty tego samego typu, czyli jeżeli sprawdzamy tekst, to drugi parametr też musi być tekstem i w wyniku też dostaniemy teskt.
Sama funkcja działa tak że jako pierwszy argument podajemy nazwę kolumny którą sprawdzamy i jeżeli okaże się że wartością null to zostanie wyświetlon zawartość drugiego argumentu.

W praktyce wygląda to tak:

zapytanie z null
[syntax=sql]SELECT kod, producent FROM elementy;[/syntax]
zapytanie z NVL + jakiś tekst
[syntax=sql]SELECT kod,Nvl(Producent,'BRAK PRODUCENTA') FROM elementy;[/syntax]
zaytanie z użyciem dwóch kolumn
[syntax=sql]SELECT kod,Nvl(Producent,kod) FROM elementy;[/syntax]

Przyglądając się jednak nazwom kolumn z ostatniego przykładu zauważymy że są jakieś "dziwne", więc wypadało by coś z tym zrobić.
Otóż w tym przypadku przychodza nam z pomoca aliasy

Poniżej macie zamieszczone 5 przykładów wykorzystania aliasów, należy zwrócić uwagę że do aliasów nie musi być wykorzystywane słowo AS, ale ja osobiście używam ponieważ przy dużych zapytaniach dla mnie kod jest bardziej przejrzysty.
Kolejną sprawą jest ignorowanie wielkości liter co pokazują kolumny 1 i 2. Aby temu zaradzić stosuje się cudzysłowy, stosuje się je także do wielowyrazowych nazw kolumn.
[syntax=sql]SELECT Nvl(Producent,kod) Producent,
Nvl(Producent,kod) AS Producent,
Nvl(Producent,kod) AS "Producent",
Nvl(Producent,kod) AS "Producent Elementu",
Nvl(Producent,kod) "Producent Elementu"
FROM elementy;[/syntax]

Na liście instrukcji SELECT są także inne cuda cudawianki jak na przykład operatory arytmetyczne, operator konkatenacji czy też funkcje wbudowane i na pierwszy ogień weżmiemy sobie operator konkatenacji.
Otóż jeżeli wyświetlimy imię i nazwisko z tabeli autorzy, to się okaże że są to dwie kolumny
[syntax=sql]SELECT imie, nazwisko FROM autorzy;[/syntax]
A my byśmy chcieli żeby zostały połączone w jedną kolumnę, to właśnie w takim przypadku przychodzi nam z pomocą operator konkatenacji który ma symbol ||
I oczywiście przykład użycia
[syntax=sql]SELECT imie AS "Imię",
nazwisko AS "Nazwisko",
imie||' '||nazwisko AS "Połączone Imię i Nazwisko"
FROM autorzy;[/syntax]

Należy jeszcze wspomnieć że operator ten wartość null traktuje jako pusty ciąg znaków.

Czas na operatory matematyczne + - * /
- jak wszyscy wiemy działają na liczbach
- mają takie same priorytety jak w regułach matematycznych
- nic nie stoi na przeszkodzie żeby stosowac nawiasy
- i [b]najważniejsze dla wartości null ZAWSZE zwracają null[\b]

[syntax=sql]SELECT 100 - 9 * 5 / 3 + 15 AS "Wynik" FROM autorzy;[/syntax]

Poniżej dodatkowo zamieszczam troszke bardziej rozbudowany kod obrazujący działeanie kilku funkcji, tylko na razie nie wnikajcie w pierwszą część kodu
Żeby nam się nie pomerdało otwórzcie nowy skrypt wklejcie kod który jest niżej i odpalcie F5
[syntax=sql]/* Na razie nie wnikajcie
o co chodzi w tym fragmencie kodu ;)
*/

CREATE TABLE PRZYKLADY_NVL(
ilosc INTEGER,
WARTOSC INTEGER
);

INSERT INTO PRZYKLADY_NVL
VALUES (10,null);

INSERT INTO PRZYKLADY_NVL
VALUES (10,4);
INSERT INTO PRZYKLADY_NVL
VALUES (2,17);

-- TUTAJ jest interesująca was część kodu --

SELECT ilosc,
wartosc,
ilosc * wartosc + 2 AS "Bez eliminacji wartości null",
Nvl(ilosc,0) * wartosc + 2 AS "Eliminacja jednego null",
Nvl(ilosc,0) * Nvl(wartosc,0) + 2 AS "Eliminacja obydwóch null"
FROM Przyklady_NVL;[/syntax]

Skoro już umiemy tak dużo, to warto sparwdzić co potrafi DISTINCT w instrukcji SELECT.
Zasada działania polega pokazaniu tylko tych rekordów które są unikatowe dla instrukcji SELECT. O co tu chodzi, najprościej chyba będzie wytłumaczyć na przykładzie.
Jeżeli wykonamy takie zapytanie
[syntax=sql]select nazwisko from autorzy;[/syntax]
to w rezultacie otzrymamy listę nazwisk (8 wierszy) występujących w tej kolumnie łącznie z tymi powtarzającymi się, jak zwrócicie uwagę jest tam dwóch Kowalskich, a my przecież
chcemy otrzymać listę nazwisk bez powtórzeń i tu z pomocą przychodzi nam właśnie distinct które "wyeliminuje" nam tego jednego Kowalskiego ...
[syntax=sql]SELECT DISTINCT nazwisko FROM autorzy;[/syntax]

Należy jednak pamiętać że distinct działa dla kombinacji wszystkich kolumn występujących w zapytaniu dlatego gdybyśmy dodali do zapytania kolumnę IMIE to DISTINCT na pierwszy rzut oka nie zadziała,
i byli byśmy w błędzie ponieważ ono zadziałało, tylko że para kolumn NAZWISKO oraz IMIE nie tworzy unikalnej kombinacji

Kolejną sprawą o której warto wiedzieć to, to że DISTINCT rozróżnia wielkości znaków i wartość "MITra" nie będzie tym samym co "mitra",
natomiast wartość null w tym przypadku (traktować jak wyjątek od reguły bo przecież nie wiadomo co nie może być niewiadomo czym ) zostanie potraktowana jako taka sama wartość i zostanie zgrupowana.
I oczywiście przykłady:
Bez DISTINCT:
[syntax=sql]SELECT Producent from elementy;[/syntax]
Z DISTINCT:
[syntax=sql]SELECT DISTINCT Producent from elementy;[/syntax]

Ufff na tym na razie skończymy

Statystyki: Napisane przez Malutki_27 — 25 wrz 2013, o 12:42

Re: SQL - ORACLE

2013-09-24T11:56:04+01:00

No dobra, chyba przyszedł czas żeby trochę po przynudzać

Więc będzie trochę definicji

SQL - ang. Structured Query Language jest to nic innego jak strukturalny język używany do tworzenia,modyfikowania baz danych oraz do umieszczania i pobierania danych z tych baz.

Podstawowymi cechami SQL są:

- jest językiem wysokiego poziomu (językiem czwartej generacji – 4GL), opartym na słownictwie języka angielskiego, jego wyrażenia mają określoną strukturę,
- tym niemniej, jak większość nowoczesnych języków ma dość swobodny format, tzn. iż poszczególne fragmenty poleceń nie muszą być umieszczane w określanych miejscach,
- jest językiem deklaratywnym (nieproceduralnym), zorientowanym na wynik (użytkownik definiuje, co chce otrzymać, ale nie pisze jak), inaczej mówiąc, SQL nie potrzebuje zatem podawania przez użytkownika dokładnego sposobu dostępu do danych i sposobu przetwarzania danych,
- jest oparty na algebrze relacji,
- zawiera logikę trójwartościową,
- nie posiada instrukcji sterujących wykonywaniem programu,
- nie dopuszcza rekurencji,
- umożliwia definiowanie struktur danych, wyszukiwanie danych oraz operacje na danych,
- działa na zbiorach danych.

Do podstawowych komponentów języka SQL należą :

- DDL (Data Definition Language)
polecenia:
- CREATE - tworzenie tabel, baz danych itd.
- ALTER - modyfikacja tego co powyżej
- DROP - usuwanie j.w.
- TRUNCATE - usuwa rekordy z tabeli
Wykonanie któregoś z powyższych poleceń jest nie odwracalne, oznacza że polecenia nie da się cofnąć.

- DQL (Data Query Language)
polecenia:
- SELECT - wyświetlanie rekordów
Tym poleceniem nie da się nic popsuć

- DML (Data Manipulation Language)
polecenia:
- INSERT - wstawianie rekordów do tabel
- UPDATE - aktualizacja rekordów
- DELETE - usuwanie rekordów
Co tu dużo pisać, opisy mówią same za siebie

- DCL (Data Control Language)
polecenia:
- GRANT - służy do nadawania uprawnień
- REVOKE - odbiera uprawnienia
- DENY - Zabrania wykonywania operacji
- COMMIT - zatwierdzanie zmian wprowadzonych przez DML
- ROLLBACK - cofanie zmian wprowadzonych przez DML

Skoro parę regułek mamy już za sobą to warto by wsponieć o typach danych.

Jest ich kilka:
- CHAR(n) - typ tekstowy o stałej długości n znaków
- VARCHAR(n) – typ tekstowy o zmiennej maksymalnej długości n znaków
- VARCHAR2(n) - to samo co wyżej tylko zoptymalizowany, i zalecany przez Oracle
- INTEGER – typ całkowitoliczbowy
- NUMERIC(p,s) – typ liczbowy przechowujący wartości rzeczywiste o określonej precyzji (p) i skali (s).
Precyzja oznacza ilość przechowywanych cyfr liczby, a skala ilość przechowywanych cyfr po przecinku.
Przykładowo NUMERIC(6,2) przechowuje liczbę o długości 6 cyfr, w tym 2 cyfry na cześć ułamkowa.
- FLOAT – typ rzeczywisty o pojedynczej precyzji
- DOUBLE – typ rzeczywisty o podwójnej precyzji
- BLOB – dane binarne
- CLOB – dane tekstowe o dużym rozmiarze
- DATE – data
- TIME – czas
- TIMESTAMP – data+czas

Jak już znamy typy danych warto by też poznać operatory którymi się będziemy posługiwać, a jest ich kilka rodzajów
i pozwolicie że nie będę ich opisywał

Porównania:
= != <> > < >= <=

arytmetyczne:
+ - * /

konkatenacji (łączenie dwóch wartości tekstowych)
||

do określania zakresów
[NOT] BEETWEN ... AND ...
[NOT] IN (...,...,...)

do określania wzorców:
[NOT] LIKE

logiczne:
AND OR NOT

do testowania wartości pustych:
IS [NOT] NULL

W tym miejscu warto wspomnieć że null nigdy nie równa się null więc warunek null=null nigdy nie będzie prawdziwy.
Dlatego należy zapamiętać to stwierdzenie -> niewiadomo co nidy nie będzie równe niewiadomo czemu

OK, operatory mamy już za sobą, więc jeszcze tylko tablice prawdy i już daje wam spokój (warto zwrócić uwagę jak zachowuje się null)

Na dziś wystarczy

Statystyki: Napisane przez Malutki_27 — 24 wrz 2013, o 11:56

SQL - ORACLE

2013-09-23T13:37:17+01:00

Wszelkie komentarze lub zachwyty (o ile będą ) umieszczajcie w tym ...wątku

Skasowane, po co tworzysz na zapas temat? Będzie potrzeba to rozwinie się dyskusja - Różowy J.

Chyba już przyszedł czas żeby powiedzieć coś o takim tworze jak sql, który pewnie kilku osobom się przyda
Jednak żeby nie było zbyt różowo do zabawy wybrałem coś takiego co się nazywa: ORACLE Database 11g XE.
Jest to wersja darmowa do zastosowań domowych i o ile się nie mylę także komercyjnych. Sam serwer ma kilka ograniczeń ( zresztą tak samo jak MSSQL w wersji express)
w postaci ograniczenia w ilości użytkowanej pamięci, wielkości bazy danych (11GB - i niech ktoś powie że dla niego za mało, to poproszę Suna albo różowego o przycięcie ilości pigułek )
oraz ilości używanych procesorów.

Jeszcze może słowo wyjaśnienia dlaczego dlaczego Oracle, ano dlatego:
- że każdy się go boi
- że jest prosty
- że jest inny
- że nikt go nie używa do zastosowań amatorskich
- że że .. że .. że ( ten argument mi się podoba najbardziej )
- i najważniejsze dawno nic w nim nie robiłem więc warto sobie przypomnieć podstawy

Zresztą generalnie sam sql na różnych serwerach tak bardzo się nie różni, oczywiście są pewne niuanse i nie konsekwencje w implementacji
składni sql czy też T-SQL ale to już inna bajka.

To by było na tyle tytułem wstępu, warto by przystąpić do instalacji tego tworu na komputerze, która zresztą nie obędzie się bez małych perturbacji, więc proszę w miarę uważnie czytać

Na początek musimy sobie zorganizować dwie instalki, jedną jest sam serwer, a drugą narzędzie SQLTOOLS które posłuży nam do pisania skryptów sql.

Serwer Oracle ściągamy z tej lokalizacji

Akceptujemy licencję i ściągamy wersję Oracle Database Express Edition 11g Release 2 for Windows x32
żeby nie było niespodzianek trzeba się zarejestrować co oczywiście niczym nie grozi (Chyba tylko tym że będą mieli nasze dane o ile poda ktoś prawdziwe )

Następnie zaglądamy do działu Download na stronie SQLTOOLS i zasysamy pakiet SQLTools 1.6 build 15 (from SourceForge)

Skoro mamy już te dwie instalki to czas się zabrać do roboty.
Rozpakowujemy do jakieś folderu instalację Oracle i odpalamy setup.exe
Naszym oczom pojawi się takie okienko gdzie klikamy next

Następnie akceptujemy licencję i klikamy next

Dalej się nas pytają co chcemy zainstalować (raczej dużego wyboru nie ma ) no i oczywiście gdzie ma być zainstalowane,
jak juz z tym się uporamy to klikamy next

Następnie naszym oczom ukaże się okienko o wprowadzenie hasła administratora serwera więc je wprowadzamy w drugim okienku potwierdzamy
i klikamy next.

A teraz się założę że nikt nie spojrzał jak te konta się nazywają
Dla przypomnienia napiszę że SYS oraz SYSTEM jest to o tyle ważne że jeżeli nie zapamiętacie tego to będą problemy z zarządzaniem serwera

No dobra teraz wyskoczy nam okienko z podsumowaniem instalacji, numerami portów na których nasłuchuje serwer itd.

Przy okazji nie zdziwcie się jak wyskoczy wam coś takiego

Pod żadnym pozorem nie klikajcie ok bo właśnie w tej chwili zajmiemy sie tym błędem.

Otwieramy explorator windows i idziemy do ścieżki którą wskazał nam komunikat.
Następnie odnajdujemy plik o nazwie OracleMTSRecoveryService.reg kopiujemy go i zmieniamy mu nazwę na KEY_XE.reg
I przy okazji kopiujemy ścieżkę z paska adresu, bo za chwilkę się nam przyda.

Po tym wszystkim odpalamy edytor rejestru (regedit.exe) i odnajdujemy klucz

[syntax=bash]HKEY_CLASSES_ROOT\Installer\Products\266B7A503A089BE4EAD1986A429434C1\SourceList\Media[/syntax]

gdzie zmieniamy wartość klucza "1" na ścieżkę którą przed chwilą skopiowaliśmy w Exploatorze Windows.

Dopiero po tych wszystkich operacjach z ulgą klikamy ok

Dalej już nie powinno być większych problemów i naszym oczom powinno się ukazać takie okienko jak poniżej gdzie klikamy Finish

No dobra instalacja Oracle już za nami, ale to nie oznacza końca "kłopotów" jednak o tym za chwilkę.

Jeżeli wszystko przebiegło pomyślnie (w co nie wierzę) i po kliknięciu linku Get Started with Oracle "bla bla bla ..." ( jest na pulpicie )
ukaże nam się w przeglądarce taka strona

to jesteśmy w domu
A jak nie to jedziemy dalej .....

Odpalamy Explorator Windows i szukamy skrótu GET_Started w lokalizacji gdzie zainstalowaliśmy Oracle.
W moim przypadku jest to [syntax=bash]C:\oraclexe\app\oracle\product\11.2.0\server[/syntax]
Kopiujemy w/w link na pulpit i edytujemy go do postaci http://localhost:8080/apex/f?p=4950 ,
następnie zapisujemy i przenosimy z powrotem na swoje miejsce.

Nooo i teraz nie ma bata musi działać

a skoro tak to od razu klikamy na Apllication Express, gdzie następnie zostaniemy poproszeni o zalogowanie się, co czynimy czym prędzej

User : SYSTEM
Password : powinno być ci znane bo przecież klepałeś je podczas instalacji

Następnie ukaże nam się formularz do tworzenia nowego użytkownika co czynimy, tutaj mam gorącą prośbę załużcie użytkownika jak na obrazku, dlatego że jak później będę wrzucał jakieś skrypty to żeby obyło się bez niespodzianek

No dobra to już 3/4 drogi za nami pozostała nam tylko instalacja SQLTOOLS.
A właśnie słowo wyjaśnienia dlaczego SQLTOOLS, ano dlatego że jest to lekki edytor obsługujący Oracle, co prawda jest oryginał który nazywa się SQL Developer ale jest bardzo "ciężki" i prawdę mówiąc nie będzie nam potrzebne aż tak potężne środowisko.

No dobra więc zabieramy się za robotę. Instalkę SQLTOOLS powinniście już mieć gdzieś zapisaną, więc ją odpalamy i instalujemy.
Tutaj miała być instrukcja instalacji, no ale bez przegięcia myślę że te parę razy "next" to potraficie wcisnąć bez instrukcji

Po skończonej instalacji odpalamy Nasz edytor gdzie ukaże nam się takie okienko w którym dzielnie wciskamy ok

następnie pojawi się okienko z prośbą o podanie hasła (hasło to jest zabezpieczeniem edytora przed nie upoważnionym użytkowaniem i tak przy okazji chroni nasze połączenia do baz danych)

więc kto chce to wpisuje, a kto nie chce to nie wpisuje

Ok skoro już się zabezpieczyliśmy albo i nie okaże się za jakiś czas

to przystępujemy do konfiguracji połączenia z bazą danych

więc pisujemy po prawej stronie okienka:
TAG: ATNEL
User: ATNEL
Password: atnel

zaznaczamy bypass coś tam ...

Host: localhost
TCP Port : 1521

Następnie klikamy TEST , jeżeli wszystko przebiegło jak należy, powinien ukazać się komunikat

A skoro jest wszystko ok to klikamy save a później connect

No dobra teraz wypadało by sprawdzić chociaż czy cały ten nasz trud się opłacał,
więc czym prędzej wpisujemy
[syntax=sql]select * from dual;[/syntax]

I .......... mamy takie cuś

A skoro mamy takie cuś , to cieszymy się jak dzieci i czekamy na dalszy ciąg

PS. Będę po troszku w tym wątku dopisywał wiedzę tajemną o sql więc spadać mi stąd ze swoimi komentarzami

Statystyki: Napisane przez Malutki_27 — 23 wrz 2013, o 13:37