MySQL编程题

2020-11-22

LeetCode

175. 组合两个表

Description
表1: Person

+-------------+---------+
| 列名         | 类型     |
+-------------+---------+
| PersonId    | int     |
| FirstName   | varchar |
| LastName    | varchar |
+-------------+---------+

PersonId 是上表主键

表2: Address

+-------------+---------+
| 列名         | 类型    |
+-------------+---------+
| AddressId   | int     |
| PersonId    | int     |
| City        | varchar |
| State       | varchar |
+-------------+---------+

AddressId 是上表主键

编写一个 SQL 查询，满足条件：无论 person 是否有地址信息，都需要基于上述两表提供 person 的以下信息：
FirstName, LastName, City, State
Program

# Write your MySQL query statement below
SELECT FirstName, LastName, City, State
FROM Person LEFT JOIN Address
    ON Person.PersonId = Address.PersonId;

178. 分数排名

Description
编写一个 SQL 查询来实现分数排名。
如果两个分数相同，则两个分数排名（Rank）相同。请注意，平分后的下一个名次应该是下一个连续的整数值。换句话说，名次之间不应该有“间隔”。

+----+-------+
| Id | Score |
+----+-------+
| 1  | 3.50  |
| 2  | 3.65  |
| 3  | 4.00  |
| 4  | 3.85  |
| 5  | 4.00  |
| 6  | 3.65  |
+----+-------+

例如，根据上述给定的 Scores 表，你的查询应该返回（按分数从高到低排列）：

+-------+------+
| Score | Rank |
+-------+------+
| 4.00  | 1    |
| 4.00  | 1    |
| 3.85  | 2    |
| 3.65  | 3    |
| 3.65  | 3    |
| 3.50  | 4    |
+-------+------+

重要提示：对于 MySQL 解决方案，如果要转义用作列名的保留字，可以在关键字之前和之后使用撇号。例如 Rank
Program

# Write your MySQL query statement below
SELECT Score,
       (SELECT COUNT(DISTINCT Score) FROM Scores as B WHERE B.Score >= A.Score) AS `Rank`
FROM Scores as A
ORDER BY A.Score DESC

181. 超过经理收入的员工

Description
Employee 表包含所有员工，他们的经理也属于员工。每个员工都有一个 Id，此外还有一列对应员工的经理的 Id。

+----+-------+--------+-----------+
| Id | Name  | Salary | ManagerId |
+----+-------+--------+-----------+
| 1  | Joe   | 70000  | 3         |
| 2  | Henry | 80000  | 4         |
| 3  | Sam   | 60000  | NULL      |
| 4  | Max   | 90000  | NULL      |
+----+-------+--------+-----------+

给定 Employee 表，编写一个 SQL 查询，该查询可以获取收入超过他们经理的员工的姓名。在上面的表格中，Joe 是唯一一个收入超过他的经理的员工。

+----------+
| Employee |
+----------+
| Joe      |
+----------+

Program
内部联结

# Write your MySQL query statement below
SELECT emp.Name as Employee
FROM Employee as emp INNER JOIN Employee as emp2
    ON emp.ManagerId = emp2.Id
WHERE emp.Salary > emp2.Salary;

182. 查找重复的电子邮箱

Description
编写一个 SQL 查询，查找 Person 表中所有重复的电子邮箱。

示例：

+----+---------+
| Id | Email   |
+----+---------+
| 1  | a@b.com |
| 2  | c@d.com |
| 3  | a@b.com |
+----+---------+

根据以上输入，你的查询应返回以下结果：

+---------+
| Email   |
+---------+
| a@b.com |
+---------+

说明：所有电子邮箱都是小写字母。
Program
分组过滤

# Write your MySQL query statement below
SELECT Email
FROM Person
GROUP BY Email
HAVING COUNT(Email) >= 2;

183. 从不订购的客户

Description
某网站包含两个表，Customers 表和 Orders 表。编写一个 SQL 查询，找出所有从不订购任何东西的客户。

Customers 表：

+----+-------+
| Id | Name  |
+----+-------+
| 1  | Joe   |
| 2  | Henry |
| 3  | Sam   |
| 4  | Max   |
+----+-------+

Orders 表：

+----+------------+
| Id | CustomerId |
+----+------------+
| 1  | 3          |
| 2  | 1          |
+----+------------+

例如给定上述表格，你的查询应返回：

+-----------+
| Customers |
+-----------+
| Henry     |
| Max       |
+-----------+

Program
①嵌套查询

# Write your MySQL query statement below
SELECT Name as Customers
FROM Customers
WHERE Customers.Id NOT IN(
    SELECT CustomerId FROM Orders
);

②外联结

# Write your MySQL query statement below
SELECT Name as Customers
FROM Customers LEFT JOIN Orders
    ON Customers.Id = Orders.CustomerId
WHERE ISNULL(CustomerId);

196. 删除重复的电子邮箱

Description
编写一个 SQL 查询，来删除 Person 表中所有重复的电子邮箱，重复的邮箱里只保留 Id 最小的那个。

+----+------------------+
| Id | Email            |
+----+------------------+
| 1  | john@example.com |
| 2  | bob@example.com  |
| 3  | john@example.com |
+----+------------------+

Id 是这个表的主键。
例如，在运行你的查询语句之后，上面的 Person 表应返回以下几行:

+----+------------------+
| Id | Email            |
+----+------------------+
| 1  | john@example.com |
| 2  | bob@example.com  |
+----+------------------+

提示：
执行 SQL 之后，输出是整个 Person 表。
使用 delete 语句。
Program
思路
使用自联结

# Write your MySQL query statement below
DELETE p1
FROM Person p1,
    Person p2
WHERE
    p1.Email = p2.Email AND p1.Id > p2.Id;

197. 上升的温度

Description
表 Weather

+---------------+---------+
| Column Name   | Type    |
+---------------+---------+
| id            | int     |
| recordDate    | date    |
| temperature   | int     |
+---------------+---------+

id 是这个表的主键
该表包含特定日期的温度信息
编写一个 SQL 查询，来查找与之前（昨天的）日期相比温度更高的所有日期的 id 。
返回结果不要求顺序。
查询结果格式如下例：
Weather

