Oracle: pobranie poprzedniego i następnego wpisu

with test as (
select 1 id ,2 ext_id, 1 wartosc from dual union all
select 2 id ,2 ext_id, 2 wartosc from dual union all
select 3 id,2 ext_id, 3 wartosc from dual union all
select 4 id,1 ext_id, 4 wartosc from dual
)

select id, wartosc,
lag(wartosc) over (partition by ext_id order by id) as poprzednie,
lead(wartosc) over (partition by ext_id order by id) as nastepne
from test
order by id;

Linki: partycjonowanie oracle

Jeśli mamy duuuuuże tabele (tzn. zawierające dużo danych) to ich przetwarzanie możemy sobie usprawnić dzieląc je na takie wirtualne części nazywane partycjami. Dzięki temu:

  1. Można zadać zapytanie tylko do jednej partycji w tabeli i dzięki temu nie ma potrzeby przetwarzania całej tabeli (co jak się nie trudno domyślić jest szybsze)
  2. Joiny śmigają szybciej na takiej jednej partycji niż na całej tabeli, to samo grupowania, sortowanie i cała reszta możliwych sposobów na męczenie bazy.
  3. Partycje możemy sobie stworzyć na podstawie zawartości kolumny w tabeli, dzięki czemu możemy np. mieć szybszy dostęp do faktur przykładowo z tego roku.
  4. W ogóle idą za tym wszystkie korzyści związane z mniejszą ilością danych do przetworzenia.

Partycje możemy generalnie tworzyć na podstawie zawartości lub podzielić na sekcje równej wielkości. Dzielone na podstawie zawartości mogą być różnych rozmiarów – możemy mieć przykładowo milion faktur z tego roku, ale 5 milionów z zeszłego.

źródło:

http://andrzejklusiewicz.blogspot.com/2010/11/partycjonowanie-tabel.html

Zabawa z SQL, count itp

Tworzenie tabel i wypelnianie danymi:
create table OSOBA
(
ID int identity(1, 1) not null,
NAZWISKO varchar(512) not null
)
go
alter table OSOBA add constraint PK_OSOBA primary key (ID);

create table SAMOCHOD
(
ID int identity(1, 1) not null,
MARKA varchar(512) not null
)
go
alter table SAMOCHOD add constraint PK_SAMOCHOD primary key (ID);

create table OSOBA_SAMOCHOD
(
ID int identity(1, 1) not null,
ID_OSOBA int not null,
ID_SAMOCHOD int not null
)
go
alter table OSOBA_SAMOCHOD add constraint PK_OSOBA_SAMOCHOD primary key (ID);
alter table OSOBA_SAMOCHOD add constraint FK_OSOBA_SAMOCHOD_SAMOCHOD foreign key (ID_SAMOCHOD) references SAMOCHOD (ID);
alter table OSOBA_SAMOCHOD add constraint FK_OSOBA_SAMOCHOD_OSOBA foreign key (ID_OSOBA) references OSOBA (ID);

INSERT INTO OSOBA(NAZWISKO) VALUES(‚Kowalski’)
INSERT INTO OSOBA(NAZWISKO) VALUES(‚Ziolko’)
INSERT INTO OSOBA(NAZWISKO) VALUES(‚Piotrowski’)
INSERT INTO OSOBA(NAZWISKO) VALUES(‚Kowalskiewicz’)
INSERT INTO OSOBA(NAZWISKO) VALUES(‚Brzeczyszykiewicz’)
INSERT INTO OSOBA(NAZWISKO) VALUES(‚Ziobro’)
INSERT INTO OSOBA(NAZWISKO) VALUES(‚Tusk’)
INSERT INTO OSOBA(NAZWISKO) VALUES(‚Kaczynski’)

INSERT INTO SAMOCHOD(MARKA) VALUES(‚AUDI’)
INSERT INTO SAMOCHOD(MARKA) VALUES(‚BMW’)
INSERT INTO SAMOCHOD(MARKA) VALUES(‚FIAT’)
INSERT INTO SAMOCHOD(MARKA) VALUES(‚FORD’)
INSERT INTO SAMOCHOD(MARKA) VALUES(‚CITROEN’)
INSERT INTO SAMOCHOD(MARKA) VALUES(‚PORSCHE’)

