1. Прости заявки

    Езикът за създаване на заявки към релационни СУБД
    (Система за Управление на Бази от Данни) - SQL

    СУБД = DBMS (Database Management System)

    SQL - Structured Query Language

    В името на примерите, дефинираме релацията - Movie(title, year, length, incolor, studioName, producerC#)

    Примерна заявка:
        SELECT *
        FROM Movie
        WHERE studioName='Disney' AND year=1990

        - във FROM клаузата - изброяваш релациите, към които се отнася заявката
        - в WHERE клаузата - задаваш условията, които трябва да бъдат удовлетворени от кортежите, за да отговорят на заявката (кортеж = query ?)
        - SELECT - задава кои атрибути на кортежите (удовлетворяващи условията от WHERE клаузата) да бъдат изведени

    Сравняване на низове:
        - С оператор за сравнение '='
        - С шаблон чрез ключовата дума LIKE
                s LIKE p (s - низ, p - шаблон)
                шаблони - низове, в които могат да се използват
                    - '%' - последователност от 0 или повече символи
                    - '_' - 1 произволен символ (като . в regex)
                    - отрицанието на LIKE е NOT LIKE

    DATETIME (???)

    NULL - стойност на атрибут, когато:
        - не знаем, каква трябва да е стойността или няма смислена стойност, която да се зададае
        - NB: може изрично да се зададе определени атрибути да не могат да приемат стойност NULL
        - NULL стойностите не удовлетворяват нито едно условие освен IS NULL
        - резултати от сравнение - TRUE или FALSE; Върху стойности с NULL - UNKNOWN (виж табличката в слайдовете за повече инф.)

    Сортиране на резултата:
        - Указва се чрез клаузата ORDER BY
        - ORDER BY <list of attributes or expressions> [ASC|DESC]
        - Пример:
            SELECT *
            FROM Movie, MovieExec
            WHERE "PRODUCERC#"="CERT#"
            ORDER BY title ASC;
        - NB: ASC by default

2. Заявки върху две или повече релациите

    Пример:
        Movie(title, year, length, incolor, studioName, producerC#)
        MovieExec(name, address, cert#, networth)

        SELECT name
        FROM Movie, MovieExec
        WHERE title='Star Wars' AND producerC#=cert#;

    При дублиране на имена на атрибути:
        Ако имаме релациите:
        MovieStar(name, address, gender, birthdate)
        MovieExec(name, address, cert#, networth)

        Тогава вместо:
        SELECT name
        FROM MovieStar, MovieExec

        Ползваме:
        SELECT MovieStar.name, MovieExec.name
        FROM MovieStar, MovieExec

    Обединение, сечение и разлика:

        SQL предлага оператори, с които можем да изпълняваме едноименните операции на релационната алгебра - UNION, INTERSECT, EXCEPT

        UNION - пример:
            Ако имаме релациите:
            Movie(title, year, length, incolor, studioName, producerc#)
            StarsIn(movieTitle, movieYear, starName)

            (SELECT title, year FROM Movie)
            UNION
            (SELECT movieTitle, movieYear FROM StarsIn)

            NB: двете заявки трябва да връщат таблици, за които:
                - Броят на колоните е еднакъв
                - Колоните от двете таблици са със съвместими типове
                - Имената НЕ е нужно да съвпадат

        INTERSECT - пример:
            Ако имаме релациите:
            MovieStar(name, address, gender, birthdate)
            MovieExec(name, address, cert#, networth)

            (SELECT name, address FROM MovieStar WHERE gender='F')
            INTERSECT
            (SELECT name, address FROM MovieExec WHERE networth > 10000000)

        EXCEPT - пример:
            Ако имаме релациите:
            MovieStar(name, address, gender, birthdate)
            MovieExec(name, address, cert#, networth)

            (SELECT name, address FROM MovieStar)
            EXCEPT
            (SELECT name, address FROM MovieExec)
            ORDER BY address

        NB: Релациите са мултимножества
            - Отстраняване на повторенията чрез ключовата дума DISTINCT
            - UNION, INTERSECT и EXCEPT - повтарящите се кортежи се премахват автоматично. За запазване на повтарящите се кортежи се използват - UNION ALL, INTERSECT ALL, EXCEPT ALL

3. Подзаявки

    Заявки, които са част от други заявки

    Подзаявките се ограждат със ()

    Подзаявките могат да връщат:
        - единствена скаларна стойност
        - списък от стойности
        - релация

    Нека R е релация, а L е списък от стойности:
    - EXISTS(R) - връща TRUE, ако R има кортежи
    - s IN (L) - връща TRUE, ако s е сред елементите на L
    - s NOT IN (L) - връща TRUE, ако s НЕ е сред елементите на L
    - s > ALL(L) - връща TRUE, ако s е по-голям от всеки един елемент на L
    - s > ANY(L) - връща TRUE, ако s е по-голям от поне 1 от елементите на L

    Пример:
        Имаме релациите:
        MovieStar(name, address, gender, birthdate)
        StarsIn(movieTitle, movieYear, starName)

        - () връща скалар:
        SELECT *
        FROM StarsIn
        WHERE starname = (SELECT name
                                            FROM MovieStar
                                            WHERE address='X path');

        - () връща списък:
        SELECT *
        FROM StarsIn
        WHERE starName in (SELECT name
                                            FROM MovieStar
                                            WHERE gender='M');

    Корелативни подзаявки:
    - Това е подзаявка, която има зависимост от заявката, в която участва.

    Пример:
        Заявка, която извежда заглавия на филми, които са използвани в поне два филма (от различни години):
        SELECT DISTINCT title
        FROM movie M
        WHERE year < ANY (SELECT year
                                            FROM movie
                                            WHERE title = M.title);

    Подзаявки във FROM клаузата:

        Пример:
        SELECT movieTitle, starName, birthdate
        FROM StarsIn s, (SELECT name, birthdate
                                        FROM MovieStar
                                        WHERE gender='M') t
        WHERE s.starname=t.name;

4. Свързване на таблици

    SELECT *
    FROM MovieExec m1, Movie m2
    WHERE m1.PrCert# = m2.PrCert#

    е същото като

    SELECT *
    FROM MovieExec m1 JOIN Movie m2
        ON m1.PrCert# = m2.PrCert#

    CROSS JOIN:
        Синтансис:
        SELECT *
        FROM MovieExec CROSS JOIN Movie;

        - прави точно каквото очакваш да прави - декартово произведение на елементите от MovieExec с елементите от Movie

    inner JOIN (Theta Join):
        Синтаксис:
        SELECT *
        FROM MovieExec m1 [inner] JOIN Movie m2
            ON m1.PrCert#=m2.PrCert#;

        - все едно сечение на многествата от елементите на m1 и m2

    LEFT JOIN:
        Синтаксис:
        SELECT *
        FROM MovieExec m1 LEFT [outer] JOIN Movie m2
            ON m1.PrCert# = m2.PrCert#;

        - сечението на двете множества + елементите от m1, които не са обединени с елементи на m2, но с попълнени NULL стойности на местата, където би трябвало да стоят колоните от m2

    RIGHT JOIN:
        Синтаксис:
        SELECT *
        FROM MovieExec m1 RIGHT [outer] JOIN Movie m2
            ON m1.PrCert# = m2.PrCert#;

        - аналогично на LEFT JOIN но + елементите на m2, които не са обединени с елементи на m1, но с попълнени NULL стойности на местата, където би трябвало да стоят колоните от m1

    FULL JOIN:
        Синтаксис:
        SELECT *
        FROM MovieExec m1 FULL [outer] JOIN Movie m2
            ON m1.PrCert# = m2.PrCert#;

        - резултатът от LEFT JOIN обединен с резултата от RIGHT JOIN

5. Групиране и агрегация

    Агрегатни функции:
    - SUM (expression)
    - AVG (expression)
    - MIN (expression)
    - MAX (expression)
    - COUNT (expression)

    Използване на DISTINCT:
        Пример:
        COUNT (DISTINCT column)

    Примери:
        SELECT AVG(netWorth)
        FROM MovieExec

        SELECT COUNT(*)
        FROM StarsIn

        SELECT COUNT(DISTINCT starName)
        FROM StarsIn

        SELECT MAX(Quantity * UnitPrice * (1 - Discount))
        FROM "Order Details"

    Групиране:
        GROUP BY

        Пример:
        SELECT studioName, SUM(length)
        FROM Movie
        GROUP BY studioName

        Правила при групиране:
        - могат да се групират по един или няколко атрибута (израза)
        - при групиране, в SELECT може да стоят само атрибутите, по които групираме и/или агрегатни функции
        - не можем да имаме агрегатна функция в WHERE клаузата. Може да има само обикновени функции като day(date), year(date) и т.н.

        HAVING:
            Пример:
            SELECT studioName, SUM(length)
            FROM Movie
            GROUP BY studioName
            HAVING SUM(length) > 1000

    NULL стойности в контекста на групиране и агрегация:
        NULL стойностите се игнорират при агрегиране
            - NULL стойност не може да бъде нито MIN, нито MAX
            - NULL стойност не влияе на сумата на стойностите по даден атрибут
            - При COUNT се броят само стойности, различни от NULL
            - Разлика между COUNT(*) и COUNT(A) (???)
        NULL стойностите НЕ се игнорират при групиране
        NULL стойностите могат да образуват група

    Ред на клаузите в една SQL заявка:
        SELECT [DISTINCT] ...
        FROM ...
        ... JOIN ... ON ...
        WHERE ...
        GROUP BY ...
        HAVING ...
        ORDER BY ...

6. Модификация на БД

    Добавяне на кортежи:
        INSERT INTO R(A1, ..., An) VALUES(v1, ..., vn)
            - default value - NULL

        Пример:
        INSERT INTO Battles(name, date)
        VALUES('Battle of the Philippine Sea', '1944-06-19'); #няма да стане по принцип, защото е твърде дълго името за полето в таблицата
        Ако спазим последователността на атрибутиъе от релацията, може накратко:
        INSERT INTO Battles VALUES('Some Battle', '1944-06-19');

        Добавяне на повече от един кортеж:
            INSERT INTO R(A1, ..., An) <подзаявка>;
            Пример:
            INSERT INTO Studio(name)
                SELECT DISTINCT studioName FROM Movie
                WHERE studioName NOT IN
                    (SELECT name FROM Studio);
            # добавя всички студиа, споменати в релацията Movie(...), но липсващи в Studio(...)

    Изтриване на кортежи:
        DELETE FROM R WHERE <условие>;

        Пример:
        DELETE FROM Battles
        WHERE name =
            'Some Battle';

    Промяна на стойностите в кортеж:
        UPDATE R SET attribute1=formula1, ...
            WHERE <условие>;
        Пример:
        UPDATE MovieExec
        SET name = 'Pres. ' || name
        WHERE cert# IN
            (SELECT presc# FROM Studio);

7. Дефиниране на схеми на релации

    Атрибутите имат типове:
        VARCHAR(n) - низ  с дължина до n символа
        CHAR(n) - низ с точно n символа
        INT / INTEGER - цяло число, 32-битово, със знак
        FLOAT / REAL
        DECIMAL(n, d) - дробно число с n цифри, d от тях след дес. запетая
        DATE, TIME, DATETIME
        и др. - специфични за различните бази данни

    Дефиниране на релационна схема:
        CREATE TABLE MovieStar(
            name VARCHAR(30),
            address VARCHAR(255)
            gender CHAR(1),
            birthdate DATE
        );

    Изтриване на релация:
        DROP TABLE R;

    Добавяне на атрибут в релация:
        ALTER TABLE MovieStar ADD phone CHAR(16);

    Изтриване на атрибут в релация:
        ALTER TABLE MovieStar DROP COLUMN phone;

    Задаване на стойност по подразбиране, която не е NULL:
        CREATE TABLE MovieStar(
            ...
            gender CHAR(1) DEFAULT '?',
            regdate DATE DEFAULT GETDATE()
        ); ##### <- така ако не посочим дата, ще се ползва текущата

        ALTER TABLE MovieStar ADD phone CHAR(16)
            DEFAULT 'unlisted';

8. Ограничения

    Ключове и външни ключове
        (!) ако релация има деклариран ключ, то тя не може да съдържа еднакви кортежи

        Деклариране:
            - чрез ключовия израз PRIMARY KEY
            - чрез UNIQUE

        Една таблица може да има само 1 първичен (primary) ключ, но може да има много уникални ключове.

        Деклариране на първичен ключ (PK)
        Пример:
        CREATE TABLE MovieStar(
            name CHAR(30) PRIMARY KEY,
            address VARCHAR(255),
            gender CHAR(1),
            birthdate DATETIME
        );
        или
        CREATE TABLE MovieStar(
            name CHAR(30),
            address VARCHAR(255),
            gender CHAR(1),
            birthdate DATETIME,
            PRIMARY KEY (name)
        );

        Първичен ключ, състоящ се от 2 атрибута, пример:
            CREATE TABLE Movie(
                title VARCHAR(50),
                year INT,
                inColor CHAR(1),
                studioName VARCHAR(50),
                producerC# INT,
                PRIMARY KEY (title, year)
            );
            - ако не се зададе име на ограничението, СУБД му поставя служебно име

            - име на ограничението се поставя с ключовата дума CONSTRAINT
            Пример:
            CREATE TABLE MovieStar(
                name CHAR(30) CONSTRAINT pk_ms PRIMARY KEY,
                address VARCHAR(255),
                gender CHAR(1),
                birthdate DATETIME
            );
            или
            CREATE TABLE MovieStar(
                name CHAR(30),
                address VARCHAR(255),
                gender CHAR(1),
                birthdate DATETIME,
                CONSTRAINT pk_ms PRIMARY KEY (name, birthdate)
            );

        Деклариране на UNIQUE ключове:
            Разлики с PRIMARY KEY:
                - можем да имаме повече от 1 UNIQUE ключ
                - PK забранява NULL стойности, UNIQUE - не (NULL не е равно на нищо, включително и на други NULL стойности)

            Пример:
            CREATE TABLE MovieStar(
                name CHAR(30) CONSTRAINT pk_ms UNIQUE,
                address VARCHAR(255),
                gender CHAR(1),
                birthdate DATETIME
            );
            или
            CREATE TABLE Movie(
                title VARCHAR(50),
                year int,
                length int,
                ...
                CONSTRAINT uk_ms UNIQUE(title, year)
            );

        Деклариране на външни ключове (FOREIGN KEY):
            В SQL можем да декларираме атрибут(и) от една релация (child table) да бъдат външен ключ и да сочат ("реферират") атрибути от втора релация (parent table).
            - допуска се двете таблици да съвпадат
            - реферираните атрибути от втората релация трябва да бъдат декларирани като UNIQUE или PRIMARY KEY ограничения за да участват във FK декларация
            - стойностите на FK, появяващи се в първата релация, трябва да се появяват като стойности на реферираните атрибути в кортежите на втората релация

            - REFERENCES <parent_table> (<parent_table_attributes>)
            Примери:
            CREATE TABLE Studio(
                name CHAR(30) PRIMARY KEY,
                address VARCHAR(255),
                presC# INT REFRENCES MovieExec(cert#)
            );
            CREATE TABLE Studio(
                name CHAR(30) PRIMARY KEY,
                address VARCHAR(255),
                presC# INT CONSTRAINT fk_me REFRENCES MovieExec(cert#)
            );

            - FOREIGN KEY (<child_table_attributes>) REFERENCES <parent_table> (<parent_table_attributes>)
            Примери:
            CREATE TABLE Studio(
                name CHAR(30) PRIMARY KEY,
                address VARCHAR(255),
                presC# INT,
                FOREIGN KEY (presC#) REFERENCES MovieExec(cert#)
            );
            CREATE TABLE Studio(
                name CHAR(30) PRIMARY KEY,
                address VARCHAR(255),
                presC# INT,
                CONSTRAINT fk_me FOREIGN KEY (presC#) REFERENCES MovieExec(cert#)
            );

            Политики за налагане на FK ограниченията:
                Действия, нарушаващи референтната цялост, които не се допускат от СУБД:
                - Вмъкване или промяна на записи от child таблицата, които нарушават референтната цялост
                - Изтриване или промяна на записи от parent таблицата, които нарушават референтната цялост

            Каскадност:
            При промяна или изтриване на записи в parent таблицата, съответноте "детайлни" записи от child таблицата, които биха нарушили ограничението за референтна цялост, съответно се променят и изтриват.

            Установяване на NULL стойности:
            CREATE TABLE Studio(
                name CHAR(30) PRIMARY KEY,
                address VARCHAR(255),
                presC# INT,
                CONSTRAINT fk_me FOREIGN KEY (presC#) REFERENCES MovieExec (cert#)
                    ON DELETE CASCADE
                    ON UPDATE SET NULL
            );
            (!) в MS SQL Server - "Установяване на NULL стойности" не се поддържа:
                [ON DELETE {CASCADE | NO ACTION}]
                [ON UPDATE {CASCADE | NO ACTION}]

    NOT NULL ограничение:
        Пример
            ...
            presC#INT REFERENCE MovieExec(cert#) NOT NULL

    CHECK ограничения на ниво атрибут:
        Примери:
            ...
            presC# INT REFERENCES MovieExec(cert#) CHECK (presC#>=100000)

            или

            ...
            gender CHAR(1) CHECK (gender in ('M', 'F'))

        - би трябвал да може да е произволно WHERE условие

        По-сложен пример:
        CREATE TABLE MovieStar(
            name CHAR(30),
            address VARCHAR(255),
            gender CHAR(1),
            birthdate DATETIME,
            CHECK (gender = 'F' OR name NOT LIKE 'Ms.%')
        );

        или
            ...
            CONSTRAINT ch_ms CHECK (gender = 'F' OR name NOT LIKE 'Ms.%')

    Модификация на ограниченията:

        Изтриване на ограничения:
            ALTER TABLE table_name
            DROP CONSTRAINT constraint_name1,  constraint_name2, ...;

        Добавяне на ограничения:
            ALTER TABLE table_name
            ADD CONSTRAINT constraint_name <table constraint declaration>;

            Пример:
            ALTER TABLE Ships
            ADD CONSTRAINT pk PRIMARY KEY (name);

        Промяна на NOT NULL ограничения:
            - понеже се дефинира само на ниво колона, може да се промени чрез промяна на дефиницията на съответната колона

            Пример:
            ALTER TABLE table
                ALTER COLUMN column_name
                    { new_data_type [ (precision [, scale])]
                        [NULL | NOT NULL] }

    Обобщение:
        Валидни типове ограничения:
        - NOT NULL
        - UNIQUE
        - PRIMARY KEY
        - FOREIGN KEY
        CHECK
        - (!) на ниво таблица не може да се задава NOT NULL

        (в pdf-a с темата има и задачи :))

9. Индекси в MS SQL

    Индекс - обект от базата данни, който помага за подреждането на данните и ускоряването на изпълнението на заявките

    2 вид индекси:
    - clustered
    - nonclustered

    Структура на индексите:
    - реализират се чрез балансирани B-дървета
    - вътрешната структура на индекса зависи от типа му
    - ако индексът е nonclustered, вътрешната му структура се определя от наличието/отсъствието на clustered индекс

    Clustered индекси:
    - данните се подреждат по начин, дефиниран от индекса
    - в листата на дървото се поместват данните, подредени по ключовите атрибути, върху които е форматиран индексът
    - (!) НЕ е задължително ключовите атрибути на индекса да са първичен ключ на релацията
    - една таблица може да има само един clustered индекс, защото данните физически се подреждат на диска според ключовите колони на индекса
    - по подразбиране първичният ключ (PRIMARY KEY) се създава като clustered index #затова често при заявки, не-изискващи подредба на резултатите, все пак резултатното множество е сортирано по PK

    Nonclustered индекси:
    (като индекс в книга)
    - таблицата не се подрежда по структурата на индекса
    - пази се информация (указател/референция) за това, къде точно на диска се намират търсените данни
    - (за разлика от clustered индексите) са отделени от физическото съхранение на данните
    - в листата на дървото се намират указатели (row locators) към мястото на диска, където са разположени реалните данни

    Row locator-ът се различава в зависимост, дали таблицата, върху която се дефинира nonclustered индексът, има вече дефиниран clustered index

    Nonclustered index върху таблица с clustered index:
    - указателят представлява ключовите колони за clustered индекса (clustering key)

    Nonclustered index върху таблица БЕЗ clustered index:
    - указателят представлява номер на страница във файла с данните + номер на ред в страницата

    Кога да създаваме индекси?
    - върху колони като PK или FK, които се използват често в заявки и по тях се извършват съединения
    - за ускоряването на заявки, които търсят интервали от съседни стойности
    - при честа нужда от сортиране на резултатните множества по дадена съвкупност от атрибути - създаване на индекс по атрибутите, участващи в сортирането
    - множество от атрибути, участващи заедно при агрегиране

    Кога да НЕ създаваме индекс?
    - колона с малък брой уникални стойности # например gender в предходните примерни - със стойности само 'M' и 'F'
    - колоната рядко се използва в заявки

    Създаване/изтриване на индекс:
    CREATE [UNIQUE] [CLUSTERED | NONCLUSTERED] INDEX <index_name> ON <table_name> (column_list);
    и
    DROP INDEX <index_name> ON <table_name>;

    Примери:
    CREATE UNIQUE CLUSTERED INDEX ci ON Movie (name, year);
    и
    DROP INDEX ci ON Movie;

10. Изгледи
    Логическо представяне на подмножество от данни, съхраняващи се в една или повече таблици.
    - съхраняват се като SELECT оператори в речника на данните на съответната СУБД
    - в един изглед могат да участват, както таблици, така и други изгледи

    Основна цел - да преобразуват начина, по който се вижда някаква таблица, част от таблица или група от таблици (без да се създават копия на съответните данни).

    За какво се ползват?
    - ограничаване достъпа до данните
    - по-лесно изпълнение на сложни заявки
    - осигуряване на по-голяма независимост по отношение структурата на данните
    - за преименуване на колони

    Типове:
    - прости (simple)
    - сложни (complex)

                                                                simple            complex

    бр. таблици                                     1                     >= 1

    съдържа функции                         не                  да
    съдържа групирани данни         не                  да
    могат да изпълняват DML          да                  не винаги
    (INSERT, UPDATE, DELETE)
    операции върху изгледа

    CREATE view
    [(alias [, alias]...)]
    AS subquery
    [WITH CHECK OPTION]

    view - име на изгледа
    alias - имена на изразите от заявката на изгледа (трябва да отговаря на броя изрази от изгледа)
    subquery - завършен SELECT оператор

    note: ако искаме да подредим резултата, по-добре да приложим ORDER BY не в SELECT оператора, а заявката към изгледа

    WITH CHECK OPTION - дали само редове, достъпни за изгледа могат да бъдат вмъквани и променяни

    Примери:
    CREATE VIEW v_USA_classes
    AS
    SELECT *
    FROM classes
    WHERE country='USA';

    CREATE VIEW v_Country_AvgGuns
    AS
    SELECT avg(numGuns) as average_Guns, country
    FROM classes
    GROUP BY country;
    - резултата от изпълнението можем да видим с:
    SELECT *
    FROM v_Country_AvgGuns
    ORDER BY average_Guns DESC;

    Пример с таблицата с кораби:
    CREATE VIEW v_ships_full_info
    (name, type, numGuns, bore, displacement, country, launched)
    AS
    SELECT s.name, c.type, c.numGuns, c.bore, c.displacement, c.country, s.launched
    FROM classes c, ships s
    WHERE c.class = s.class

    Модификация на изглед:
        ALTER VIEW view
        [(alias [, alias]...)]
        AS subquery
        [WITH CHECK OPTION]

        - изгледът се пресъздава без това да се отрази на обектите, зависещи от изгледа (съхранени процедури, тригери и т.н.)
        - запазват се и установените права за достъп до изгледа

    Модифициране на данни с използване на изгледи:
        - когато се модифицират данни, използвайки изглед, в действителност се актуализират данните  от таблицата
        - това се прилага и когато се вмъкват или изтриват данни

        - не може да се използват следните видове изгледи за модифициране на данни:
            -- изгледи с операторите за множества, поддържани от съответната СУБД
            -- изгледи с клаузи, съдържащи GROUP BY
            -- изгледи с групови функции като AVG, SUM, MAX
            -- изгледи използващи DISTINCT

        Правила за изпълнение на DML операции върху изгледи, базирани на една таблица:
            - не може да се изтрива ред от изглед, ако той съдържа групови функции, групирания на данни или DISTINCT
            - не може да се модифицира ред от изглед, ако той съдържа групови функции, групирания на данни, DISTINCT или колони дефинирани чрез израз
            - не може да се добавят данни чрез изглед, ако той съдържа групови функции, групирания на данни, DISTINCT, колони дефинирани чрез израз или в базовата таблица има NOT NULL колони, които не са включени в изгледа

            - можем да си гарантираме, че DML операциите изпълнени върху изгледа ще станат в областта на видимост, определена от изгледа като използваме клаузата WITH CHECK OPTION

    Изтриване на изглед:
        DROP VIEW view;


11. MS SQL DML тригери

    INSERT      - inserted
    DELETE     - deleted
    UPDATE    - inserted / deleted

    Подходящи за:
        - запазване информация за кой кога е правил промени по дадените данни
        - архивиране на данни
        - отменяне на операции
        - проверка състоянието на данните преди и след модификация
        - показване на потребителски съобщения при изпълнение на команда

    AFTER тригери:
        - изпълняват се СЛЕД модификация завърши успешно (INSERT, DELETE, UPDATE)
        - могат да се създават само върху таблици

    INSTEAD OF тригери:
        - изпълняват се ВМЕСТО модификация
        - изпълняват се преди да бъдат проверени ограниченията върху таблицата
        - могат да се създават за таблици или изгледи

    Ред на изпълнение на операциите на тригери:
        - извикване на INSERT/UPDATE/DELETE
        - ако е дефиниран INSTREAD OF тригер - той се изпълнява
        - проверка, дали модификациите са съобразени с дефинираните ограничения. Ако не са - възниква грешка и операцията се прекратява
        - изпълняват се AFTER тригерите
            -- първият и последният тригер могат да се специфицират изрично, останалите се изпълняват в произволен ред
        - транзакцията се затвърждава (COMMIT)

    CREATE TRIGGER <TriggerName> ON <TableName>
    AFTER|FOR|INSTREAD OF Insert|Update|Delete
    AS
    <TriggerCode>;

    ALTER TRIGGER <TriggerOne> ON <Target>
    AFTER|FOR|INSTREAD OF Insert|Update|Delete
    AS
    <TriggerCode>;

    DROP TRIGGER <TriggerName>;

    Временна отмяна на тригер:
    ALTER TABLE <TableName> {Enable|Disable} TRIGGER<TriggerName>;