+----+------------+-------------+
| id | recordDate | Temperature |
+----+------------+-------------+
| 1  | 2015-01-01 | 10          |
| 2  | 2015-01-02 | 25          |
| 3  | 2015-01-03 | 20          |
| 4  | 2015-01-04 | 30          |
+----+------------+-------------+

Result table:

+----+
| id |
+----+
| 2  |
| 4  |
+----+

2015-01-02 的温度比前一天高（10 -> 25）
2015-01-04 的温度比前一天高（30 -> 20）
Program
联结+函数
联结后日期比较函数DATEDIFF(date1, date2)返回date1 - date2的日期差。

# Write your MySQL query statement below
SELECT weather.id as id
FROM
    weather JOIN weather as w
    ON DATEDIFF(weather.recordDate, w.recordDate) = 1
       AND weather.Temperature > w.Temperature;

595. 大的国家

Description
这里有张 World 表

+-----------------+------------+------------+--------------+---------------+
| name            | continent  | area       | population   | gdp           |
+-----------------+------------+------------+--------------+---------------+
| Afghanistan     | Asia       | 652230     | 25500100     | 20343000      |
| Albania         | Europe     | 28748      | 2831741      | 12960000      |
| Algeria         | Africa     | 2381741    | 37100000     | 188681000     |
| Andorra         | Europe     | 468        | 78115        | 3712000       |
| Angola          | Africa     | 1246700    | 20609294     | 100990000     |
+-----------------+------------+------------+--------------+---------------+

如果一个国家的面积超过 300 万平方公里，或者人口超过 2500 万，那么这个国家就是大国家。
编写一个 SQL 查询，输出表中所有大国家的名称、人口和面积。
例如，根据上表，我们应该输出:

+--------------+-------------+--------------+
| name         | population  | area         |
+--------------+-------------+--------------+
| Afghanistan  | 25500100    | 652230       |
| Algeria      | 37100000    | 2381741      |
+--------------+-------------+--------------+

Program

# Write your MySQL query statement below
SELECT w.name, w.population, w.area
FROM World as w
WHERE w.area > 3000000 OR w.population > 25000000;

596. 超过5名学生的课

Description
有一个courses 表，有: student (学生) 和 class (课程)。
请列出所有超过或等于5名学生的课。
例如，表：

+---------+------------+
| student | class      |
+---------+------------+
| A       | Math       |
| B       | English    |
| C       | Math       |
| D       | Biology    |
| E       | Math       |
| F       | Computer   |
| G       | Math       |
| H       | Math       |
| I       | Math       |
+---------+------------+

应该输出:

+---------+
| class   |
+---------+
| Math    |
+---------+

提示：
学生在每个课中不应被重复计算。
Program

# Write your MySQL query statement below
SELECT class
FROM courses
GROUP BY class
HAVING COUNT(DISTINCT student) >= 5;

620. 有趣的电影

Description
某城市开了一家新的电影院，吸引了很多人过来看电影。该电影院特别注意用户体验，专门有个 LED显示板做电影推荐，上面公布着影评和相关电影描述。
作为该电影院的信息部主管，您需要编写一个 SQL查询，找出所有影片描述为非 boring (不无聊) 的并且 id 为奇数的影片，结果请按等级 rating 排列。
例如，下表 cinema:

+---------+-----------+--------------+-----------+
|   id    | movie     |  description |  rating   |
+---------+-----------+--------------+-----------+
|   1     | War       |   great 3D   |   8.9     |
|   2     | Science   |   fiction    |   8.5     |
|   3     | irish     |   boring     |   6.2     |
|   4     | Ice song  |   Fantacy    |   8.6     |
|   5     | House card|   Interesting|   9.1     |
+---------+-----------+--------------+-----------+

对于上面的例子，则正确的输出是为：

+---------+-----------+--------------+-----------+
|   id    | movie     |  description |  rating   |
+---------+-----------+--------------+-----------+
|   5     | House card|   Interesting|   9.1     |
|   1     | War       |   great 3D   |   8.9     |
+---------+-----------+--------------+-----------+

Program

# Write your MySQL query statement below
SELECT *
FROM cinema
WHERE description != 'boring' and id%2 = 1
ORDER BY rating DESC;

627. 变更性别

Description
给定一个 salary 表，如下所示，有 m = 男性和 f = 女性的值。交换所有的 f 和 m 值（例如，将所有 f 值更改为 m，反之亦然）。要求只使用一个更新（Update）语句，并且没有中间的临时表。
注意，您必只能写一个 Update 语句，请不要编写任何 Select 语句。

例如：

| id | name | sex | salary |
|----|------|-----|--------|
| 1  | A    | m   | 2500   |
| 2  | B    | f   | 1500   |
| 3  | C    | m   | 5500   |
| 4  | D    | f   | 500    |

运行你所编写的更新语句之后，将会得到以下表:

| id | name | sex | salary |
|----|------|-----|--------|
| 1  | A    | f   | 2500   |
| 2  | B    | m   | 1500   |
| 3  | C    | f   | 5500   |
| 4  | D    | m   | 500    |

Program
表达式

# Write your MySQL query statement below
UPDATE salary
SET
    sex = CASE sex
        WHEN 'm' THEN 'f'
        ELSE 'm'
    END;

1179. 重新格式化部门表

Description
部门表 Department：

+---------------+---------+
| Column Name   | Type    |
+---------------+---------+
| id            | int     |
| revenue       | int     |
| month         | varchar |
+---------------+---------+

(id, month) 是表的联合主键。
这个表格有关于每个部门每月收入的信息。
月份（month）可以取下列值 [“Jan”,”Feb”,”Mar”,”Apr”,”May”,”Jun”,”Jul”,”Aug”,”Sep”,”Oct”,”Nov”,”Dec”]。

编写一个 SQL 查询来重新格式化表，使得新的表中有一个部门 id 列和一些对应每个月的收入（revenue）列。
查询结果格式如下面的示例所示：
Department 表：