insert into OSOBA_SAMOCHOD(ID_OSOBA,ID_SAMOCHOD) VALUES(1,1);
insert into OSOBA_SAMOCHOD(ID_OSOBA,ID_SAMOCHOD) VALUES(1,2);
insert into OSOBA_SAMOCHOD(ID_OSOBA,ID_SAMOCHOD) VALUES(1,3);
insert into OSOBA_SAMOCHOD(ID_OSOBA,ID_SAMOCHOD) VALUES(1,4);
insert into OSOBA_SAMOCHOD(ID_OSOBA,ID_SAMOCHOD) VALUES(1,5);
insert into OSOBA_SAMOCHOD(ID_OSOBA,ID_SAMOCHOD) VALUES(1,6);
insert into OSOBA_SAMOCHOD(ID_OSOBA,ID_SAMOCHOD) VALUES(2,4);

insert into OSOBA_SAMOCHOD(ID_OSOBA,ID_SAMOCHOD) VALUES(2,4);
insert into OSOBA_SAMOCHOD(ID_OSOBA,ID_SAMOCHOD) VALUES(5,1);
insert into OSOBA_SAMOCHOD(ID_OSOBA,ID_SAMOCHOD) VALUES(5,2);
insert into OSOBA_SAMOCHOD(ID_OSOBA,ID_SAMOCHOD) VALUES(5,3);
insert into OSOBA_SAMOCHOD(ID_OSOBA,ID_SAMOCHOD) VALUES(5,4);
insert into OSOBA_SAMOCHOD(ID_OSOBA,ID_SAMOCHOD) VALUES(4,4);
insert into OSOBA_SAMOCHOD(ID_OSOBA,ID_SAMOCHOD) VALUES(3,1);

 

 

TERAZ zapytania:
–pobierz osoby ktore maja wiecej niz 2 samochody
SELECT
o.nazwisko, COUNT(s.marka)
FROM OSOBA_SAMOCHOD os
JOIN OSOBA o on o.id = os.id_osoba
join samochod s on s.id = os.id_samochod
group by  o.nazwisko
having count(*)>2

ważne żeby użyć group by  o.nazwisko i having count(*)>2

–zlicz ilosc wpisow dla danej osoby
SELECT
os.ID_OSOBA, COUNT(os.ID_OSOBA)
FROM OSOBA_SAMOCHOD os
group by os.ID_OSOBA

 

Relacje

http://en.wikibooks.org/wiki/Java_Persistence/OneToMany

http://en.wikibooks.org/wiki/Java_Persistence/ManyToMany

Rozróżniamy następujące warianty relacji tego typu:
– dwukierunkową relacje jeden-do-wielu/wiele-do-jednego: obiekt nadrzędny posiada kolekcję referencji do obiektów podrzędnych, które posiadają referencję do obiektu nadrzędnego;
– jednokierunkowa relacja jeden-do-wielu: obiekt nadrzędny posiada kolekcję referencji do obiektów podrzędnych;
– jednokierunkowa relacja wiele-do-jednego: obiekt podrzędny posiada referencję do obiektu nadrzędnego;


Relacja jeden-do-wielu

Relacja jeden-do-wielu jest najbardziej powszechnym typem relacji. W relacji jeden-do-wielu rekord w tabeli A może mieć wiele dopasowanych do niego rekordów z tabeli B, ale rekord w tabeli B ma tylko jeden dopasowany rekord w tabeli A.

Relacja wiele-do-wielu

W relacji wiele-do-wielu, rekord w tabeli A może mieć wiele dopasowanych do niego rekordów z tabeli B i tak samo rekord w tabeli B może mieć wiele dopasowanych do niego rekordów z tabeli A. Jest to możliwe tylko przez zdefiniowanie trzeciej tabeli (nazywanej tabelą łącza), której klucz podstawowy składa się z dwóch pól — kluczy obcych z tabel A i B. Relacja wiele-do-wielu jest w istocie dwiema relacjami jeden-do-wielu z trzecią tabelą. Na przykład, tabele Zamówienia i Produkty są powiązane relacją wiele-do-wielu zdefiniowaną przez utworzenie dwóch relacji jeden-do-wielu z tabelą Opisy zamówień.

Relacja jeden-do-jednego

W relacji jeden-do-jednego każdy rekord w tabeli A może mieć tylko jeden dopasowany rekord z tabeli B, i tak samo każdy rekord w tabeli B może mieć tylko jeden dopasowany rekord z tabeli A. Ten typ relacji spotyka się rzadko, ponieważ większość informacji powiązanych w ten sposób byłoby zawartych w jednej tabeli. Relacji jeden-do-jednego można używać do podziału tabeli z wieloma polami, do odizolowania długa tabeli ze względów bezpieczeństwa, albo do przechowania informacji odnoszącej się tylko do podzbioru tabeli głównej. Na przykład, można by utworzyć tabelę do wyszukiwania pracowników uczestniczących w rozgrywkach piłkarskich.

więcej na http://dwalczak.blogspot.com/2008/04/jpa-relacje-jeden-do-wielu-i-wiele-do.html