ASD

/* ================================================ */
/* TABELA: DYRYGENT */
/* ================================================ */

CREATE TABLE [DYRYGENT]
(
    PESEL_DYRYGENT CHAR(11) NOT NULL,
    IMIE_DYRYGENT VARCHAR(32) NOT NULL,
    NAZWISKO_DYRYGENT VARCHAR(32) NOT NULL,
    PLEC_DYRYGENT CHAR(1) NULL DEFAULT 'N'
        CONSTRAINT CHECK_PLEC_DYRYGENT
            CHECK (PLEC_DYRYGENT IS NULL OR (PLEC_DYRYGENT IN ('N','K','M'))),
    DATA_URODZENIA_DYRYGENT DATE NULL,

    CONSTRAINT PK_DYRYGENT PRIMARY KEY (PESEL_DYRYGENT)
);

COMMENT ON TABLE [DYRYGENT] IS
    'Osoba dyrygujaca dana grupa muzykow';

COMMENT ON COLUMN [DYRYGENT].PLEC_DYRYGENT IS
    'Plec kompozytora.
    N - brak danych
    K - kobieta
    M - mezczyzna';

COMMENT ON COLUMN [DYRYGENT].PESEL_DYRYGENT IS
    '11 znakowy unikalny ciag znakow';

COMMENT ON COLUMN [DYRYGENT].IMIE_DYRYGENT IS
    'Imie jakim posluguje sie dyrygent';

COMMENT ON COLUMN [DYRYGENT].NAZWISKO_DYRYGENT IS
    'Nazwisko jakim posluguje sie dyrygent';

COMMENT ON COLUMN [DYRYGENT].DATA_URODZENIA_DYRYGENT IS
    'Data w jakiej przyszedl na swiat dyrygent';


/* ================================================ */
/* TABELA: INSTRUMENT */
/* ================================================ */

CREATE TABLE [INSTRUMENT]
(
    ID_INSTRUMENT INTEGER DEFAULT AUTOINCREMENT,
    PESEL_MUZYK CHAR(11) NULL,
    TYP_INSTRUMENT CHAR(1) NOT NULL DEFAULT 'N'
        CONSTRAINT CHECK_TYP_INSTRUMENT
            CHECK (TYP_INSTRUMENT IN ('N','A','C','I','M','E')),
    NAZWA_INSTRUMENT VARCHAR(32) NOT NULL,
    PRODUCENT VARCHAR(32) NULL,
    DATA_WYPRODUKOWANIA DATE NULL,

    CONSTRAINT PK_INSTRUMENT PRIMARY KEY (ID_INSTRUMENT)
);

COMMENT ON TABLE [INSTRUMENT] IS
    'Dane na temat kazdego egzemplarzu instrumentu';

COMMENT ON COLUMN [INSTRUMENT].PESEL_MUZYK IS
    '11-znakowy unikalny identyfikator osoby';

COMMENT ON COLUMN [INSTRUMENT].TYP_INSTRUMENT IS
    'Rodzina do jakiej klasyfikowany jest instrument.
    N - brak danych
    A - aerofon - dęty
    C - chordofon - strunowy
    I - idiofon - perkusyjny samobrzmiacy
    M - membranofon - perkusyjny membranowy
    E - elektrofon - instrument elektroniczny';

COMMENT ON COLUMN [INSTRUMENT].NAZWA_INSTRUMENT IS
    'Nazwa Instrumentu.';

COMMENT ON COLUMN [INSTRUMENT].PRODUCENT IS
    'Nazwa tworcy danego egzemplarzu instrumentu.';

COMMENT ON COLUMN [INSTRUMENT].DATA_WYPRODUKOWANIA IS
    'Data w jakim dniu dany egzemplarz zostal uznany jako gotowy do uzytku.';

/* ================================================ */
/* TABELA: KOMPOZYTOR */
/* ================================================ */

CREATE TABLE [KOMPOZYTOR]
(
    PESEL_KOMPOZYTOR CHAR(11) NOT NULL,
    IMIE_KOMPOZYTOR VARCHAR(32) NOT NULL,
    NAZWISKO_KOMPOZYTOR VARCHAR(32) NOT NULL,
    DATA_URODZENIA_KOMPOZYTOR DATE NULL,

    CONSTRAINT PK_KOMPOZYTOR PRIMARY KEY (PESEL_KOMPOZYTOR)
);

COMMENT ON TABLE [KOMPOZYTOR] IS
    'Osoba tworzaca utwory.';

COMMENT ON COLUMN [KOMPOZYTOR].PESEL_KOMPOZYTOR IS
    '11 znakowy unikalny ciag znakow';

COMMENT ON COLUMN [KOMPOZYTOR].IMIE_KOMPOZYTOR IS
    'Imie jakim posluguje sie kompozytor';

COMMENT ON COLUMN [KOMPOZYTOR].NAZWISKO_KOMPOZYTOR IS
    'Nazwisko jakim posluguje sie kompozytor';

COMMENT ON COLUMN [KOMPOZYTOR].DATA_URODZENIA_KOMPOZYTOR IS
    'Data w jakiej przyszedl na swiat kompozytor';

/* ================================================ */
/* TABELA: KONCERT */
/* ================================================ */

CREATE TABLE [SALA]
(
    ID_SALA INTEGER DEFAULT AUTOINCREMENT,
    NAZWA_SALA VARCHAR(64) NOT NULL,
    LOKALIZACJA VARCHAR(32) NULL,
    POJEMNOSC INTEGER NULL
        CONSTRAINT CHECK_POJEMNOSC
            CHECK (POJEMNOSC IS NULL OR (POJEMNOSC >=1)),

    CONSTRAINT PK_SALA PRIMARY KEY (ID_SALA)
);

COMMENT ON TABLE [SALA] IS
    'Miejsce w ktorym odbywaja sie koncerty.';

COMMENT ON COLUMN [SALA].ID_SALA IS
    'Unikalny identyfikator sali.';

COMMENT ON COLUMN [SALA].NAZWA_SALA IS
    'Nazwa nadana przy otwarciu sali.';

COMMENT ON COLUMN [SALA].LOKALIZACJA IS
    'Mijescowosc w jakiej znajduje sie sala.';

COMMENT ON COLUMN [SALA].POJEMNOSC IS
    'Ilosc osob jaka moze pomiescic sala';

/* ================================================ */
/* TABELA: KONCERT */
/* ================================================ */

CREATE TABLE [KONCERT]
(
    ID_KONCERT INTEGER DEFAULT AUTOINCREMENT,
    ID_SALA INTEGER NOT NULL,
    NAZWA_KONCERT VARCHAR(32) NOT NULL,
    DATA_KONCERT DATE NOT NULL,

    CONSTRAINT PK_KONCERT PRIMARY KEY (ID_KONCERT)
);

COMMENT ON TABLE [KONCERT] IS
    'Zorganizowane wydarzenie kulturowe na ktorym prezentowane sa pozycje (utwory) instrumentalne.';

COMMENT ON COLUMN [KONCERT].ID_SALA IS
    'Unikalny identyfikator sali.';

COMMENT ON COLUMN [KONCERT].NAZWA_KONCERT IS
    'Nazwa nadana wydarzeniu przez organizora eventu.';

COMMENT ON COLUMN [KONCERT].DATA_KONCERT IS
    'Dzien w jakim ma sie odbyc koncert.';



/* ================================================ */
/* TABELA: MUZYK */
/* ================================================ */

CREATE TABLE [MUZYK]
(
    PESEL_MUZYK CHAR(11) NOT NULL,
    IMIE_MUZYK VARCHAR(32) NOT NULL,
    NAZWISKO_MUZYK VARCHAR(32) NOT NULL,
    PLEC_MUZYK CHAR(1) NULL DEFAULT 'N'
        CONSTRAINT CHECK_PLEC_MUZYK
            CHECK (PLEC_MUZYK is NULL or (PLEC_MUZYK IN ('N', 'M','K'))),
    DATA_URODZENIA_MUZYK DATE NULL,

    CONSTRAINT PK_MUZYK PRIMARY KEY (PESEL_MUZYK)
);