+------+---------+-------+
| id   | revenue | month |
+------+---------+-------+
| 1    | 8000    | Jan   |
| 2    | 9000    | Jan   |
| 3    | 10000   | Feb   |
| 1    | 7000    | Feb   |
| 1    | 6000    | Mar   |
+------+---------+-------+

查询得到的结果表：

+------+-------------+-------------+-------------+-----+-------------+
| id   | Jan_Revenue | Feb_Revenue | Mar_Revenue | ... | Dec_Revenue |
+------+-------------+-------------+-------------+-----+-------------+
| 1    | 8000        | 7000        | 6000        | ... | null        |
| 2    | 9000        | null        | null        | ... | null        |
| 3    | null        | 10000       | null        | ... | null        |
+------+-------------+-------------+-------------+-----+-------------+

注意，结果表有 13 列 (1个部门 id 列 + 12个月份的收入列)。
Program

# Write your MySQL query statement below
SELECT id,
SUM(CASE WHEN month='Jan' THEN revenue END) AS Jan_Revenue,
SUM(CASE WHEN month='Feb' THEN revenue END) AS Feb_Revenue,
SUM(CASE WHEN month='Mar' THEN revenue END) AS Mar_Revenue,
SUM(CASE WHEN month='Apr' THEN revenue END) AS Apr_Revenue,
SUM(CASE WHEN month='May' THEN revenue END) AS May_Revenue,
SUM(CASE WHEN month='Jun' THEN revenue END) AS Jun_Revenue,
SUM(CASE WHEN month='Jul' THEN revenue END) AS Jul_Revenue,
SUM(CASE WHEN month='Aug' THEN revenue END) AS Aug_Revenue,
SUM(CASE WHEN month='Sep' THEN revenue END) AS Sep_Revenue,
SUM(CASE WHEN month='Oct' THEN revenue END) AS Oct_Revenue,
SUM(CASE WHEN month='Nov' THEN revenue END) AS Nov_Revenue,
SUM(CASE WHEN month='Dec' THEN revenue END) AS Dec_Revenue
FROM Department
GROUP BY id
ORDER BY id;

牛客

SQL01 查找最晚入职员工的所有信息

题目描述
查找最晚入职员工的所有信息，为了减轻入门难度，目前所有的数据里员工入职的日期都不是同一天(sqlite里面的注释为–,mysql为comment)

CREATE TABLE `employees` (
`emp_no` int(11) NOT NULL,  -- '员工编号'
`birth_date` date NOT NULL,
`first_name` varchar(14) NOT NULL,
`last_name` varchar(16) NOT NULL,
`gender` char(1) NOT NULL,
`hire_date` date NOT NULL,
PRIMARY KEY (`emp_no`));

输出描述
|emp_no|birth_date|first_name|last_name|gender|hire_date|
|–|–|–|–|–|–|–|
|10008|1958-02-19|Saniya|Kalloufi|M|1994-09-15|
程序

SELECT *
FROM employees
ORDER BY hire_date DESC
LIMIT 1;

SQL02 查找入职员工时间排名倒数第三的员工所有信息

1	查找入职员工时间排名倒数第三的员工所有信息，为了减轻入门难度，目前所有的数据里员工入职的日期都不是同一天

CREATE TABLE employees (
emp_no int(11) NOT NULL,
birth_date date NOT NULL,
first_name varchar(14) NOT NULL,
last_name varchar(16) NOT NULL,
gender char(1) NOT NULL,
hire_date date NOT NULL,
PRIMARY KEY (emp_no));

