kaloyankibarev07f 1.0.0

    // );
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Имате заявка, която създава таблица Persons и трябва да се използва ограничение, което да постави стойност по подразбиране за град Burgas. От трите посочени думи, изберете ограничението, което трябва да поставите за да решите коректно примера. 
    // 
    // 
    // 
    // 
    // CREATE TABLE Persons(
    // 
    //             PersonID int NOT NULL,
    // 
    //             FirstName varchar(255) NOT NULL,
    // 
    //             LastName varchar(255) NOT NULL,
    // 
    //             Age int,
    // 
    //             City varchar(255) [DEFAULT] 'Burgas'
    // 
    // );
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Имате заявка за създаване на таблица cities с две колони city_id и name. Посочете липсващите думи в кода, така че да получите коректно работеща заявка.
    // 
    // [CREATE] TABLE cities(
    // 
    // city_id [INT] PRIMARY KEY,
    // 
    // name [VARCHAR(50)]
    // 
    // );
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Ограниченията задават правила за данните в дадена таблица. Имате посочени примери за често срещани ограничения. Моля свържете ограничението с неговото вярно описание.
    // 
    // 
    // Правилният отговор е: FOREIGN KEY → уникално идентифицира запис от друга таблица, UNIQUE → гарантира, че всички данни в колоната са различни, CHECK → гарантира, че всички данни в колоната удовлетворят дадено условие
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // TEST 9
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Дефинирайте понятието псевдоним в базите от данни и посочете за какво се използва.
    // 
    // Псевдонимите преименуват таблица или заглавие на колона. Използват се, за да се осъществи връзка между  таблици по свързващото условие.
    // 
    // 
    // 
    // 
    // 
    // 
    // Имате представена подзаявка за намиране служителите от отдел финанси и извеждане на всички колони от таблицата. Поставете липсващите думи, за да направите работещ код.
    // 
    // SELECT * FROM employees
    // [WHERE] department_id [IN]
    // 
    //   (
    // 
    //    SELECT department_id
    //     [FROM] departments
    // 
    //     [WHERE] name = 'Finance'  );
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Следната заявка извлича от таблица projects колоната с крайна дата на проекти, която е NULL
    // 
    // UPDATE projects
    // 
    //    SET end_date = '2017-05-29'
    // 
    //  WHERE end_date IS NULL;
    // 
    // 
    // Правилният отговор е "Неистина"
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Посочете правилния код за създаване на заявка, която извлича всички записи от таблицата departments.
    // 
    // Правилният отговор е: SELECT * FROM departments;
    // 
    // 
    // 
    // 
    // 
    // 
    // Посочете резултата от изпълнението на следната заявка:
    // 
    // UPDATE employees
    // 
    // set last_name = 'Dani'
    // 
    // WHERE employee_id = '1';
    // 
    // 
    // 
    // Правилният отговор е: Ще промени таблицата и на колоната фамилно име на служител с номер 1 ще присвои име Dani.
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Пояснете какво прави връзката RIGHT OUTER JOIN.
    // 
    // RIGHT OUTER JOIN извежда всички записи от дясната таблица и съвпадащите записи от лявата таблица.
    // 
    // 
    // 
    // 
    // 
    // Във вашата база от данни Soft_uni имате създадена таблица Employees с 500 записа. Необходимо е да добавите нова колона с име salary. Напишете заявка за добавяне на колоната в таблица employees. 
    // 
    // ALTER TABLE employees
    // ADD salary DECIMAL(10,2);
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Посочете резултата от изпълнението на следната заявка:
    // 
    // SELECT first_name, last_name, salary FROM employees;
    // 
    // Правилният отговор е: Извлича първо име, фамилия и заплата на служителите
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Посочете какво прави клаузата INNER JOIN:
    // 
    // Клауза INNER JOIN връща само записите, които имат съвпадение в двете свързани таблици.
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // В база от данни People имате таблица persons, състояща се от 4 колони и те са следните:
    // 
    // PersonID int NOT NULL,
    // 
    // FirstName varchar(25) NOT NULL,
    // 
    // email VARCHAR(10),
    // 
    //  Age int );
    // 
    // В таблицата имате достатъчен брой записи, които не трябва да загубите. Вашият мениджър ви поставя задача да промените броя на символите на колоната е-мейл, като ги увеличите на 100. Напишете заявка за промяна на колоната и съответно на таблицата persons.
    // 
    // 
    // 
    // ALTER TABLE persons
    // MODIFY COLUMN email VARCHAR(100);
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // В дадения код имате обединяване на заявки чрез клаузата UNION. Попълнете чрез влачене липсващите думи в кода, така че да получите работеща заявка, която да извежда данни от база от данни geography и да сортира колона name.
    // 
    // (select river_name as name [FROM] rivers)
    //   UNION
    // 
    // ([SELECT] mountain_range from mountains)
    // 
    // [ORDER BY] name ASC LIMIT 100
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Изберете липсващите думи в следната заявка, така че да получите служителите със заплата по-голяма от 50000.
    // 
    // [SELECT] e.employee_id, e.first_name, e.salary, d.name [FROM ] employees AS e
    // 
    // JOIN departments AS d ON d.department_id = e.department_id
    // 
    // [WHERE] salary > 50000
    // 
    // [ORDER BY] d.department_id desc;
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Посочете верния отговор за създаване на заявка, която извлича името на отдела от таблицата departments.
    // 
    // Правилният отговор е: SELECT name FROM departments;
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Посочете верния изход при изпълнение на следната заявка.
    // 
    // SELECT * FROM employees AS e
    // 
    //   JOIN departments AS d ON d.department_id = e.department_id
    // 
    // 
    // 
    // Правилният отговор е: Таблица employees ще се преименува на е, а таблица departments ще се преименува на d и по този начин ще се осъществи връзката между двете таблици по свързващото условие колона department_id
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Посочете резултата от изпълнението на следната заявка:
    // 
    // SELECT employee_id AS id, first_name, last_name
    // 
    //   FROM employees;
    // 
    // 
    // Правилният отговор е: Колоната employee_id ще се преименува на id.
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Посочете резултата от изпълнението на следната заявка: 
    // 
    // UPDATE employees
    // 
    // SET salary = salary*1.10
    // 
    // WHERE department_id = 7;
    // 
    // 
    // 
    // Правилният отговор е: Ще промени таблицата, като стойността на заплатата ще бъде променена само на записите, които са с номер на отдел 7.
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Следната заявка ще изтрие всички записи от таблицата, както и ще рестартира брояча на стойностите за ID.
    // 
    // TRUNCATE TABLE `employees`;
    // 
    //  "Истина"
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Създайте таблица categories, която да съдържа две колони - id и name, като прецените типа данни, който да укажете за двете колони. Колоната id да бъде първичен ключ.
    // 
    // CREATE TABLE categories (
    //     id INT NOT NULL PRIMARY KEY,
    //     name VARCHAR(100) NOT NULL
    // );
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Имате дадена ER диаграма. Информацията в таблиците е въведена предварително. След като анализирате данните в базата от данни colonial_journey, създайте следните заявки. Съобразете се с посочените примери.
    // 
    // 40 TOCHKI
    // 
    // 
    // 
    // 
    // 
    // 
    // SELECT *
    // FROM travel_cards
    // ORDER BY card_number ASC;
    // 
    // 
    // 
    // 
    // SELECT 
    //     CONCAT(first_name, ' ', last_name) AS full_name,
    //     id
    // FROM colonists
    // ORDER BY full_name ASC, id ASC;
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // SELECT 
    //     s.name AS spaceship_name,
    //     sp.name AS destination_name
    // FROM spaceships s
    // JOIN journeys j ON j.spaceship_id = s.id
    // JOIN spaceports sp ON j.destination_spaceport_id = sp.id
    // ORDER BY s.light_speed_rate DESC
    // LIMIT 1;
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Посочете резултата от изпълнение на следната заявка: 
    // 
    // SELECT * FROM projects WHERE end_date IS NULL;
    // 
    // 
    // 
    // Правилният отговор е: Извежда само тези записи, които са NULL в колоната крайна дата.
    // 
    // 
    // 
    // 
    // 
    // 
    // Допишете следната заявка, така че да изведе служителите със заплати между 20000 и 30000.
    // 
    // 
    // 
    // SELECT `last_name`, `salary` FROM `employees`
    // 
    // SELECT `last_name`, `salary`FROM `employees`
    // 
    // WHERE `salary` BETWEEN 20000 AND 22000;
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // TEST 10
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Имате пример за създаване на процедура:
    // 
    // CREATE [PROCEDURE] [usp]_withdraw_money (account_id INT, money_amount DECIMAL)
    // 
    // [BEGIN]
    // 
    //   -- Transaction logic goes here.
    // 
    // END
    // 
    // Поставете липсващите думи, така че да се получи правилния код.
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Имате създадена съхранена процедура с параметър usp_select_employees_by_seniority(min_years_at_work INT). Моля да дефинирате заявка за извикване на процедурата, за да може да бъде използвана.
    // 
    // CALL usp_select_employees_by_seniority(5);
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Имплементирайте код на заявка, която извежда колоните first_name, last_name и job_title от таблица employees и извежда само тези записи със заплата между 20000 и 30000.
    // 
    // SELECT first_name, last_name, job_title
    // FROM employees
    // WHERE salary BETWEEN 20000 AND 30000;
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Посочете коя от следните заявки ще изведе фамилия и заплата, като заплатата е в периода 20000 и 22000.
    // 
    // Правилният отговор е:
    // SELECT `last_name`, `salary`FROM `employees` WHERE `salary` BETWEEN 20000 AND 22000;
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Посочете какво прави клаузата FULL JOIN.
    // 
    // FULL JOIN - Тази връзка връща записите, отговарящи на свързващото условие и също така несъвпадащите записи от лявата или от дясната таблица.
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Дадена е дефиниция за транзакция.  Поставете липсващите думи в дефиницията. 
    // 
    // Транзакциите гарантират пълнотата и цялостността на базата данни. Всички промени в транзакцията са  [временни]. Промените се съхраняват едва след изпълнението на [COMMIT]. По всяко време всички промени могат да се отменят чрез [ROLLBACK].
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Във вашата база от данни Soft_uni имате създадена таблица Employees с 500 записа. Необходимо е да добавите нова колона с име осигуровки (osigurovki). Напишете заявка за добавяне на колоната в таблица employees. 
    // 
    // ALTER TABLE employees
    // ADD osigurovki DECIMAL(10,2);
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // В посочения пример имате заявка за създаване на таблица persons с колони person_id, first_name, passport_id и salary. Моля избирете липсващите думи за всяка колона от таблицата.
    // 
    // CREATE TABLE persons(
    // 
    // person_id  [INT] PRIMARY KEY,
    // 
    // first_name [VARCHAR(50)],
    // 
    // salary [DECIMAL(8,2)],
    // 
    // passport_id INT UNIQUE,
    // 
    // CONSTRAINT fk_persons_passports FOREIGN KEY(passport_id) REFERENCES passports(passport_id)
    // 
    // );
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Създайте база данни с името online_auction. Ще получите описания, с помощта на които ще създадете следните 5 таблици: 
    // 
    // cities 
    // 
    // persons 
    // 
    // product_types 
    // 
    // products 
    // 
    // bids 
    // 
    // 40 TOCHKI
    // 
    // 
    // 
    // 
    // 
    // 
    // CREATE DATABASE online_auction;
    // USE online_auction;
    // 
    // 
    // 
    // 
    // CREATE TABLE cities (
    //     id INT PRIMARY KEY AUTO_INCREMENT,
    //     name VARCHAR(40),
    //     country_name VARCHAR(50)
    // );
    // 
    // CREATE TABLE persons (
    //     id INT PRIMARY KEY AUTO_INCREMENT,
    //     first_name VARCHAR(50),
    //     middle_name VARCHAR(20),
    //     last_name VARCHAR(50),
    //     birth_date DATETIME,
    //     city_id INT,
    //     FOREIGN KEY (city_id) REFERENCES cities(id)
    // );
    // 
    // CREATE TABLE product_types (
    //     id INT PRIMARY KEY AUTO_INCREMENT,
    //     name VARCHAR(30)
    // );
    // 
    // CREATE TABLE products (
    //     id INT PRIMARY KEY AUTO_INCREMENT,
    //     name VARCHAR(50),
    //     description VARCHAR(1024),
    //     start_bid_price DECIMAL(15,2),
    //     sold_on DATETIME,
    //     owner_id INT,
    //     sold_city_id INT,
    //     product_type_id INT,
    //     FOREIGN KEY (owner_id) REFERENCES persons(id),
    //     FOREIGN KEY (sold_city_id) REFERENCES cities(id),
    //     FOREIGN KEY (product_type_id) REFERENCES product_types(id)
    // );
    // 
    // CREATE TABLE bids (
    //     product_id INT,
    //     person_id INT,
    //     amount DECIMAL(15,2),
    //     date DATETIME,
    //     FOREIGN KEY (product_id) REFERENCES products(id),
    //     FOREIGN KEY (person_id) REFERENCES persons(id)
    // );
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // SELECT 
    //     p.id, 
    //     p.name AS product_name, 
    //     ps.first_name, 
    //     ps.last_name, 
    //     c.name AS city_name, 
    //     c.country_name
    // FROM products p
    // JOIN persons ps ON p.owner_id = ps.id
    // JOIN cities c ON p.sold_city_id = c.id
    // WHERE ps.first_name = 'Britni'
    //   AND c.country_name = 'Germany'
    // ORDER BY p.id ASC;
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // SELECT 
    //     ps.id, 
    //     ps.first_name, 
    //     ps.last_name, 
    //     c.name AS city_name, 
    //     COUNT(p.id) AS product_count
    // FROM persons ps
    // JOIN products p ON p.owner_id = ps.id
    // JOIN cities c ON ps.city_id = c.id
    // GROUP BY ps.id, ps.first_name, ps.last_name, c.name
    // ORDER BY product_count DESC, ps.first_name ASC
    // LIMIT 10;
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // SELECT 
    //     p.name AS product_name, 
    //     c.name AS city_name, 
    //     COUNT(b.product_id) AS bid_count, 
    //     MAX(b.amount) AS max_amount, 
    //     MIN(b.amount) AS min_amount
    // FROM products p
    // JOIN bids b ON p.id = b.product_id
    // JOIN cities c ON c.id = p.sold_city_id
    // WHERE c.country_name = 'Bulgaria'
    // GROUP BY p.id, p.name, c.name
    // ORDER BY bid_count DESC
    // LIMIT 5;
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Моля посочете вярното твърдение за съхранени процедури в език My SQL.
    // 
    // Правилният отговор е: Могат да приемат входни параметри; Могат да връщат изходни резултати.
    // 
    // 
    // 
    // 
    // 
    // 
    // Създайте заявка, която извежда първо име, фамилия и длъжност на служителите, които имат заплата между 20000 и 30000. Използвайте базата данни soft_uni.
    // 
    // SELECT first_name, last_name, job_title
    // FROM employees
    // WHERE salary BETWEEN 20000 AND 30000;
    // 
    // 
    // 
    // 
    // 
    // 
    // Моля посочете вярното твърдение за посочените типове данни:
    // 
    // Правилният отговор е: Float → тип данни за реални числа, DOUBLE → тип данни за реални числа, VARCHAR(M) → текстов тип данни
    // 
    // 
    // 
    // 
    // 
    // Допишете следната заявка, така че да изведе като резултат служителите със заплата по-голяма от 50000 и да ги сортира в низходящ ред.
    // 
    // SELECT first_name, last_name, salary FROM employees
    // 
    // 
    // 
    // SELECT first_name, last_name, salary
    // FROM employees
    // WHERE salary > 50000
    // ORDER BY salary DESC;
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Имате представена подзаявка за намиране служителите от отдел финанси и извеждане на всички колони от таблицата. Поставете липсващите думи, за да направите работещ код.
    // 
    // SELECT * FROM employees
    // [WHERE] department_id [IN]
    // 
    //   (
    // 
    //    SELECT department_id
    //     [FROM] departments
    // 
    //     [WHERE] name = 'Finance'  );
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Имате следната заявка. Посочете вярното твърдение за получения резултат от агрегиращата използвана функция след нейното изпълнение. 
    // 
    // SELECT e.`department_id`,
    // 
    //   AVG(e.`salary`) AS 'AvgSalary'
    // 
    // FROM `employees` AS e
    // 
    // GROUP BY e.`department_id`;
    // 
    // 
    // Правилният отговор е: Намира средноаритметичната стойност на заплатите на служителите и преименува колоната.
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Имате синтаксис на транзакция в My SQL. Открийте липсващите думи в кода и го модифицирайте, така че да получите коректно работеща заявка. 
    // 
    // [START] [TRANSACTION]
    // 
    // [UPDATE] accounts SET balance = balance – withdraw_amount
    // 
    // WHERE id = account
    // 
    // --Transaction logic goes here
    // 
    // IF ROW_COUNT() <> 1 THEN -- Affected rows are different than one.
    // 
    //             SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Invalid account';
    // 
    //             [ROLLBACK];
    // 
    // ELSE
    // 
    //             [COMMIT];
    // 
    // [END IF];
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Имате пример за създаване на функция:
    // 
    // CREATE [FUNCTION] [udf]_project_weeks (start_date DATETIME, end_date DATETIME)
    // 
    // [RETURNS] INT
    // 
    // BEGIN
    // 
    //             // тяло на функцията
    // 
    // END
    // 
    // Поставете липсващите думи, така че да се получи правилния код.
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Посочете коя от следните заявки ще изтрие записи от таблица projects, които са с начална дата 2006-01-01.
    // 
    // Правилният отговор е: DELETE FROM projects WHERE start_date = '2006-01-01';
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Посочете действието на използваната връзка в следната заявка: 
    // 
    // SELECT * FROM employees AS e
    // 
    //  RIGHT OUTER JOIN departments AS d
    // 
    //  ON e.department_id = d.department_id;
    // 
    // 
    // 
    // Правилният отговор е:
    // Тази връзка връща записите, отговарящи на свързващото условие и също така несъвпадащите записи от таблица departments.
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // Посочете коя от следните заявки ще изведе всички записи от таблица departments и извежда първите два реда от таблицата.
    // 
    // 
    // Правилният отговор е:
    // SELECT * FROM departments WHERE department_id <=2
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // ТЕСТ 11
    // 
    // 
    // 
    //