COMMENT ON TABLE [MUZYK] IS
    'Dane instrumentalistow bioracych udzial w koncertach.';

COMMENT ON COLUMN [MUZYK].PESEL_MUZYK IS
    '11-znakowy unikalny identyfikator osoby';

COMMENT ON COLUMN [MUZYK].IMIE_MUZYK IS
    'Imie pod jakim znany jest muzyk';

COMMENT ON COLUMN [MUZYK].NAZWISKO_MUZYK IS
    'Nazwisko pod jakim znany jest muzyk.';

COMMENT ON COLUMN [MUZYK].PLEC_MUZYK IS
    'Plec jaka identyfikuje sie muzyk.
    N - brak danych
    M - mezczyzna
    K - kobieta';

COMMENT ON COLUMN [MUZYK].DATA_URODZENIA_MUZYK IS
    'Dzien w jakim przyszedl na swiat muzyk.';

/* ================================================ */
/* TABELA: ORKIESTRA */
/* ================================================ */

CREATE TABLE [ORKIESTRA]
(
    ID_ORKIESTRA INTEGER DEFAULT AUTOINCREMENT,
    PESEL_DYRYGENT CHAR(11) NULL,
    NAZWA_ORKIESTRA VARCHAR(64) NOT NULL,
    TYP_ORKIESTRA CHAR(2) NULL DEFAULT 'Zk'
        CONSTRAINT CHECK_TYP_ORKIESTRA
            CHECK (TYP_ORKIESTRA IS NULL OR(TYP_ORKIESTRA IN ('Sf', 'Sm','Dt','Bb','Zk'))),
    DATA_UTWORZENIA DATE NULL,

    CONSTRAINT PK_ORKIESTRA PRIMARY KEY (ID_ORKIESTRA)
);

COMMENT ON TABLE [ORKIESTRA] IS
    'Dane o grupach bioracych udzial w koncercach.';

COMMENT ON COLUMN [ORKIESTRA].ID_ORKIESTRA IS
    'Liczba jednoznacznie pozwalajaca zidentyfikowac grupe osob.';

COMMENT ON COLUMN [ORKIESTRA].NAZWA_ORKIESTRA IS
    'Nazwa pod jaka wystepuje dana grupa osob.';

COMMENT ON COLUMN [ORKIESTRA].TYP_ORKIESTRA IS
    'Okresla typy instrumentow wchodzacych w sklad orkiestry.
    Sf - orkiestra symfoniczna
    Sm- orkiestra smyczkowa
    Dt - orkiestra  Dęta
    Bb - orkiestra rozrywkowa (bigband)
    Zk - zespół kameralny';

COMMENT ON COLUMN [ORKIESTRA].PESEL_DYRYGENT IS
    'Unikalny 11 znakowy ciag identyfikujacy dyrygenta.';

COMMENT ON COLUMN [ORKIESTRA].DATA_UTWORZENIA IS
    'Dzien w jakim grupa osob oficalnie zaczela istniec.';

/* ================================================ */
/* TABELA: UTWOR */
/* ================================================ */

CREATE TABLE [UTWOR]
(
    ID_UTWOR INTEGER DEFAULT AUTOINCREMENT,
    NAZWA_UTWOR VARCHAR(32) NOT NULL,
    CZAS_UTWOR INTEGER NULL,
    DATA_SKOMPONOWANIA INTEGER NULL,

    CONSTRAINT PK_UTWOR PRIMARY KEY (ID_UTWOR)
);

COMMENT ON TABLE [UTWOR] IS
'Kompozycja napisana przez danego kompozytora i wykonywana przez muzykow.';

COMMENT ON COLUMN [UTWOR].ID_UTWOR IS
'Numer katalogowy nadawany po wpisaniu kompozycji do rejestru kompozytora';

COMMENT ON COLUMN [UTWOR].NAZWA_UTWOR IS
'Tytul nadawany kompozycji przez kompozytora.';

COMMENT ON COLUMN [UTWOR].CZAS_UTWOR IS
'Czas jaki jest przewidywany na wykonanie kompozycji';

COMMENT ON COLUMN [UTWOR].DATA_SKOMPONOWANIA IS
'Data wpisania kompozycji do rejestru kompozytora.';




/* ================================================ */
/* Tabela: CZLONEK */
/* ================================================ */

CREATE TABLE [CZLONEK]
(
    PESEL_MUZYK CHAR(11) NOT NULL,
    ID_ORKIESTRA INTEGER NOT NULL,

    CONSTRAINT PK_CZLONEK
 PRIMARY KEY CLUSTERED (PESEL_MUZYK, ID_ORKIESTRA)
);

COMMENT ON TABLE [CZLONEK] IS
    'Relacja mowiaca czy muzyk jest w skladzie danej grupy';

COMMENT ON COLUMN [CZLONEK].PESEL_MUZYK IS
    '11-znakowy unikalny identyfikator osoby';

COMMENT ON COLUMN [CZLONEK].ID_ORKIESTRA IS
    'Liczba jednoznacznie pozwalajaca zidentyfikowac grupe osob';

/* ================================================ */
/* Tabela: KATALOG_DZIEL */
/* ================================================ */

CREATE TABLE [KATALOG_DZIEL]
(
    PESEL_KOMPOZYTOR CHAR(11) NOT NULL,
    ID_UTWOR INTEGER NOT NULL,

    CONSTRAINT PK_KATALOG_DZIEL PRIMARY KEY CLUSTERED (PESEL_KOMPOZYTOR, ID_UTWOR)
);

COMMENT ON TABLE [KATALOG_DZIEL] IS
    'Informacje jakie dziala stworzyl dany kompozytor';

COMMENT ON COLUMN [KATALOG_DZIEL].ID_UTWOR IS
    'Numer katalogowy nadawany po wpisaniu kompozycji do rejestru kompozytora';

COMMENT ON COLUMN [KATALOG_DZIEL].PESEL_KOMPOZYTOR IS
    'Unikalny 11 znakowy ciag identyfikujacy kompozytora';

/* ================================================ */
/* Tabela: REPERTUAR */
/* ================================================ */

CREATE TABLE [REPERTUAR]
(
    ID_UTWOR INTEGER NOT NULL,
    ID_ORKIESTRA INTEGER NOT NULL,

    CONSTRAINT PK_REPERTUAR PRIMARY KEY CLUSTERED (ID_UTWOR, ID_ORKIESTRA)
);

COMMENT ON TABLE [REPERTUAR] IS
    'Utwory jakie jest wstanie wykONac orkiestra.';

COMMENT ON COLUMN [REPERTUAR].ID_UTWOR IS
    'Numer katalogowy nadawany po wpisaniu kompozycji do rejestru kompozytora';

COMMENT ON COLUMN [REPERTUAR].ID_ORKIESTRA IS
    'Liczba jednoznacnzie pozwalajaca zidentyfikowac grupe osob.';

/* ================================================ */
/* Tabela: SOLISTA */
/* ================================================ */

CREATE TABLE [SOLISTA]
(
    PESEL_MUZYK CHAR(11) NOT NULL,
    ID_WYKONANIE INTEGER NOT NULL,

    CONSTRAINT PK_SOLISTA PRIMARY KEY CLUSTERED (PESEL_MUZYK, ID_WYKONANIE)
);

COMMENT ON TABLE [SOLISTA] IS
    'Muzyk wystepujacy w pojedynke.';

COMMENT ON COLUMN [SOLISTA].PESEL_MUZYK IS
    '11-znakowy unikalny identyfikator osoby';

COMMENT ON COLUMN [SOLISTA].ID_WYKONANIE IS
    'Numer identyfikacyjny wykONania';


/* ================================================ */
/* Tabela: WYKONANIE */
/* ================================================ */

