Witajcie, konstruje bazę danych dla systemu obiegu umów.
Wygląda to tak, że klient sprzedaje usługi i zależnie od specyfiki każda usługa ma nieco inna umowę.
Aktualnie są 3 rodzaje umów, ale w przyszłości planowane jest więcej.

Wpraktyce jest tak, że logistyk czyli osoba wysyłająca umowy potrzebuje widzieć wszystkie pozycje na jednej liście, ale osoby weryfikujące ich poprawność są już odpowiedzialne tylko za swoje własne rodzaje umów.

Pomyślałem że zrobię to tak:

Tab: umowy
id PK
id1 - klucz obcy (jeśli podany oznacza że jest to rodzaj pierwszy)
id2 - klucz obcy (jeśli podany oznacza że jest to rodzaj drugi)
id3 - klucz obcy (jeśli podany oznacza że jest to rodzaj trzeci)
..... inne pola stałe dla każdej umowy


Tab: umowy_rodzaju_pierwszego
id
..... inne specyficzne pola dla umowy tego rodzaju

Tab: umowy_rodzaju_drugiego
id
..... inne specyficzne pola dla umowy tego rodzaju

Tab: umowy_rodzaju_trzeciego
id
..... inne specyficzne pola dla umowy tego rodzaju




Czy taki będzie ok? czy macie jakies inne pomysły ?

Uważam że dobrze myślisz.
Ja bym stworzył system który by miał opcje:
Umowa/Umowy
|
|
-Umowa1
|
-Umowa2
|
-Umowa2
Chyba że rodzaj umowy jest przypisany du urzytkownika
to wtedy meni było by z jego typem umowy.

Dzięki za odpowiedź tylko toroche jej nie zrozumiałem.

Mógłbyś rozwinąć ?

Klienci z którymi są podpisywane te umowy nie muszą byc gromadzeni w jakąś tabelę oddzielną. Jeśli pytałes o to.
Natomiast osoby przegladające (weryfikujące) konkretne umowy, rzeczywiście będą mieli rodzaj umowy przypisany do siebie. I może być tak że jedna osoba dostanie dwa rodzaje.
Zatem planuje tabelę

tab: osoby_sprawdzajace
id
imie_nazwisko
rodzaje_umow -- varchar (poprzecinku rodzaje umow np. "1, 2, 3")
.... inne pola o tym pracowniku

Ale Nie wiem ten pomysł nie jest zbyt prymitywny. Co myślicie?

Jak dobrze czytam to będzie także tabela z danymi osób które sprawdzają:
osoby_sprawdzajace
id
imie_nazwisko
rodzaje_umow -- varchar (poprzecinku rodzaje umow np. "1, 2, 3")
.... inne pola o tym pracowniku

Uważam że by było dobrze. W momencie kiedy osoba sprawdzająca wchodziła do systemu
ma meni z umowami jakie są dostępne w tabeli.
Upraszcza to obsługą systemu i nie powoduje jakiś pomyłek.
Jak dobrze czytam to jest to tablica jedno wymiarowa
rodzaje_umow -- varchar (poprzecinku rodzaje umow np. "1, 2, 3")
if rodzaje_umow =(1,2,3) then
Umowa1
Umowa2
Umowa3
end if
if rodzaje_umow =(0,2,3) then
Umowa2
Umowa3
end if
if rodzaje_umow =(1,0,3) then
Umowa1
Umowa3
end if
if rodzaje_umow =(1,2,0) then
Umowa1
Umowa2
end if
if rodzaje_umow =(0,03) then
Umowa3
end if
if rodzaje_umow =(1,0,0) then
Umowa1
end if
if rodzaje_umow =(0,2,0) then
Umowa2
end if
Może źle myślę.

Twój pomysł ciekawy ale troszkę inaczej to chciałem zrobić.

Pomyślałem żeby to nieco zmodyfikować i pokazać

[SQL] pobierz, plaintext 
CREATE TABLE IF NOT EXISTS `umowy` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `status` varchar(4) COLLATE utf8_polish_ci DEFAULT NULL,
  `rodzaj_umowy` varchar(5) COLLATE utf8_polish_ci DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8 COLLATE=utf8_polish_ci AUTO_INCREMENT=14 ;
 