**输出描述**
|emp_no|birth_date|first_name|last_name|gender|hire_date|
|--|--|--|--|--|--|--|
|10008|1958-02-19|Saniya|Kalloufi|M|1994-09-15|
**程序**
```MySQL
SELECT *
FROM employees
ORDER BY hire_date DESC
LIMIT 2,1;

SQL03 查找各个部门当前领导当前薪水详情以及其对应部门编号dept_no

题目描述
查找各个部门当前(dept_manager.to_date=’9999-01-01’)领导当前(salaries.to_date=’9999-01-01’)薪水详情以及其对应部门编号dept_no
(注:输出结果以salaries.emp_no升序排序，并且请注意输出结果里面dept_no列是最后一列)

CREATE TABLE `salaries` (
`emp_no` int(11) NOT NULL, -- '员工编号',
`salary` int(11) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`from_date`));

CREATE TABLE `dept_manager` (
`dept_no` char(4) NOT NULL, -- '部门编号'
`emp_no` int(11) NOT NULL, --  '员工编号'
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`dept_no`));

思路
题目要求从两个表中

SELECT s.emp_no, s.salary, s.from_date, s.to_date, d.dept_no
FROM salaries as s join dept_manager as d
    ON s.emp_no = d.emp_no and s.to_date = '9999-01-01' and d.to_date = '9999-01-01'
ORDER BY s.emp_no ASC;

SQL04 查找所有已经分配部门的员工的last_name和first_name

题目描述
查找所有已经分配部门的员工的last_name和first_name以及dept_no(请注意输出描述里各个列的前后顺序)

CREATE TABLE `dept_emp` (
`emp_no` int(11) NOT NULL,
`dept_no` char(4) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`dept_no`));
CREATE TABLE `employees` (
`emp_no` int(11) NOT NULL,
`birth_date` date NOT NULL,
`first_name` varchar(14) NOT NULL,
`last_name` varchar(16) NOT NULL,
`gender` char(1) NOT NULL,
`hire_date` date NOT NULL,
PRIMARY KEY (`emp_no`));

程序

SELECT e.last_name, e.first_name, d.dept_no
FROM employees as e LEFT JOIN dept_emp as d
    ON e.emp_no = d.emp_no
WHERE d.dept_no IS NOT null;

SQL05 查找所有员工的last_name和first_name以及对应部门编号dept_no

题目描述
查找所有员工的last_name和first_name以及对应部门编号dept_no，也包括暂时没有分配具体部门的员工(请注意输出描述里各个列的前后顺序)

CREATE TABLE `dept_emp` (
`emp_no` int(11) NOT NULL,
`dept_no` char(4) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`dept_no`));
CREATE TABLE `employees` (
`emp_no` int(11) NOT NULL,
`birth_date` date NOT NULL,
`first_name` varchar(14) NOT NULL,
`last_name` varchar(16) NOT NULL,
`gender` char(1) NOT NULL,
`hire_date` date NOT NULL,
PRIMARY KEY (`emp_no`));

程序

1
2
3

SELECT e.last_name, e.first_name, d.dept_no
FROM employees as e LEFT JOIN dept_emp as d
    ON e.emp_no = d.emp_no;

SQL06 查找所有员工入职时候的薪水情况

题目描述
查找所有员工入职时候的薪水情况，给出emp_no以及salary，并按照emp_no进行逆序(请注意，一个员工可能有多次涨薪的情况)

CREATE TABLE `employees` (
`emp_no` int(11) NOT NULL,
`birth_date` date NOT NULL,
`first_name` varchar(14) NOT NULL,
`last_name` varchar(16) NOT NULL,
`gender` char(1) NOT NULL,
`hire_date` date NOT NULL,
PRIMARY KEY (`emp_no`));
CREATE TABLE `salaries` (
`emp_no` int(11) NOT NULL,
`salary` int(11) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`from_date`));

程序

SELECT e.emp_no, s.salary
FROM employees as e JOIN salaries as s
    ON e.emp_no = s.emp_no and e.hire_date = s.from_date
ORDER BY e.emp_no DESC;

SQL07 查找薪水涨幅超过15次的员工号emp_no以及其对应的涨幅次数t

题目描述
查找薪水变动超过15次的员工号emp_no以及其对应的变动次数t

CREATE TABLE `salaries` (
`emp_no` int(11) NOT NULL,
`salary` int(11) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`from_date`));

程序

SELECT emp_no, COUNT(emp_no) as t
FROM salaries
GROUP BY emp_no
HAVING COUNT(emp_no) >= 15;

SQL08 找出所有员工当前具体的薪水salary情况

题目描述
找出所有员工当前(to_date=’9999-01-01’)具体的薪水salary情况，对于相同的薪水只显示一次,并按照逆序显示

CREATE TABLE `salaries` (
`emp_no` int(11) NOT NULL,
`salary` int(11) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`from_date`));

程序

SELECT DISTINCT salary
FROM salaries
WHERE to_date = '9999-01-01'
ORDER BY salary DESC;

SQL09 获取所有部门当前manager的当前薪水情况

题目描述
获取所有部门当前(dept_manager.to_date=’9999-01-01’)manager的当前(salaries.to_date=’9999-01-01’)薪水情况，给出dept_no, emp_no以及salary，输出结果按照dept_no升序排列(请注意，同一个人可能有多条薪水情况记录)

CREATE TABLE `dept_manager` (
`dept_no` char(4) NOT NULL,
`emp_no` int(11) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`dept_no`));

CREATE TABLE `salaries` (
`emp_no` int(11) NOT NULL,
`salary` int(11) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`from_date`));

程序

SELECT d.dept_no, s.emp_no, s.salary
FROM salaries as s INNER JOIN dept_manager as d
    ON s.emp_no = d.emp_no and d.to_date = '9999-01-01' and s.to_date = '9999-01-01'
ORDER BY d.dept_no;

SQL10 获取所有非manager的员工emp_no

题目描述
获取所有非manager的员工emp_no

CREATE TABLE `dept_manager` (
`dept_no` char(4) NOT NULL,
`emp_no` int(11) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`dept_no`));
CREATE TABLE `employees` (
`emp_no` int(11) NOT NULL,
`birth_date` date NOT NULL,
`first_name` varchar(14) NOT NULL,
`last_name` varchar(16) NOT NULL,
`gender` char(1) NOT NULL,
`hire_date` date NOT NULL,
PRIMARY KEY (`emp_no`));

程序

SELECT e.emp_no
FROM dept_manager as d RIGHT JOIN employees as e
    ON d.emp_no = e.emp_no
WHERE d.dept_no IS NULL;

SQL11 获取所有员工当前的manager

题目描述
获取所有员工当前的(dept_manager.to_date=’9999-01-01’)manager，如果员工是manager的话不显示(也就是如果当前的manager是自己的话结果不显示)。输出结果第一列给出当前员工的emp_no,第二列给出其manager对应的emp_no。

CREATE TABLE `dept_emp` (
`emp_no` int(11) NOT NULL, -- '所有的员工编号'
`dept_no` char(4) NOT NULL, -- '部门编号'
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`dept_no`));
CREATE TABLE `dept_manager` (
`dept_no` char(4) NOT NULL, -- '部门编号'
`emp_no` int(11) NOT NULL, -- '经理编号'
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`dept_no`));

程序

SELECT de.emp_no as emp_no, dm.emp_no as manager_no
FROM dept_emp as de INNER JOIN dept_manager as dm
    ON de.dept_no = dm.dept_no
WHERE de.emp_no != dm.emp_no and dm.to_date = '9999-01-01';

SQL12 获取所有部门中当前员工薪水最高的相关信息

题目描述
获取所有部门中当前(dept_emp.to_date = ‘9999-01-01’)员工当前(salaries.to_date=’9999-01-01’)薪水最高的相关信息，给出dept_no, emp_no以及其对应的salary，按照部门编号升序排列。

CREATE TABLE `dept_emp` (
`emp_no` int(11) NOT NULL,
`dept_no` char(4) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`dept_no`));
CREATE TABLE `salaries` (
`emp_no` int(11) NOT NULL,
`salary` int(11) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`from_date`));

程序
子查询查找每个部门中满足条件的最高薪水，然后外表根据最高薪水进行选择。

SELECT d.dept_no, s.emp_no, s.salary
FROM salaries as s INNER JOIN dept_emp as d
    ON s.emp_no = d.emp_no and d.to_date = '9999-01-01' and s.to_date = '9999-01-01'
WHERE s.salary in (
    SELECT MAX(s1.salary)
    FROM salaries as s1 INNER JOIN dept_emp as d1
    ON s1.emp_no = d1.emp_no and d1.to_date = '9999-01-01' and s1.to_date = '9999-01-01'
        and d.dept_no = d1.dept_no
)
ORDER BY d.dept_no;

SQL13 从titles表获取按照title进行分组

题目描述
从titles表获取按照title进行分组，每组个数大于等于2，给出title以及对应的数目t。

CREATE TABLE IF NOT EXISTS "titles" (
`emp_no` int(11) NOT NULL,
`title` varchar(50) NOT NULL,
`from_date` date NOT NULL,
`to_date` date DEFAULT NULL);

程序

1
2
3

SELECT title, COUNT(*)
FROM titles
GROUP BY title;

SQL14 从titles表获取按照title进行分组，注意对于重复的emp_no进行忽略。

题目描述
从titles表获取按照title进行分组，每组个数大于等于2，给出title以及对应的数目t。
注意对于重复的emp_no进行忽略(即emp_no重复的title不计算，title对应的数目t不增加)。

CREATE TABLE IF NOT EXISTS `titles` (
`emp_no` int(11) NOT NULL,
`title` varchar(50) NOT NULL,
`from_date` date NOT NULL,
`to_date` date DEFAULT NULL);

程序
分组后去重emp_no

1
2
3

SELECT title, COUNT(DISTINCT(emp_no))
FROM titles
GROUP BY title;

SQL15 查找employees表所有emp_no为奇数

题目描述
查找employees表所有emp_no为奇数，且last_name不为Mary(注意大小写)的员工信息，并按照hire_date逆序排列
复制代码

CREATE TABLE `employees` (
`emp_no` int(11) NOT NULL,
`birth_date` date NOT NULL,
`first_name` varchar(14) NOT NULL,
`last_name` varchar(16) NOT NULL,
`gender` char(1) NOT NULL,
`hire_date` date NOT NULL,
PRIMARY KEY (`emp_no`));

程序

SELECT *
FROM employees
WHERE emp_no % 2 = 1 and last_name != 'Mary'
ORDER BY hire_date DESC;

SQL16 统计出当前各个title类型对应的员工当前薪水对应的平均工资

题目描述
统计出当前(titles.to_date=’9999-01-01’)各个title类型对应的员工当前(salaries.to_date=’9999-01-01’)薪水对应的平均工资。结果给出title以及平均工资avg。

CREATE TABLE `salaries` (
`emp_no` int(11) NOT NULL,
`salary` int(11) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`from_date`));
CREATE TABLE IF NOT EXISTS "titles" (
`emp_no` int(11) NOT NULL,
`title` varchar(50) NOT NULL,
`from_date` date NOT NULL,
`to_date` date DEFAULT NULL);

程序

SELECT t.title, AVG(s.salary)
FROM salaries as s INNER JOIN titles as t
    ON s.emp_no = t.emp_no
WHERE t.to_date = '9999-01-01' and s.to_date = '9999-01-01'
GROUP BY t.title;

SQL17 获取当前薪水第二多的员工的emp_no以及其对应的薪水salary

题目描述
获取当前（to_date=’9999-01-01’）薪水第二多的员工的emp_no以及其对应的薪水salary

CREATE TABLE `salaries` (
`emp_no` int(11) NOT NULL,
`salary` int(11) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`from_date`));

程序

SELECT emp_no, salary
FROM salaries
WHERE to_date = '9999-01-01' and salary = (
    SELECT salary
    FROM salaries
    WHERE to_date = '9999-01-01'
    GROUP BY salary
    ORDER BY salary DESC
    LIMIT 1,1
);

SQL18 查找当前薪水排名第二多的员工编号emp_no

题目描述
查找当前薪水(to_date=’9999-01-01’)排名第二多的员工编号emp_no、薪水salary、last_name以及first_name，你可以不使用order by完成吗

CREATE TABLE `employees` (
`emp_no` int(11) NOT NULL,
`birth_date` date NOT NULL,
`first_name` varchar(14) NOT NULL,
`last_name` varchar(16) NOT NULL,
`gender` char(1) NOT NULL,
`hire_date` date NOT NULL,
PRIMARY KEY (`emp_no`));
CREATE TABLE `salaries` (
`emp_no` int(11) NOT NULL,
`salary` int(11) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`from_date`));

程序

SELECT s.emp_no, s.salary, e.last_name, e.first_name
FROM salaries as s INNER JOIN employees as e
    ON s.emp_no = e.emp_no and s.to_date = '9999-01-01'
WHERE s.salary = (
    SELECT salary
    FROM salaries
    WHERE to_date = '9999-01-01'
    GROUP BY salary
    ORDER BY salary DESC
    LIMIT 1,1
);

SELECT s.emp_no, s.salary, e.last_name, e.first_name
FROM salaries as s INNER JOIN employees as e
    ON s.emp_no = e.emp_no and s.to_date = '9999-01-01'
WHERE s.salary = (
    SELECT MAX(salary)  # 找次高的工资
    FROM salaries
    WHERE to_date = '9999-01-01' and salary < (
        SELECT MAX(salary) # 找最高工资
        FROM salaries
        WHERE to_date = '9999-01-01'
    )
);

SQL19 查找所有员工的last_name和first_name以及对应的dept_name

题目描述
查找所有员工的last_name和first_name以及对应的dept_name，也包括暂时没有分配部门的员工

CREATE TABLE `departments` (
`dept_no` char(4) NOT NULL,
`dept_name` varchar(40) NOT NULL,
PRIMARY KEY (`dept_no`));
CREATE TABLE `dept_emp` (
`emp_no` int(11) NOT NULL,
`dept_no` char(4) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`dept_no`));
CREATE TABLE `employees` (
`emp_no` int(11) NOT NULL,
`birth_date` date NOT NULL,
`first_name` varchar(14) NOT NULL,
`last_name` varchar(16) NOT NULL,
`gender` char(1) NOT NULL,
`hire_date` date NOT NULL,
PRIMARY KEY (`emp_no`));

程序

SELECT e.last_name, e.first_name,
       (SELECT dp.dept_name
        FROM departments as dp
        WHERE dp.dept_no = d.dept_no)
FROM employees as e LEFT JOIN dept_emp as d
    ON e.emp_no = d.emp_no

SELECT e.last_name, e.first_name, dp.dept_name
FROM (employees as e LEFT JOIN dept_emp as d
    ON e.emp_no = d.emp_no) LEFT JOIN departments as dp
    ON d.dept_no = dp.dept_no

SQL20 查找员工编号emp_now为10001其自入职以来的薪水salary涨幅值growth

题目描述
查找员工编号emp_no为10001其自入职以来的薪水salary涨幅(总共涨了多少)growth(可能有多次涨薪，没有降薪)

CREATE TABLE `salaries` (
`emp_no` int(11) NOT NULL,
`salary` int(11) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`from_date`));

程序

1
2
3

SELECT MAX(salary) - MIN(salary) AS growth
FROM salaries
WHERE emp_no = 10001;

SQL21 查找所有员工自入职以来的薪水涨幅情况

题目描述
查找所有员工自入职以来的薪水涨幅情况，给出员工编号emp_no以及其对应的薪水涨幅growth，并按照growth进行升序
（注:可能有employees表和salaries表里存在记录的员工，有对应的员工编号和涨薪记录，但是已经离职了，离职的员工salaries表的最新的to_date!=’9999-01-01’，这样的数据不显示在查找结果里面）

CREATE TABLE `employees` (
`emp_no` int(11) NOT NULL,
`birth_date` date NOT NULL,
`first_name` varchar(14) NOT NULL,
`last_name` varchar(16) NOT NULL,
`gender` char(1) NOT NULL,
`hire_date` date NOT NULL, --  '入职时间'
PRIMARY KEY (`emp_no`));
CREATE TABLE `salaries` (
`emp_no` int(11) NOT NULL,
`salary` int(11) NOT NULL,
`from_date` date NOT NULL, --  '一条薪水记录开始时间'
`to_date` date NOT NULL, --  '一条薪水记录结束时间'
PRIMARY KEY (`emp_no`,`from_date`));

程序

SELECT s1.emp_no, s1.salary - s2.salary AS growth
FROM (SELECT emp_no, salary # 当前薪水
     FROM salaries
     WHERE to_date = '9999-01-01') AS s1
     INNER JOIN
     (SELECT e.emp_no, s.salary # 入职时的薪水
     FROM employees AS e INNER JOIN salaries AS s
         ON e.emp_no = s.emp_no and e.hire_date = s.from_date) as s2
     ON s1.emp_no = s2.emp_no
ORDER BY growth;

SQL22 统计各个部门的工资记录数

题目描述
统计各个部门的工资记录数，给出部门编码dept_no、部门名称dept_name以及部门在salaries表里面有多少条记录sum，按照dept_no升序排序

CREATE TABLE `departments` (
`dept_no` char(4) NOT NULL,
`dept_name` varchar(40) NOT NULL,
PRIMARY KEY (`dept_no`));
CREATE TABLE `dept_emp` (
`emp_no` int(11) NOT NULL,
`dept_no` char(4) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`dept_no`));
CREATE TABLE `salaries` (
`emp_no` int(11) NOT NULL,
`salary` int(11) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`from_date`));

程序

SELECT dp.dept_no, dp.dept_name, COUNT(*) AS sum
FROM (departments AS dp
     INNER JOIN dept_emp AS de
     ON dp.dept_no = de.dept_no
     INNER JOIN
     salaries as s
     ON de.emp_no = s.emp_no)
GROUP BY de.dept_no
ORDER BY de.dept_no;

SQL23 对所有员工的当前薪水按照salary进行按照1-N的排名

题目描述
对所有员工的当前(to_date=’9999-01-01’)薪水按照salary进行按照1-N的排名，相同salary并列且按照emp_no升序排列

CREATE TABLE `salaries` (
`emp_no` int(11) NOT NULL,
`salary` int(11) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`from_date`));

程序
下面介绍三种用于进行排序的专用窗口函数：

1、RANK()
在计算排序时，若存在相同位次，会跳过之后的位次。
例如，有3条排在第1位时，排序为：1，1，1，4······

2、DENSE_RANK()
这就是题目中所用到的函数，在计算排序时，若存在相同位次，不会跳过之后的位次。
例如，有3条排在第1位时，排序为：1，1，1，2······

3、ROW_NUMBER()
这个函数赋予唯一的连续位次。
例如，有3条排在第1位时，排序为：1，2，3，4······

窗口函数用法：
<窗口函数> OVER ( [PARTITION BY <列清单> ]
ORDER BY <排序用列清单> ）
*其中[ ]中的内容可以忽略

SELECT emp_no, salary,
       DENSE_RANK() OVER (ORDER BY salary DESC) as t_rank
FROM salaries
WHERE to_date = '9999-01-01'
ORDER BY t_rank ASC, emp_no ASC;

SQL24 获取所有非manager员工当前的薪水情况

题目描述
获取所有非manager员工当前的薪水情况，给出dept_no、emp_no以及salary ，当前表示to_date=’9999-01-01’

CREATE TABLE `dept_emp` (
`emp_no` int(11) NOT NULL,
`dept_no` char(4) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`dept_no`));
CREATE TABLE `dept_manager` (
`dept_no` char(4) NOT NULL,
`emp_no` int(11) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`dept_no`));
CREATE TABLE `employees` (
`emp_no` int(11) NOT NULL,
`birth_date` date NOT NULL,
`first_name` varchar(14) NOT NULL,
`last_name` varchar(16) NOT NULL,
`gender` char(1) NOT NULL,
`hire_date` date NOT NULL,
PRIMARY KEY (`emp_no`));
CREATE TABLE `salaries` (
`emp_no` int(11) NOT NULL,
`salary` int(11) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`from_date`));

程序

SELECT de.dept_no, e.emp_no, s.salary
FROM employees as e
     INNER JOIN
     dept_emp as de
     ON e.emp_no = de.emp_no
     INNER JOIN
     salaries as s
     ON e.emp_no = s.emp_no
        AND e.emp_no not in (
        SELECT emp_no
        FROM dept_manager as dm
        )
WHERE s.to_date = '9999-01-01';

SQL25 获取员工其当前的薪水比其manager当前薪水还高的相关信息

题目描述
获取员工其当前的薪水比其manager当前薪水还高的相关信息，当前表示to_date=’9999-01-01’,
结果第一列给出员工的emp_no，
第二列给出其manager的manager_no，
第三列给出该员工当前的薪水emp_salary,
第四列给该员工对应的manager当前的薪水manager_salary

CREATE TABLE `dept_emp` (
`emp_no` int(11) NOT NULL,
`dept_no` char(4) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`dept_no`));
CREATE TABLE `dept_manager` (
`dept_no` char(4) NOT NULL,
`emp_no` int(11) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`dept_no`));
CREATE TABLE `salaries` (
`emp_no` int(11) NOT NULL,
`salary` int(11) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`from_date`));

程序
（1）先让员工表与工资表按照员工编号emp_no内连接，得到员工的工资；
（2）再根据dept_no连接管理员表；
（3）再根据管理员表的emp_no与工资表连接，得到管理员的工资；

SELECT de.emp_no, dm.emp_no AS manager_no, s1.salary AS emp_salary, s2.salary AS manager_salary
FROM dept_emp AS de
    INNER JOIN
      salaries AS s1
      ON de.emp_no = s1.emp_no
    INNER JOIN
      dept_manager AS dm
      ON de.dept_no = dm.dept_no
    INNER JOIN
      salaries AS s2
      ON dm.emp_no = s2.emp_no
WHERE s1.to_date = '9999-01-01' and s2.to_date = '9999-01-01' and s1.salary > s2.salary;

SQL26 汇总各个部门当前员工的title类型的分配数目

题目描述
汇总各个部门当前员工的title类型的分配数目，即结果给出部门编号dept_no、dept_name、其部门下所有的当前(dept_emp.to_date = ‘9999-01-01’)员工的当前(titles.to_date = ‘9999-01-01’)title以及该类型title对应的数目count，结果按照dept_no升序排序
(注：因为员工可能有离职，所有dept_emp里面to_date不为’9999-01-01’就已经离职了，不计入统计，而且员工可能有晋升，所以如果titles.to_date 不为 ‘9999-01-01’，那么这个可能是员工之前的职位信息，也不计入统计)

CREATE TABLE `departments` (
`dept_no` char(4) NOT NULL,
`dept_name` varchar(40) NOT NULL,
PRIMARY KEY (`dept_no`));
CREATE TABLE `dept_emp` (
`emp_no` int(11) NOT NULL,
`dept_no` char(4) NOT NULL,
`from_date` date NOT NULL,
`to_date` date NOT NULL,
PRIMARY KEY (`emp_no`,`dept_no`));
CREATE TABLE IF NOT EXISTS `titles` (
`emp_no` int(11) NOT NULL,
`title` varchar(50) NOT NULL,
`from_date` date NOT NULL,
`to_date` date DEFAULT NULL);

程序
（1）先按照dept_no联结departments和dept_emp；
（2）再按照emp_no联结titles；
（3）题目需要按dept_no排序，所以最后需要ORDER BY dept_no；
（4）最关键的在于需要统计每个部门内的每个title类型的数量，所以需要先对dept_no部门进行分组，而后再对每个部门内的title类型进行分组，最后统计COUNT(title)计算的就是所求；
关键点GROUP BY dp.dept_no, t.title

SELECT dp.dept_no, dp.dept_name, t.title, COUNT(t.title) AS 'count'
FROM departments AS dp
    INNER JOIN
     dept_emp AS de
     ON dp.dept_no = de.dept_no AND de.to_date = '9999-01-01'
    INNER JOIN
     titles as t
     ON  de.emp_no = t.emp_no AND t.to_date = '9999-01-01'
GROUP BY dp.dept_no, t.title
ORDER BY dp.dept_no;

SQL28 查找描述信息中包括robot的电影对应的分类名称以及电影数目

题目描述
查找描述信息(film.description)中包含robot的电影对应的分类名称(category.name)以及电影数目(count(film.film_id))，而且还需要该分类包含电影总数量(count(film_category.category_id))>=5部

CREATE TABLE IF NOT EXISTS film (
film_id smallint(5)  NOT NULL DEFAULT '0',
title varchar(255) NOT NULL,
description text,
PRIMARY KEY (film_id));

CREATE TABLE category  (
category_id  tinyint(3)  NOT NULL ,
name  varchar(25) NOT NULL, `last_update` timestamp,
PRIMARY KEY ( category_id ));

CREATE TABLE film_category  (
film_id  smallint(5)  NOT NULL,
category_id  tinyint(3)  NOT NULL, `last_update` timestamp);

程序
（1）注意，分类下电影总数不是包含robot的而是原始film_category下计算的电影总数大于等于5；
（2）其他按规则联结。

SELECT c.name as '分类名称actegory.name',
       COUNT(fc.film_id) as '电影数目count(film.film_id)'
FROM film as f
    INNER JOIN film_category as fc
     ON f.film_id = fc.film_id AND f.description LIKE '%robot%'
    INNER JOIN category as c
     ON fc.category_id = c.category_id
    INNER JOIN (
        SELECT category_id, COUNT(film_id) as film_cnt
        FROM film_category
        GROUP BY category_id
        HAVING COUNT(film_id) >= 5
    ) as fc2
     ON fc.category_id = fc2.category_id
GROUP BY fc.category_id;

SQL29 使用join查询方式找出没有分类的电影id以及名称

题目描述
使用join查询方式找出没有分类的电影id以及名称

CREATE TABLE IF NOT EXISTS film (
film_id smallint(5)  NOT NULL DEFAULT '0',
title varchar(255) NOT NULL,
description text,
PRIMARY KEY (film_id));

CREATE TABLE category  (
category_id  tinyint(3)  NOT NULL ,
name  varchar(25) NOT NULL, `last_update` timestamp,
PRIMARY KEY ( category_id ));

CREATE TABLE film_category  (
film_id  smallint(5)  NOT NULL,
category_id  tinyint(3)  NOT NULL, `last_update` timestamp);

程序

SELECT f.film_id, f.title
FROM film as f
    LEFT JOIN
     film_category as fc
     ON f.film_id = fc.film_id
WHERE fc.category_id is NULL;

SQL30 使用子查询的方式找出属于Action分类的所有电影对应的title,description

题目描述
你能使用子查询的方式找出属于Action分类的所有电影对应的title,description吗

CREATE TABLE IF NOT EXISTS film (
film_id smallint(5)  NOT NULL DEFAULT '0',
title varchar(255) NOT NULL,
description text,
PRIMARY KEY (film_id));

CREATE TABLE category  (
category_id  tinyint(3)  NOT NULL ,
name  varchar(25) NOT NULL, `last_update` timestamp,
PRIMARY KEY ( category_id ));

CREATE TABLE film_category  (
film_id  smallint(5)  NOT NULL,
category_id  tinyint(3)  NOT NULL, `last_update` timestamp);

程序

SELECT f.title, f.description
FROM film as f
    INNER JOIN
     film_category as fc
     ON f.film_id = fc.film_id
    INNER JOIN
     category as c
     ON fc.category_id = c.category_id and c.name = 'ACTION';

SQL32 将employees表的所有员工的last_name和first_name拼接起来作为Name，中间以一个空格区分

题目描述
将employees表的所有员工的last_name和first_name拼接起来作为Name，中间以一个空格区分
(注：sqllite,字符串拼接为 || 符号，不支持concat函数，mysql支持concat函数)

CREATE TABLE `employees` ( `emp_no` int(11) NOT NULL,
`birth_date` date NOT NULL,
`first_name` varchar(14) NOT NULL,
`last_name` varchar(16) NOT NULL,
`gender` char(1) NOT NULL,
`hire_date` date NOT NULL,
PRIMARY KEY (`emp_no`));

程序

1 2	SELECT CONCAT(e.last_name, ' ', e.first_name) as Name # CONCATE(str1, str2, ...) FROM employees as e;

1 2	SELECT CONCAT_WS(' ', e.last_name, e.first_name) as Name # CONCATE_WS(seperator, str1, str2, ...) FROM employees as e;

SQL33 创建一个actor表，包含如下列信息

题目描述
创建一个actor表，包含如下列信息
|列表| 类型| 是否为NULL| 含义|
|–|–|–|–|
|actor_id| smallint(5) |not null |主键id|
|first_name |varchar(45) |not null |名字|
|last_name| varchar(45) |not null| 姓氏|
|last_update| date |not null| 日期|
程序

CREATE TABLE actor(
    actor_id smallint(5) not null,
    first_name varchar(45) not null,
    last_name varchar(45) not null,
    last_update date not null,
    primary key(actor_id)
);

SQL34 批量插入数据

题目描述
题目已经先执行了如下语句:

drop table if exists actor;
CREATE TABLE actor (
   actor_id  smallint(5)  NOT NULL PRIMARY KEY,
   first_name  varchar(45) NOT NULL,
   last_name  varchar(45) NOT NULL,
   last_update  DATETIME NOT NULL)

请你对于表actor批量插入如下数据(不能有2条insert语句哦!)
|actor_id |first_name| last_name| last_update|
|–|–|–|–|
|1| PENELOPE |GUINESS| 2006-02-15 12:34:33|
|2| NICK| WAHLBERG |2006-02-15 12:34:33|
程序

1
2
3

INSERT INTO actor(actor_id,first_name,last_name,last_update)
VALUES(1,"PENELOPE","GUINESS","2006-02-15 12:34:33"),
      (2,"NICK","WAHLBERG","2006-02-15 12:34:33");

SQL35 批量插入数据,如果数据已经存在，请忽略，不使用replace操作

题目描述
题目已经先执行了如下语句:

drop table if exists actor;
CREATE TABLE actor (
   actor_id  smallint(5)  NOT NULL PRIMARY KEY,
   first_name  varchar(45) NOT NULL,
   last_name  varchar(45) NOT NULL,
   last_update  DATETIME NOT NULL);
insert into actor values ('3', 'WD', 'GUINESS', '2006-02-15 12:34:33');

对于表actor插入如下数据,如果数据已经存在，请忽略(不支持使用replace操作)

1	'3' 'ED' 'CHASE' '2006-02-15 12:34:33'

程序

INSERT IGNORE INTO actor(actor_id,
                 first_name,
                 last_name,
                 last_update)
VALUES ('3', 'ED', 'CHASE', '2006-02-15 12:34:33');

SQL36 创建一个actor_name表，将actor表中的所有first_name以及last_name导入改表

题目描述
对于如下表actor，其对应的数据为:
actor_id first_name last_name last_update
1 PENELOPE GUINESS 2006-02-15 12:34:33
2 NICK WAHLBERG 2006-02-15 12:34:33

请你创建一个actor_name表，并且将actor表中的所有first_name以及last_name导入该表.
actor_name表结构如下：
列表类型是否为NULL 含义
first_name varchar(45) not null 名字
last_name varchar(45) not null 姓氏
程序

CREATE TABLE IF NOT EXISTS actor_name(
first_name VARCHAR(45) NOT NULL,
last_name VARCHAR(45) NOT NULL
);

INSERT INTO actor_name
SELECT first_name, last_name
FROM actor;

SQL37 对first_name创建唯一索引uniq_idx_firstname，对last_name创建普通索引idx_lastname

题目描述
针对如下表actor结构创建索引：
(注:在 SQLite 中,除了重命名表和在已有的表中添加列,ALTER TABLE 命令不支持其他操作，
mysql支持ALTER TABLE创建索引)

CREATE TABLE actor  (
   actor_id  smallint(5)  NOT NULL PRIMARY KEY,
   first_name  varchar(45) NOT NULL,
   last_name  varchar(45) NOT NULL,
   last_update  datetime NOT NULL);
对first_name创建唯一索引uniq_idx_firstname，对last_name创建普通索引idx_lastname

程序

1 2	ALTER TABLE actor ADD UNIQUE uniq_idx_firstname(first_name); ALTER TABLE actor ADD INDEX idx_lastname(last_name);