CREATE TABLE [WYKONANIE]
(
    ID_WYKONANIE INTEGER DEFAULT AUTOINCREMENT,
    ID_UTWOR INTEGER NOT NULL,
    ID_KONCERT INTEGER NOT NULL,
    ID_ORKIESTRA INTEGER NULL,

    CONSTRAINT PK_WYKONANIE PRIMARY KEY (ID_WYKONANIE)
);

COMMENT ON TABLE [WYKONANIE] IS
'Dane odnosnie wykonania danego utworu.';

COMMENT ON COLUMN [WYKONANIE].ID_WYKONANIE IS
'Numer identyfikacyjny wykonania.';

COMMENT ON COLUMN [WYKONANIE].ID_UTWOR IS
'Numer identyfikacyjny utworu.';

COMMENT ON COLUMN [WYKONANIE].ID_KONCERT IS
'Numer identyfikacyjny koncertu.';

COMMENT ON COLUMN [WYKONANIE].ID_ORKIESTRA IS
'Numer identyfikacyjny orkiestry.';


/* ================================================ */
/* Tabela: WYPOSAZENIE_SALI */
/* ================================================ */
/*
CREATE TABLE [WYPOSAZENIE_SALI]
(
    ID_INSTRUMENT INTEGER NOT NULL,
    ID_SALA INTEGER NOT NULL,

    CONSTRAINT PK_WYPOSAZENIE_SALI PRIMARY KEY CLUSTERED (ID_INSTRUMENT, ID_SALA)
);

COMMENT ON TABLE [WYPOSAZENIE_SALI] IS
    'Duze instrumenty stacjonarne znajdujace sie na stale w salach';

COMMENT ON COLUMN [WYPOSAZENIE_SALI].ID_SALA IS
    'Unikalny identyfikator sali.';
*/


/* ================================================ */
/* Tabela: ORKIESTRA_ARCHIWUM */
/* ================================================ */

CREATE TABLE [ORKIESTRA_ARCHIWUM]
(
    ID_ORKIESTRA_ARCHIWUM INTEGER DEFAULT AUTOINCREMENT,
    ID_ORKIESTRA_A INTEGER NULL,
    PESEL_MUZYK_A CHAR(11) NOT NULL,
    NAZWA_ORKIESTRA_A CHAR(32) NULL,
    OSOBA_A CHAR(64) NOT NULL,

    CONSTRAINT PK_ORKIESTRA_ARCHIWUM PRIMARY KEY CLUSTERED (ID_ORKIESTRA_ARCHIWUM)
);

 COMMENT ON TABLE [ORKIESTRA_ARCHIWUM] IS
    'Tabela zawierajaca dane na temat czlonkowstwa muzykow w orkiestrach';

COMMENT ON COLUMN [ORKIESTRA_ARCHIWUM].ID_ORKIESTRA_ARCHIWUM IS
    'Licznik rekordow w archiwum.';

COMMENT ON COLUMN [ORKIESTRA_ARCHIWUM].ID_ORKIESTRA_A IS
    'Numer identyfikacyjny orkiestry.';

COMMENT ON COLUMN [ORKIESTRA_ARCHIWUM].PESEL_MUZYK_A IS
    'Numer identyfikacyjny muzyka.';

COMMENT ON COLUMN [ORKIESTRA_ARCHIWUM].NAZWA_ORKIESTRA_A IS
    'Nazwa orkiestry.';

COMMENT ON COLUMN [ORKIESTRA_ARCHIWUM].OSOBA_A IS
    'Imie i nazwisko osoby';


/* ================================================ */
/* Tabela: KONCERT_ARCHIWUM */
/* ================================================ */

CREATE TABLE [SOLISCI_ARCHIWUM]
(
    ID_SOLISCI_ARCHIWUM INTEGER DEFAULT AUTOINCREMENT,
    UTWOR_A VARCHAR(32) NULL,
    KONCERT_A VARCHAR(32) NULL,
    ORKIESTRA_A VARCHAR(64) NULL,
    SOLISCI_A VARCHAR(256) NULL,
    DATA_A DATE NOT NULL,

    CONSTRAINT PK_SOLISCI_ARCHIWUM PRIMARY KEY CLUSTERED (ID_SOLISCI_ARCHIWUM)
);

 COMMENT ON TABLE [SOLISCI_ARCHIWUM] IS
    'Tabela zawierajaca dane na temat solistow z poszczegolnych wykonan utworow na koncercie';

COMMENT ON COLUMN [SOLISCI_ARCHIWUM].ID_SOLISCI_ARCHIWUM IS
    'Licznik w archiwum';

COMMENT ON COLUMN [SOLISCI_ARCHIWUM].UTWOR_A IS
    'Nazwa wykonanego utworu';

COMMENT ON COLUMN [SOLISCI_ARCHIWUM].KONCERT_A IS
    'Nazwa zagranego koncertu';

COMMENT ON COLUMN [SOLISCI_ARCHIWUM].ORKIESTRA_A IS
    'Nazwa orkiestry ktora brala udzial';

COMMENT ON COLUMN [SOLISCI_ARCHIWUM].SOLISCI_A IS
    'Imiona i nazwiska solistow';

COMMENT ON COLUMN [SOLISCI_ARCHIWUM].DATA_A IS
    'Dzien w ktorym odbyl sie koncert';