INSERT INTO `umowy` (`id`, `status`, `rodzaj_umowy`) VALUES
(3, 'f', '1'),
(4, 'f', '1'),
(5, 'f', '1'),
(6, 'f', '1'),
(7, 'g', '2'),
(8, 'y', '2'),
(9, 'h', '2'),
(10, 'g', '2'),
(11, 'g', '2'),
(12, 'e', '3'),
(13, 't', '3');
[SQL] pobierz, plaintext 

Tabele z rodzajami umów (one z tabelą "umowy" są w relacji jeden do jeden):

[SQL] pobierz, plaintext 
CREATE TABLE IF NOT EXISTS `umowy_1` (
  `umowy_id` int(11) NOT NULL,
  `cos_innego3` varchar(45) COLLATE utf8_polish_ci DEFAULT NULL,
  PRIMARY KEY (`umowy_id`),
  KEY `fk_umowy_1_umowy1` (`umowy_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_polish_ci;
 
INSERT INTO `umowy_1` (`umowy_id`, `cos_innego3`) VALUES
(3, '1dfdgf'),
(4, '1adsfdg'),
(5, '1esrfd'),
(6, '1asrg');
 
CREATE TABLE IF NOT EXISTS `umowy_2` (
  `umowy_id` int(11) NOT NULL,
  `nip` varchar(4) COLLATE utf8_polish_ci DEFAULT NULL,
  PRIMARY KEY (`umowy_id`),
  KEY `fk_umowy_2_umowy1` (`umowy_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_polish_ci;
 
INSERT INTO `umowy_2` (`umowy_id`, `nip`) VALUES
(7, '3414'),
(8, '3141'),
(9, '3234'),
(10, '4135');
 
CREATE TABLE IF NOT EXISTS `umowy_3` (
  `umowy_id` int(11) NOT NULL,
  `cos_innego` varchar(4) COLLATE utf8_polish_ci DEFAULT NULL,
  PRIMARY KEY (`umowy_id`),
  KEY `fk_umowy_3_umowy1` (`umowy_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_polish_ci;
 
INSERT INTO `umowy_3` (`umowy_id`, `cos_innego`) VALUES
(12, 'fs'),
(13, 'fs');
[SQL] pobierz, plaintext 

tabela: tab: osoby_sprawdzajace pozostanie bez zmian


Jak loguje się osoba_sprawdzająca to wykonuje się zapytanie

[SQL] pobierz, plaintext 
SELECT rodzaje_umow FROM osoby_sprawdzające WHERE login=$login_zalogowanej_osoby;
[SQL] pobierz, plaintext 

W ten sposób otrzymamy przypisane do niego rodzaje umów. w postacie ciągu np. "1, 2, 3" - ciąg oznacza że ta osoba ma dostęp do umów 1 (pierwszego) rodzaju, 2 (drugiego), 3 (trzeciego).


Potem chciałbym jednym zapytaniem pobrać jego wszystkie umowy razem z ich indywidualnymi szczegółami.
Zatem niezbędne będzie zapytanie łączące tabele główną "umowy" z tabelami rodzajów.
Załóżmy że poprzednie zapytanie wyświetliło: "1, 2", Zatem będziemy łączyć tabele: "umowy" , "umowy_1", "umowy_2".

[SQL] pobierz, plaintext 
SELECT u.*, u1.cos_innego3, u2.nip FROM umowy u 
LEFT JOIN umowy_1 u1 ON u.id=u1.umowy_id
LEFT JOIN umowy_2 u2 ON u.id=u2.umowy_id
WHERE u.rodzaj_umowy IN(1, 2) ORDER BY u.id LIMIT 30
[SQL] pobierz, plaintext 

wynik:





Zapytanie działa poprawnie. Ale niewiem jak to jest wydajne. No i widac pewne wady.
Co prawda to system pisany w php będzie dbał by coś takiego nie miało miejsca, ale widzimy że jak wprowadzona jest nowa umowa to trzeba ją wprowadzać w dwóch miejscach. Najpierw w tabeli "umowy" potem w "umowy_1" lub innej zależnie od pola u.rodzaj_umowy.


Dlatego tak myslę czy nie da się tego jakos ciekawiej zrobić