/* ================================================ */
/* klucze glowne i indeksy  */
/* ================================================ */
ALTER TABLE [CZLONEK]
        ADD CONSTRAINT FK_CZLONEK_MUZYK FOREIGN KEY (PESEL_MUZYK)
            REFERENCES [MUZYK] (PESEL_MUZYK)
    ON UPDATE RESTRICT
        ON
    DELETE RESTRICT;

    ALTER TABLE [CZLONEK]
        ADD CONSTRAINT FK_CZLONEK_ORKIESTRA FOREIGN KEY (ID_ORKIESTRA)
            REFERENCES [ORKIESTRA] (ID_ORKIESTRA)
    ON UPDATE RESTRICT
        ON
    DELETE RESTRICT;

    ALTER TABLE INSTRUMENT
        ADD CONSTRAINT FK_INSTRUMENT_MUZYK FOREIGN KEY (PESEL_MUZYK)
            REFERENCES [MUZYK] (PESEL_MUZYK)
    ON UPDATE RESTRICT
        ON
    DELETE RESTRICT;

    ALTER TABLE KONCERT
        ADD CONSTRAINT FK_KONCERT_SALA FOREIGN KEY (ID_SALA)
            REFERENCES [SALA] (ID_SALA)
    ON UPDATE RESTRICT
        ON
    DELETE RESTRICT;

    ALTER TABLE KATALOG_DZIEL
        ADD CONSTRAINT FK_KATALOG_DZIEL_KOMPOZYTOR FOREIGN KEY (PESEL_KOMPOZYTOR)
            REFERENCES [KOMPOZYTOR] (PESEL_KOMPOZYTOR)
    ON UPDATE RESTRICT
        ON
    DELETE RESTRICT;

    ALTER TABLE KATALOG_DZIEL
        ADD CONSTRAINT FK_KATALOG_DZIEL_UTWOR FOREIGN KEY (ID_UTWOR)
            REFERENCES [UTWOR] (ID_UTWOR)
    ON UPDATE RESTRICT
        ON
    DELETE RESTRICT;

    ALTER TABLE ORKIESTRA
        ADD CONSTRAINT FK_ORKIESTRA_DYRYGENT FOREIGN KEY (PESEL_DYRYGENT)
            REFERENCES [DYRYGENT] (PESEL_DYRYGENT)
    ON UPDATE RESTRICT
            ON
    DELETE RESTRICT;

    ALTER TABLE REPERTUAR
        ADD CONSTRAINT FK_REPERTUAR_UTWOR FOREIGN KEY (ID_UTWOR)
            REFERENCES [UTWOR] (ID_UTWOR)
    ON UPDATE RESTRICT
        ON
    DELETE RESTRICT;

    ALTER TABLE REPERTUAR
        ADD CONSTRAINT FK_REPERTUAR_ORKIESTRA FOREIGN KEY (ID_ORKIESTRA)
            REFERENCES [ORKIESTRA] (ID_ORKIESTRA)
    ON UPDATE RESTRICT
        ON
    DELETE RESTRICT;

    ALTER TABLE SOLISTA
        ADD CONSTRAINT FK_SOLISTA_MUZYK FOREIGN KEY (PESEL_MUZYK)
            REFERENCES [MUZYK] (PESEL_MUZYK)
    ON UPDATE RESTRICT
        ON
    DELETE RESTRICT;

    ALTER TABLE SOLISTA
        ADD CONSTRAINT FK_SOLISTA_WYKONANIE FOREIGN KEY (ID_WYKONANIE)
            REFERENCES [WYKONANIE] (ID_WYKONANIE)
    ON UPDATE RESTRICT
        ON
    DELETE RESTRICT;

    ALTER TABLE WYKONANIE
        ADD CONSTRAINT FK_WYKONANIE_UTWOR FOREIGN KEY (ID_UTWOR)
            REFERENCES UTWOR (ID_UTWOR)
    ON UPDATE RESTRICT
        ON
    DELETE RESTRICT;

    ALTER TABLE WYKONANIE
        ADD CONSTRAINT FK_WYKONANIE_KONCERT FOREIGN KEY (ID_KONCERT)
            REFERENCES KONCERT (ID_KONCERT)
    ON UPDATE RESTRICT
        ON
    DELETE RESTRICT;

    ALTER TABLE  WYKONANIE
        ADD CONSTRAINT FK_WYKONANIE_ORKIESTRA FOREIGN KEY (ID_ORKIESTRA)
            REFERENCES [ORKIESTRA] (ID_ORKIESTRA)
    ON UPDATE RESTRICT
        ON
    DELETE RESTRICT;

    /*
    ALTER TABLE WYPOSAZENIE_SALI
        ADD CONSTRAINT FK_WYPOSAZENIE_SALI_INSTRUMENT FOREIGN KEY (ID_INSTRUMENT)
            REFERENCES [INSTRUMENT] (ID_INSTRUMENT
    )
    ON UPDATE RESTRICT
        ON
    DELETE RESTRICT;

    ALTER TABLE WYPOSAZENIE_SALI
        ADD CONSTRAINT FK_WYPOSAZENIE_SALI_SALA FOREIGN KEY (ID_SALA)
            REFERENCES [SALA] (ID_SALA)
    ON UPDATE RESTRICT
        ON
    DELETE RESTRICT;
    */




    CREATE INDEX CZLONEK_FK ON [CZLONEK]
    (
        PESEL_MUZYK ASC
    );

    CREATE INDEX CZLONEK2_FK ON [CZLONEK]
    (
        ID_ORKIESTRA ASC
    );

    ------------------------------- DYRYGENT

    CREATE UNIQUE INDEX DYRYGENT_PK ON [DYRYGENT]
    (
        PESEL_DYRYGENT ASC
    );

    ------------------------------- INSTRUMENT

    CREATE UNIQUE INDEX INSTRUMENT_PK ON [INSTRUMENT]
    (
        ID_INSTRUMENT ASC
    );

    CREATE UNIQUE INDEX Posiadanie_FK ON [INSTRUMENT]
    (
        PESEL_MUZYK ASC
    );

    ------------------------------- KOMPOZYTOR

    CREATE UNIQUE INDEX KOMPOZYTOR_PK ON [KOMPOZYTOR]
    (
        PESEL_KOMPOZYTOR ASC
    );

    ------------------------------- KONCERT

    CREATE UNIQUE INDEX KONCERT_PK ON [KONCERT]
    (
        ID_KONCERT ASC
    );

    CREATE INDEX Miejsce_koncertu_FK ON [KONCERT]
    (
        ID_SALA ASC
    );

    ------------------------------- KATALOG DZIEL
    /*
    CREATE UNIQUE CLUSTERED INDEX KATALOG_DZIEL_PK ON KATALOG_DZIEL
    (
        PESEL_KOMPOZYTOR ASC,
        ID_UTWOR ASC
    );
    */

    CREATE INDEX KATALOG_DZIEL_FK ON [KATALOG_DZIEL]
    (
        PESEL_KOMPOZYTOR ASC
    );

    CREATE INDEX KATALOG_DZIEL2_FK ON [KATALOG_DZIEL]
    (
        ID_UTWOR ASC
    );

    ------------------------------- MUZYK

    CREATE UNIQUE INDEX MUZYK_PK ON [MUZYK]
    (
        PESEL_MUZYK ASC
    );

    ------------------------------- ORKIESTRA

    CREATE UNIQUE INDEX ORKIESTRA_PK ON [ORKIESTRA]
    (
        ID_ORKIESTRA ASC
    );

    CREATE INDEX Dyrygowanie_FK ON [ORKIESTRA]
    (
        PESEL_DYRYGENT ASC
    );

    ------------------------------- REPERTUAR
    /*
    CREATE UNIQUE CLUSTERED INDEX REPERTUAR_PK ON [REPERTUAR]
    (
        ID_UTWOR ASC,
        ID_ORKIESTRA ASC
    );
    */
    CREATE INDEX REPERTUAR_FK ON [REPERTUAR]
    (
        ID_UTWOR ASC
    );

    CREATE INDEX REPERTUAR2_FK ON [REPERTUAR]
    (
        ID_ORKIESTRA ASC
    );

    ------------------------------- SALA

    CREATE UNIQUE INDEX SALA_PK ON [SALA]
    (
        ID_SALA ASC
    );

    ------------------------------- SOLISTA
    /*
    CREATE UNIQUE CLUSTERED INDEX SOLISTA_PK ON [SOLISTA]
    (
        PESEL_MUZYK ASC, ID_WYKONANIE ASC
    );
    */
    CREATE INDEX SOLISTA_FK ON [SOLISTA]
    (
        PESEL_MUZYK ASC
    );

    CREATE INDEX SOLISTA2_FK ON [SOLISTA]
    (
        ID_WYKONANIE ASC
    );

    ------------------------------- UTWOR

    CREATE UNIQUE INDEX UTWOR_PK ON [UTWOR]
    (
        ID_UTWOR ASC
    );

    ------------------------------- WYKONANIE

    CREATE UNIQUE INDEX Wykonanie_PK ON [WYKONANIE]
    (
        ID_WYKONANIE ASC
    );

    CREATE INDEX Pozycja_koncertu_FK on [WYKONANIE]
    (
        ID_KONCERT ASC
    );

    CREATE INDEX Pozycja_FK ON [WYKONANIE]
    (
        ID_UTWOR ASC
    );

    CREATE INDEX Wykonanie_orkiestra_FK ON [WYKONANIE]
    (
        ID_ORKIESTRA ASC
    );




    ------------------------------- WYPOSAZENIE_SALI
    /*
    CREATE UNIQUE CLUSTERED INDEX WYPOSAZENIE_SALI_PK ON [WYPOSAZENIE_SALI]
    (
        ID_INSTRUMENT ASC,
        ID_SALA ASC
    );
    */
    /*
    CREATE INDEX WYPOSAZENIE_SALI_FK ON [WYPOSAZENIE_SALI]
    (
        ID_INSTRUMENT ASC
    );

    CREATE INDEX WYPOSAZENIE_SALI2_FK ON [WYPOSAZENIE_SALI]
    (
        ID_SALA ASC

    );
*/

---------------
--- WIDOKI
----------------

CREATE MATERIALIZED VIEW KONCERTY AS
    SELECT DISTINCT
        [KONCERT].NAZWA_KONCERT AS KONCERT,
        LIST ([UTWOR].NAZWA_UTWOR ,', ') AS UTWOR,
        LIST ([ORKIESTRA].NAZWA_ORKIESTRA, ', ') AS ORKIESTRA,
        LIST ([DYRYGENT].IMIE_DYRYGENT + ' ' + [DYRYGENT].NAZWISKO_DYRYGENT, ', ') AS DYRYGENT,
        CONVERT(VARCHAR, SUM([UTWOR].CZAS_UTWOR) / 60 ) + 'h ' +
            CONVERT(VARCHAR, SUM([UTWOR].CZAS_UTWOR) % 60) + 'm' AS CZAS_KONCERTU,
        [KONCERT].DATA_KONCERT AS DATA
    FROM
        [ORKIESTRA] INNER JOIN [DYRYGENT] ON [ORKIESTRA].PESEL_DYRYGENT = [DYRYGENT].PESEL_DYRYGENT,
        [ORKIESTRA] INNER JOIN [WYKONANIE] ON [ORKIESTRA].ID_ORKIESTRA = [WYKONANIE].ID_ORKIESTRA,
        [UTWOR] INNER JOIN [WYKONANIE] ON [UTWOR].ID_UTWOR = [WYKONANIE].ID_UTWOR,
        [KONCERT] INNER JOIN [WYKONANIE] ON [KONCERT].ID_KONCERT = [WYKONANIE].ID_KONCERT
    GROUP BY KONCERT, DATA
ORDER BY DATA;

COMMENT ON VIEW [SIKER].KONCERTY IS
    'Informacje o koncertach';

---

CREATE VIEW WSPOLPRACA AS
    SELECT
        ([MUZYK].IMIE_MUZYK + ' ' + [MUZYK].NAZWISKO_MUZYK) AS INSTRUMENTALISTA,
        [ORKIESTRA].NAZWA_ORKIESTRA AS ORKIESTRY,
        COUNT ([ORKIESTRA].NAZWA_ORKIESTRA) AS 'WSPOLNE KONCERTY',
        [INSTRUMENT].NAZWA_INSTRUMENT AS SPECJALNOSC,

        (SELECT TOP 1 [KONCERT].DATA_KONCERT --PIERWSZY
            FROM
                [KONCERT] INNER JOIN [WYKONANIE]
                    ON [KONCERT].ID_KONCERT =  [WYKONANIE].ID_KONCERT,
                [WYKONANIE] INNER JOIN [CZLONEK]
                    ON [WYKONANIE].ID_ORKIESTRA = [CZLONEK].ID_ORKIESTRA,
                [CZLONEK] INNER JOIN [MUZYK]
                    ON [CZLONEK].PESEL_MUZYK = [MUZYK].PESEL_MUZYK
            WHERE
                ([MUZYK].IMIE_MUZYK + ' ' + [MUZYK].NAZWISKO_MUZYK) = INSTRUMENTALISTA
            ORDER BY [KONCERT].DATA_KONCERT ASC )
        || ' / ' ||
        (SELECT TOP 1 [KONCERT].DATA_KONCERT  -- OSTATNI
            FROM
                [KONCERT] INNER JOIN [WYKONANIE]
                    ON [KONCERT].ID_KONCERT =  [WYKONANIE].ID_KONCERT,
                [WYKONANIE] INNER JOIN [CZLONEK]
                    ON [WYKONANIE].ID_ORKIESTRA = [CZLONEK].ID_ORKIESTRA,
                [CZLONEK] INNER JOIN [MUZYK]
                    ON [CZLONEK].PESEL_MUZYK = [MUZYK].PESEL_MUZYK
            WHERE
                ([MUZYK].IMIE_MUZYK + ' ' + [MUZYK].NAZWISKO_MUZYK) = INSTRUMENTALISTA
            ORDER BY [KONCERT].DATA_KONCERT DESC ) AS 'PIERWSZY/OSTATNI KONCERT'

    FROM
        [CZLONEK],
        [MUZYK],
        [ORKIESTRA] RIGHT JOIN [WYKONANIE]
            ON [ORKIESTRA].ID_ORKIESTRA = [WYKONANIE].ID_ORKIESTRA,
        [MUZYK] LEFT JOIN [INSTRUMENT]
            ON [MUZYK].PESEL_MUZYK = [INSTRUMENT].PESEL_MUZYK

    WHERE
        [MUZYK].PESEL_MUZYK = [CZLONEK].PESEL_MUZYK
        AND [ORKIESTRA].ID_ORKIESTRA = [CZLONEK].ID_ORKIESTRA

    GROUP BY INSTRUMENTALISTA, ORKIESTRY, SPECJALNOSC
ORDER BY INSTRUMENTALISTA ASC;

COMMENT ON VIEW WSPOLPRACA IS
    'Widok przedstawiajacy z jakimi orkiestrami, ile razy i od jakiego czasu dana osoba wspolpracuje';

---

CREATE VIEW TWORCZOSC AS
    SELECT
        [UTWOR].NAZWA_UTWOR AS KOMPOZYCJA,
        ([KOMPOZYTOR].IMIE_KOMPOZYTOR + ' ' + [KOMPOZYTOR].NAZWISKO_KOMPOZYTOR) AS KOMPOZYTOR,
        CASE
            WHEN [UTWOR].DATA_SKOMPONOWANIA >=1400 AND [UTWOR].DATA_SKOMPONOWANIA <1600
                THEN 'RENESANS'
            WHEN [UTWOR].DATA_SKOMPONOWANIA >=1600 AND [UTWOR].DATA_SKOMPONOWANIA <1750
                THEN ' BAROK'
            WHEN [UTWOR].DATA_SKOMPONOWANIA >=1750 AND [UTWOR].DATA_SKOMPONOWANIA <1800
                THEN 'KLASYCYZM'
            WHEN [UTWOR].DATA_SKOMPONOWANIA >=1800 AND [UTWOR].DATA_SKOMPONOWANIA <1900
                THEN 'ROMANTYZM'
            WHEN [UTWOR].DATA_SKOMPONOWANIA >=1900 AND [UTWOR].DATA_SKOMPONOWANIA <1975
                THEN 'XX WIEK'
            WHEN [UTWOR].DATA_SKOMPONOWANIA >=1975
                THEN 'WPOLCZESNOSC'
            ELSE 'SREDNIOWIECZE' END AS EPOKA,
        [UTWOR].DATA_SKOMPONOWANIA - YEAR([KOMPOZYTOR].DATA_URODZENIA_KOMPOZYTOR) AS WIEK_KOMPOZYTORA

    FROM
        [UTWOR] RIGHT JOIN [KATALOG_DZIEL]
            ON [UTWOR].ID_UTWOR = [KATALOG_DZIEL].ID_UTWOR,
        [KOMPOZYTOR] RIGHT JOIN [KATALOG_DZIEL]
            ON [KOMPOZYTOR].PESEL_KOMPOZYTOR = [KATALOG_DZIEL].PESEL_KOMPOZYTOR;

COMMENT ON VIEW TWORCZOSC IS
    'Widok przedstawiajacy spis utworo, w jakich epokach powstaly i ile lat mial kompozytor gdy go stworzyl';

--- LICZNIK
/*
CREATE SEQUENCE "ARCHIWUM_S"
    START WITH 1
    INCREMENT BY 1
    MAXVALUE 1000;
*/


---------------
--- PROCEDURY
----------------

CREATE PROCEDURE [SIKER].GRYWANIE ( IN PESEL_IN CHAR(11))
    BEGIN
        DECLARE PESEL CHAR(11);
        DECLARE IMIE VARCHAR(32);
        DECLARE NAZWISKO VARCHAR(32);
        DECLARE NAZWA VARCHAR(64);
        DECLARE ORKIESTRY TEXT;

        DECLARE LICZNIK INTEGER;

        DECLARE KURSOR CURSOR FOR (
            SELECT [ORKIESTRA].NAZWA_ORKIESTRA
            FROM
                [ORKIESTRA] INNER JOIN [CZLONEK]
                    ON [ORKIESTRA].ID_ORKIESTRA = [CZLONEK].ID_ORKIESTRA,
                [MUZYK] INNER JOIN [CZLONEK]
                    ON [MUZYK].PESEL_MUZYK = [CZLONEK].PESEL_MUZYK
            WHERE [MUZYK].PESEL_MUZYK = PESEL_IN
                AND [MUZYK].PESEL_MUZYK = [CZLONEK].PESEL_MUZYK
                AND [CZLONEK].ID_ORKIESTRA = [ORKIESTRA].ID_ORKIESTRA
        );

            SET IMIE = (SELECT [MUZYK].IMIE_MUZYK
                FROM [MUZYK]
                WHERE [MUZYK].PESEL_MUZYK = PESEL_IN);
            SET NAZWISKO = (SELECT [MUZYK].NAZWISKO_MUZYK
                FROM [MUZYK]
                WHERE [MUZYK].PESEL_MUZYK = PESEL_IN);

        MESSAGE 'Osoba ' + IMIE + ' ' + NAZWISKO + ' wystepuje z nastepujacymi orkiestrami:\n' TO CLIENT;

        SET LICZNIK = 0;
        OPEN KURSOR;
        petla: LOOP
            FETCH NEXT KURSOR INTO ORKIESTRY;
            IF SQLCODE <> 0
                THEN LEAVE petla;
            ENDIF;
            SET LICZNIK = LICZNIK + 1;
            MESSAGE LICZNIK || ') ' || ORKIESTRY || '\n' TO CLIENT;
        END LOOP;
        CLOSE KURSOR
END;

COMMENT ON PROCEDURE GRYWANIE IS
    'Procedura zwracajaca w formie komunikatu zespoly z jakimi wystepuje danyh muzyk. Jako argument wejsciowy przyjmuje pesel.';
---

CREATE PROCEDURE [SIKER].PRZESZLOSC_MUZYKA (IN PESEL_IN CHAR(11))
    BEGIN
        DECLARE PESEL CHAR(11);
        DECLARE DANE_OSOBOWE VARCHAR(64);
        DECLARE NAZWA VARCHAR(64);
        DECLARE ORKIESTRY TEXT;

        DECLARE LICZNIK INTEGER;

        DECLARE KURSOR CURSOR FOR(
            SELECT [ORKIESTRA_ARCHIWUM].NAZWA_ORKIESTRA_A
            FROM [ORKIESTRA_ARCHIWUM]
            WHERE [ORKIESTRA_ARCHIWUM].PESEL_MUZYK_A = PESEL_IN

            EXCEPT

            SELECT [ORKIESTRA].NAZWA_ORKIESTRA
            FROM
                [ORKIESTRA] INNER JOIN [CZLONEK]
                    ON [ORKIESTRA].ID_ORKIESTRA = [CZLONEK].ID_ORKIESTRA,
                [MUZYK] INNER JOIN [CZLONEK]
                    ON [MUZYK].PESEL_MUZYK = [CZLONEK].PESEL_MUZYK
            WHERE [MUZYK].PESEL_MUZYK = PESEL_IN
        );

        SET DANE_OSOBOWE = (SELECT [ORKIESTRA_ARCHIWUM].OSOBA_A
            FROM [ORKIESTRA_ARCHIWUM]
            WHERE [ORKIESTRA_ARCHIWUM].PESEL_MUZYK_A = PESEL_IN
            GROUP BY [ORKIESTRA_ARCHIWUM].OSOBA_A);


        MESSAGE 'OSOBA ' + DANE_OSOBOWE + ' nie wystepuje juz z nastepujacymi orkiestrami:\n' TO CLIENT;

        SET LICZNIK = 0;
        OPEN KURSOR;
        PETLA: LOOP
            FETCH NEXT KURSOR INTO ORKIESTRY;
            IF SQLCODE <> 0
                THEN IF LICZNIK = 0
                        THEN MESSAGE 'BRAK' TO CLIENT;
                    ENDIF;
                LEAVE PETLA;
            ENDIF;
            SET LICZNIK = LICZNIK + 1;
            MESSAGE LICZNIK || ') ' || ORKIESTRY TO CLIENT;
        END LOOP;
        CLOSE KURSOR
END;

COMMENT ON PROCEDURE PRZESZLOSC_MUZYKA IS
    'Procedura zwracajaca w formie komunikatu wykaz zespolow z jakimi nie wpolpracuje juz muzyk. Jako argument wejsciowy przyjmuje pesel.';


CREATE PROCEDURE [SIKER].PODZIAL_INSTRUMENTOW (IN ORK INTEGER)
    BEGIN
        DECLARE ILOSC INTEGER;
        DECLARE NAZWA CHAR(32);
        DECLARE TYP CHAR(1);
        DECLARE TYP_I CHAR(1);
        DECLARE LICZNIK INT;

        DECLARE KURSOR_TYP CURSOR FOR(
            SELECT [INSTRUMENT].TYP_INSTRUMENT
            FROM
                [INSTRUMENT] INNER JOIN [CZLONEK]
                    ON [INSTRUMENT].PESEL_MUZYK = [CZLONEK].PESEL_MUZYK,
            WHERE ORK = [CZLONEK].ID_ORKIESTRA
            GROUP BY [INSTRUMENT].TYP_INSTRUMENT);

        DECLARE KURSOR_NAZWA CURSOR FOR(
            SELECT [INSTRUMENT].NAZWA_INSTRUMENT, COUNT([INSTRUMENT].ID_INSTRUMENT), [INSTRUMENT].TYP_INSTRUMENT
            FROM
                [INSTRUMENT] INNER JOIN [CZLONEK]
                    ON [INSTRUMENT].PESEL_MUZYK = [CZLONEK].PESEL_MUZYK,
            WHERE ORK = [CZLONEK].ID_ORKIESTRA
            GROUP BY [INSTRUMENT].NAZWA_INSTRUMENT, [INSTRUMENT].TYP_INSTRUMENT);

        SET NAZWA = (SELECT [ORKIESTRA].NAZWA_ORKIESTRA FROM [ORKIESTRA] WHERE ORK=ID_ORKIESTRA);
        MESSAGE 'INSTRUMENTY ORKIESTRY "' || NAZWA || '" ZAWIERAJA SKLAD:' TO CLIENT;

        SET LICZNIK =0;

        OPEN KURSOR_TYP;
        PETLA_TYP: LOOP
            FETCH NEXT KURSOR_TYP INTO TYP;
            IF SQLCODE <> 0
                THEN LEAVE PETLA_TYP;
            ENDIF;
            SET ILOSC = ILOSC_INSTRUMENTOW(ORK, TYP);
            SET LICZNIK = LICZNIK + 1;
            MESSAGE LICZNIK || ') ';
             CASE
                WHEN TYP = 'A' THEN MESSAGE '\nAEROFONY: ' || ILOSC TO CLIENT;
                WHEN TYP = 'C' THEN MESSAGE '\nCHORDOFONY: ' || ILOSC TO CLIENT;
                WHEN TYP = 'I' THEN MESSAGE '\nIDIOFONY: ' || ILOSC TO CLIENT;
                WHEN TYP = 'M' THEN MESSAGE '\nMEMBRANOFONY: ' || ILOSC TO CLIENT;
                WHEN TYP = 'E' THEN MESSAGE '\nELEKTROFONY: ' || ILOSC TO CLIENT;
             END;

            OPEN KURSOR_NAZWA;
            PETLA_NAZWA:LOOP
                FETCH NEXT KURSOR_NAZWA INTO NAZWA, ILOSC, TYP_I;
                IF SQLCODE <> 0
                    THEN LEAVE PETLA_NAZWA;
                ENDIF;
                IF TYP = TYP_I THEN
                    MESSAGE NAZWA || ' w ilosci: ' || ILOSC TO CLIENT;
                ENDIF;
            END LOOP;
            CLOSE KURSOR_NAZWA;

        END LOOP;
        CLOSE KURSOR_TYP;

    END;

COMMENT ON PROCEDURE PODZIAL_INSTRUMENTOW IS
    'Procedura zwracajaca w formie komunikatu ilosciowe zestawienie instrumentow z podzialem na typy';

CREATE PROCEDURE [SIKER].DODAJ_REPERTUAR (IN KOMPOZYCJA INTEGER, IN ORK INTEGER)
    BEGIN
    DECLARE KOMUNIKAT TEXT;

    IF EXISTS (
        SELECT [REPERTUAR].ID_UTWOR, [REPERTUAR].ID_ORKIESTRA
        FROM [REPERTUAR]
        WHERE
            KOMPOZYCJA = [REPERTUAR].ID_UTWOR AND
            ORK = [REPERTUAR].ID_ORKIESTRA )  THEN
            SET @KOMUNIKAT='ORKIESTRA ZAWIERA TEN UTWOR W SWOIM REPERTUARZE';
            MESSAGE KOMUNIKAT TO CLIENT;
    ELSE
            INSERT INTO [REPERTUAR] (ID_UTWOR, ID_ORKIESTRA) VALUES (KOMPOZYCJA, ORK);
            SET KOMUNIKAT='DODANO DO REPERTUARU';
            MESSAGE KOMUNIKAT TO CLIENT;
    ENDIF;
    END;

COMMENT ON PROCEDURE DODAJ_REPERTUAR IS
    'Procedura dodajaca utwor do repertuaru orkiestry i sprawdzajace czy juz nie istneje';



---------------
--- TRIGERY
----------------

CREATE TRIGGER [SIKER].ARCHIWIZACJA_CZLONKOW
    AFTER INSERT ,DELETE ,UPDATE ON [CZLONEK]
    REFERENCING NEW AS NEWS
    FOR EACH ROW

    BEGIN
        DECLARE PESEL CHAR(11); -- PESEL_MUZYK
        DECLARE ZESPOL INT; -- ID_ORKIESTRA
        DECLARE NAZWA CHAR(64); -- NAZWA_ORKIESTRA
        DECLARE NAME CHAR(64); -- IMIE I NAZWISKO

        SET PESEL = [NEWS].PESEL_MUZYK;
        SET ZESPOL = [NEWS].ID_ORKIESTRA;

        SET NAZWA = (
            SELECT [ORKIESTRA].NAZWA_ORKIESTRA
            FROM [ORKIESTRA]
            WHERE [ORKIESTRA].ID_ORKIESTRA = [NEWS].ID_ORKIESTRA);
        SET NAME = (
            SELECT [MUZYK].IMIE_MUZYK + ' ' + [MUZYK].NAZWISKO_MUZYK
            FROM [MUZYK]
            WHERE [NEWS].PESEL_MUZYK = [MUZYK].PESEL_MUZYK);

        INSERT INTO [ORKIESTRA_ARCHIWUM] (ID_ORKIESTRA_A, PESEL_MUZYK_A, NAZWA_ORKIESTRA_A, OSOBA_A)
            VALUES (ZESPOL, PESEL, NAZWA, NAME);
END;

COMMENT ON TRIGGER ARCHIWIZACJA_CZLONKOW IS
    'TRIGGER dodajacy do archiwizujacy dane o czlonkach orkiestr';

---

CREATE TRIGGER [SIKER].WYSTEP_GOSCINNY
    AFTER INSERT, UPDATE ON [SOLISTA]

    REFERENCING NEW AS NEWS
    FOR EACH ROW

    BEGIN
        DECLARE UTWOR_tmp VARCHAR(32);
        DECLARE KONCERT_tmp VARCHAR(32);
        DECLARE ORKIESTRA_tmp VARCHAR(64);
        DECLARE SOLISCI_tmp VARCHAR(256);
        DECLARE DATA_tmp DATE;

        SET UTWOR_tmp = (
            SELECT [UTWOR].NAZWA_UTWOR
            FROM
                [UTWOR] INNER JOIN [WYKONANIE]
                    ON [UTWOR].ID_UTWOR = [WYKONANIE].ID_UTWOR
            WHERE [NEWS].ID_WYKONANIE = [WYKONANIE].ID_WYKONANIE
        );

        SET KONCERT_tmp = (
            SELECT [KONCERT].NAZWA_KONCERT
            FROM
                [WYKONANIE] INNER JOIN [KONCERT]
                    ON [WYKONANIE].ID_KONCERT = [KONCERT].ID_KONCERT
            WHERE [NEWS].ID_WYKONANIE = [WYKONANIE].ID_WYKONANIE
        );

        SET ORKIESTRA_tmp = (
            SELECT [ORKIESTRA].NAZWA_ORKIESTRA
            FROM
                [WYKONANIE] INNER JOIN [ORKIESTRA]
                    ON [WYKONANIE].ID_ORKIESTRA = [ORKIESTRA].ID_ORKIESTRA
            WHERE [NEWS].ID_WYKONANIE = [WYKONANIE].ID_WYKONANIE
        );

         SET DATA_tmp = (
            SELECT [KONCERT].DATA_KONCERT
            FROM
                [WYKONANIE] INNER JOIN [KONCERT]
                    ON [WYKONANIE].ID_KONCERT = [KONCERT].ID_KONCERT
            WHERE [NEWS].ID_WYKONANIE = [WYKONANIE].ID_WYKONANIE
        );

        SET SOLISCI_tmp = (
            SELECT LIST([MUZYK].IMIE_MUZYK + ' ' + [MUZYK].NAZWISKO_MUZYK, ',')
                FROM
                    [WYKONANIE] INNER JOIN [SOLISTA]
                        ON [WYKONANIE].ID_WYKONANIE = [SOLISTA].ID_WYKONANIE,
                    [SOLISTA] INNER JOIN [MUZYK]
                        ON [SOLISTA].PESEL_MUZYK = [MUZYK].PESEL_MUZYK
                WHERE [NEWS].ID_WYKONANIE = [WYKONANIE].ID_WYKONANIE
        );

        INSERT INTO [SOLISCI_ARCHIWUM] (UTWOR_A, KONCERT_A, ORKIESTRA_A, SOLISCI_A, DATA_A)
            VALUES ( UTWOR_tmp, KONCERT_tmp, ORKIESTRA_tmp, SOLISCI_tmp, DATA_tmp);

    END;

COMMENT ON TRIGGER WYSTEP_GOSCINNY IS
    'TRIGGER dodajacy do archiwum dane o solistach wystepujacych na koncertach';

---

CREATE TRIGGER [SIKER].KONTROLA_KONCERT
    BEFORE INSERT ,UPDATE
    ORDER 1 ON [WYKONANIE]
    REFERENCING NEW AS NEWS
    FOR EACH ROW

    BEGIN
        DECLARE CZAS INTEGER;
        DECLARE POBRANE INTEGER;
        DECLARE KURSOR CURSOR FOR
            (SELECT [UTWOR].CZAS_UTWOR
                FROM [UTWOR] INNER JOIN [WYKONANIE]
                    ON [UTWOR].ID_UTWOR = [WYKONANIE].ID_UTWOR
                WHERE
                    [NEWS].ID_UTWOR = [UTWOR].ID_UTWOR AND
                    [NEWS].ID_WYKONANIE = [WYKONANIE].ID_WYKONANIE);
        SET CZAS = 0;
        OPEN KURSOR;
        PETLA:LOOP
            FETCH KURSOR INTO POBRANE;
            IF SQLCODE <> 0 THEN
                LEAVE PETLA;
            ENDIF;
            SET CZAS = CZAS + POBRANE
        END LOOP PETLA;
        CLOSE KURSOR;

        IF CZAS > 300 THEN
            MESSAGE 'KONCERT PRZEKRACZA LIMIT CZASOWY' TO CLIENT;
            DELETE FROM [KONCERT] WHERE [KONCERT].ID_KONCERT = [NEWS].ID_KONCERT;
        ENDIF;

    END;

COMMENT ON TRIGGER KONTROLA_KONCERT IS
    'TRIGGER wysylajacy komunikat do organizatora ze koncert przekracza czas komfortowego sluchania';


---------------
--- FUNKCJE
----------------

CREATE FUNCTION [SIKER].NAJAKTYWNIEJSZY_MUZYK (IN MAX INTEGER)
    RETURNS CHAR(64)

    BEGIN
        DECLARE LICZNIK INTEGER;
        DECLARE RETURN_NAME CHAR(64);
        DECLARE ILOSC INTEGER;

        DECLARE LIDER CURSOR FOR(
            SELECT [MUZYK].IMIE_MUZYK + ' ' + [MUZYK].NAZWISKO_MUZYK, COUNT([WYKONANIE].ID_WYKONANIE) AS ILOSC
                INTO RETURN_NAME, ILOSC
            FROM
                [MUZYK] INNER JOIN [CZLONEK]
                    ON [MUZYK].PESEL_MUZYK = [CZLONEK].PESEL_MUZYK,
                [CZLONEK] INNER JOIN [ORKIESTRA]
                    ON [CZLONEK].ID_ORKIESTRA = [ORKIESTRA].ID_ORKIESTRA,
                [ORKIESTRA] INNER JOIN [WYKONANIE]
                    ON [ORKIESTRA].ID_ORKIESTRA = [WYKONANIE].ID_ORKIESTRA
            GROUP BY [MUZYK].IMIE_MUZYK, [MUZYK].NAZWISKO_MUZYK
            ORDER BY ILOSC DESC
        );

        SET NAJWIECEJ = 0;
        SET LICZNIK = 1;
        MESSAGE 'RANKING NAJAKTYWNIEJSZYCH MUZYKOW \n OTO NAJLEPSZYCH ' || MAX || ' MUZYKOW:' TO CLIENT;

        OPEN LIDER;
        PETLA: LOOP
            FETCH NEXT LIDER INTO RETURN_NAME, ILOSC;
            IF SQLCODE <> 0 THEN
                LEAVE PETLA
            ENDIF;

            IF LICZNIK < MAX + 1 THEN
                MESSAGE LICZNIK || ') ' || RETURN_NAME || ' - ZAGRAL -  ' || ILOSC || ' KONCERTOW' TO CLIENT;
            ENDIF;
            SET LICZNIK = LICZNIK + 1;
        END LOOP;
        CLOSE LIDER;
        RETURN RETURN_NAME; -- osoba z najwieksza iloscia
    END;

COMMENT ON PROCEDURE NAJAKTYWNIEJSZY_MUZYK IS
    'Wysyla w formie komunikatu liste najaktywniejszych muzykow i zwraca osobe w kolejnosci okreslonej przez argument wejsciowy';
---

CREATE FUNCTION [SIKER].KONCERTOWANIE (IN PESEL_IN CHAR(11), DATE_IN DATE)
    RETURNS INT

    BEGIN
        DECLARE ILOSC INT;

        SET ILOSC = (
            SELECT COUNT ([KONCERT].DATA_KONCERT)
            FROM
                [MUZYK] INNER JOIN [CZLONEK]
                    ON [MUZYK].PESEL_MUZYK = [CZLONEK].PESEL_MUZYK,
                [WYKONANIE] INNER JOIN [KONCERT]
                    ON [WYKONANIE].ID_KONCERT = [KONCERT].ID_KONCERT
            WHERE
                [MUZYK].PESEL_MUZYK = pesel_IN AND
                [CZLONEK].ID_ORKIESTRA = [WYKONANIE].ID_ORKIESTRA AND
                [KONCERT].DATA_KONCERT >= DATE_IN
        );
        RETURN ILOSC;
    END ;

COMMENT ON PROCEDURE KONCERTOWANIE IS
    'Zwraca ile koncertow dana osoba grala po danej dacie';

---

CREATE FUNCTION [SIKER].CZAS_NA_SCENIE (IN PESEL CHAR(11), IN ORKIESTRA INTEGER)
    RETURNS INTEGER
    DETERMINISTIC
    BEGIN
        DECLARE CZAS INTEGER;
        DECLARE POBRANE INTEGER;
        DECLARE KURSOR  CURSOR FOR (
            SELECT [UTWOR].CZAS_UTWOR
            FROM
                [UTWOR] INNER JOIN [WYKONANIE]
                    ON [UTWOR].ID_UTWOR = [WYKONANIE].ID_UTWOR,
                [WYKONANIE] INNER JOIN [ORKIESTRA]
                    ON [WYKONANIE].ID_ORKIESTRA = [ORKIESTRA].ID_ORKIESTRA,
                [ORKIESTRA] INNER JOIN [CZLONEK]
                    ON [ORKIESTRA].ID_ORKIESTRA = [CZLONEK].ID_ORKIESTRA,
                [CZLONEK] INNER JOIN [MUZYK]
                    ON [CZLONEK].PESEL_MUZYK = [MUZYK].PESEL_MUZYK
            WHERE
                PESEL = [MUZYK].PESEL_MUZYK AND
                ORK = [WYKONANIE].ID_ORKIESTRA

            UNION

            SELECT [UTWOR].CZAS_UTWOR
            FROM
                [UTWOR] INNER JOIN [WYKONANIE]
                    ON [UTWOR].ID_UTWOR = [WYKONANIE].ID_UTWOR,
                [WYKONANIE] INNER JOIN [SOLISTA]
                    ON [WYKONANIE].ID_WYKONANIE = [SOLISTA].ID_WYKONANIE
            WHERE
                PESEL = [SOLISTA].PESEL_MUZYK AND
                ORK = [WYKONANIE].ID_ORKIESTRA);

        SET CZAS = 0;
        OPEN KURSOR;
        PETLA:LOOP
            FETCH NEXT KURSOR INTO POBRANE;
            IF SQLCODE <> 0 THEN
                LEAVE PETLA;
            ENDIF;
            SET CZAS = CZAS + POBRANE;
        END LOOP PETLA;
        CLOSE KURSOR;
    MESSAGE 'CZAS SPEDZONY NA SCENIE: \N' TO CLIENT;
            RETURN CZAS;
END;

COMMENT ON PROCEDURE CZAS_NA_SCENIE IS
    'Funkcja zwraca czas jaki muzyk spedzil z dana orkiestra na scenie';

---

CREATE FUNCTION [SIKER].ILOSC_INSTRUMENTOW (IN ORK INTEGER, IN TYP CHAR(1))
    RETURNS INT
    DETERMINISTIC
    BEGIN
        DECLARE ILOSC INTEGER;
        DECLARE POBRANY INTEGER;

        DECLARE KURSOR CURSOR FOR(
            SELECT COUNT([INSTRUMENT].ID_INSTRUMENT)
            FROM
                [ORKIESTRA] INNER JOIN [CZLONEK]
                    ON [ORKIESTRA].ID_ORKIESTRA = [CZLONEK].ID_ORKIESTRA,
                [CZLONEK] INNER JOIN [MUZYK]
                    ON [MUZYK].PESEL_MUZYK=[CZLONEK].PESEL_MUZYK,
                [MUZYK] INNER JOIN [INSTRUMENT]
                    ON [MUZYK].PESEL_MUZYK = [INSTRUMENT].PESEL_MUZYK
            WHERE
                ORK = [CZLONEK].ID_ORKIESTRA AND
                TYP = [INSTRUMENT].TYP_INSTRUMENT);

        SET ILOSC = 0;
        OPEN KURSOR;
        PETLA:LOOP
            FETCH NEXT KURSOR INTO POBRANY;
            IF SQLCODE <> 0 THEN
                LEAVE PETLA;
            ENDIF;
            SET ILOSC = ILOSC + POBRANY;
        END LOOP PETLA;
        RETURN ILOSC;
    END;

COMMENT ON PROCEDURE ILOSC_INSTRUMENTOW IS
    'Funkcja zwraca ilosc instrumentow danego typu z danej orkiestry';