Développeurs: utilisez des majuscules pour les mots clés SQL et des minuscules pour tous les noms de colonnes et de tables
Premièrement, comprendre la base de données et la table
# Revenir à la liste des tableaux de données disponibles
USE testdb;# Utiliser la base de données testdb
USE testdb;# Afficher les tables de la base de données
SHOW TABLES;# Afficher les informations de la table clients
SHOW COLUMNS FROM customers;# Afficher les informations de la table des clients, version abrégée
DESCRIBE customers;Deuxièmement, récupérer des données
# Récupérer une seule colonne
SELECT prod_name FROM products;# Récupérer plusieurs colonnes
SELECT prod_id, prod_name, prod_price FROM products;# Récupérer toutes les colonnes (réduction de la récupération, performances de l'application)
SELECT * FROM products;# Récupère différentes lignes (ne renvoie que des valeurs différentes), DISTINCT ne peut pas être partiellement utilisé
SELECT DISTICT vend_id FROM products;# LIMIT 5 demande à MySQL de ne pas renvoyer plus de 5 lignes
SELECT prod_name FROM products LIMIT 5;# LIMIT 5,5 demande à MySQL de renvoyer 5 lignes à partir de la ligne 5, le premier numéro est la position de départ et le second est le nombre de lignes à récupérer
SELECT prod_name FROM products LIMIT 5,5;# Utilisez des noms de table complets (les noms de table et les noms de colonne peuvent être qualifiés)
SELECT products.prod_name FROM products;
SELECT products.prod_name FROM testdb.products;Troisièmement, trier et récupérer les données
# Trier les données par ordre alphabétique pour la colonne prod_name
SELECT prod_name FROM products ORDER BY prod_name;# Récupérez 3 colonnes et triez les résultats par deux, d'abord par prix, puis par nom
SELECT prod_id, prod_price, prod_name FROM products ORDER BY prod_price, prod_name;# Spécifiez le sens de tri, triez les produits par ordre décroissant de prix
SELECT prod_id, prod_price, prod_name FROM products ORDER BY prod_price DESC;# Le mot clé DESC n'est appliqué qu'au nom de la colonne directement devant lui. Si chaque colonne est triée par ordre décroissant, chaque colonne reçoit le mot clé DESC
SELECT prod_id, prod_price, prod_name FROM products ORDER BY prod_price DESC, prod_name;# Utilisez la combinaison ORDER BY et LIMIT pour trouver la valeur la plus élevée ou la plus basse dans une colonne
SELECT prod_price FROM products ORDER BY prod_price DESC LIMIT 1;Quatrièmement, filtrer les données
# Utilisez la clause WHERE pour ne renvoyer que les lignes avec une valeur prod_price de 2,50
SELECT prod_name, prod_price FROM products WHERE prod_price = 2.50;# Vérifiez une seule valeur. Des guillemets simples sont utilisés pour qualifier la chaîne. Si vous comparez la valeur avec une colonne de type chaîne, vous devez qualifier les guillemets. La valeur utilisée pour comparer avec la colonne numérique n'a pas de guillemets
SELECT prod_name, prod_price FROM products WHERE prod_name = 'fuses';
SELECT prod_name, prod_price FROM products WHERE prod_price <10;# Vérification des incompatibilités
SELECT vend_id, prod_name FROM products WHERE vend_id <> 1003;
SELECT vend_id, prod_name FROM products WHERE vend_id != 1003;# Vérification de la valeur de la plage
SELECT prod_name, prod_price FROM products WHERE prod_price BETWEEN 5 AND 10;# Contrôle nul
SELECT prod_name, prod_price FROM products WHERE prod_price IS NULL;
SELECT cust_id FROM customers WHERE cust_email IS NULL;Cinq, filtrage des données
# Combinaison clause WHERE
# Opérateur AND
SELECT prod_id, prod_price, prod_name FROM products WHERE vend_id = 1003 AND prod_price <= 10;# Opérateur OR
SELECT vend_id, prod_name, prod_price FROM products WHERE vend_id = 1002 OR vend_id = 1003;# Ordre de calcul, l'ordre d'opération de l'opérateur AND est supérieur à OR
SELECT prod_name, vend_id, prod_price FROM products WHERE vend_id = 1002 OR vend_id = 1003 AND prod_price >= 10;# Utilisez des parenthèses pour éliminer toute ambiguïté
SELECT prod_name, vend_id, prod_price FROM products WHERE (vend_id = 1002 OR vend_id = 1003) AND prod_price >= 10;
SELECT prod_name, vend_id, prod_price FROM products WHERE vend_id IN (1002, 1003) AND prod_price >= 10;# Opérateur IN
SELECT prod_name, vend_id, prod_price FROM products WHERE vend_id IN (1002, 1003) ORDER BY prod_name;
SELECT prod_name, vend_id, prod_price FROM products WHERE vend_id = 1002 OR vend_id = 1003 ORDER BY prod_name;
# Les résultats des deux instructions de requête ci-dessus sont les mêmes, pourquoi utiliser l'opérateur IN?
# Clair, intuitif et facile à gérer; l' opérateur IN est généralement plus rapide que l'exécution de la liste d'opérateurs OR ; peut contenir d'autres instructions SELECT
# opérateur NOT
SELECT prod_name, vend_id, prod_price FROM products WHERE vend_id NOT IN (1002,1003) ORDER BY prod_name;Six, utilisez des caractères génériques pour filtrer
# Opérateur LIKE
# Caractère générique de signe de pourcentage (%)
SELECT prod_name, prod_price FROM products WHERE prod_name LIKE 'jet%';
SELECT prod_name, prod_price FROM products WHERE prod_name LIKE '%anvil%'
SELECT prod_name, prod_price FROM products WHERE prod_name LIKE 's%e';# Caractère générique de soulignement (_), ne correspond qu'à un seul caractère au lieu de plusieurs caractères
SELECT prod_id, prod_name FROM products WHERE prod_name LIKE '_ ton anvil';
SELECT prod_id, prod_name FROM products WHERE prod_name LIKE '% ton anvil';# Précautions d'utilisation des caractères génériques:
- N'abusez pas des caractères génériques. Si d'autres opérateurs peuvent atteindre le même objectif, d'autres opérateurs devraient être utilisés;
- Lorsque vous avez vraiment besoin d'utiliser des caractères génériques, ne les utilisez pas au début du modèle de recherche à moins que cela ne soit absolument nécessaire. Mettez le caractère générique au début du motif de recherche, la recherche est la plus lente. Comme il s'agit d'une analyse complète de la table, la complexité temporelle est O (1).
- Faites très attention à la position du joker. S'il est égaré, il peut ne pas renvoyer les données souhaitées
Sept, recherche avec des expressions régulières
# Correspondance de caractères de base
SELECT prod_name FROM products WHERE prod_name REGEXP '1000' ORDER BY prod_name;# Est un caractère spécial dans le langage des expressions régulières, cela signifie correspondre à n'importe quel caractère
SELECT prod_name FROM products WHERE prod_name REGEXP '.000' ORDER BY prod_name;# Effectuer une correspondance OR, | est l'opérateur OR des expressions régulières
SELECT prod_name FROM products WHERE prod_name REGEXP '1000|2000' ORDER BY prod_name;# Correspond à l'un de plusieurs caractères, à compléter en spécifiant un groupe de caractères entre [et]
SELECT prod_name FROM products WHERE prod_name REGEXP '[123] Ton' ORDER BY prod_name;
SELECT prod_name FROM products WHERE prod_name REGEXP '[1|2|3] Ton' ORDER BY prod_name;# Les jeux de caractères peuvent également être annulés, c'est-à-dire qu'ils correspondent à tout sauf aux caractères spécifiés, il suffit de mettre un ^ au début de l'ensemble
SELECT prod_name FROM products WHERE prod_name REGEXP '[^123] Ton' ORDER BY prod_name;# Match range
# [0123456789] équivaut à [0-9]; la plage n'est pas limitée à l'ensemble complet, [1-3] et [6-9] sont également des plages légales; [az] correspond à n'importe quel caractère alphabétique
SELECT prod_name FROM products WHERE prod_name REGEXP '[1-5] Ton' ORDER BY prod_name;# Faire correspondre les caractères spéciaux
# Pour faire correspondre les caractères spéciaux, vous devez utiliser \\ comme début. \\ - signifie recherche-, \\ signifie recherche.
SELECT vend_name FROM vendors WHERE vend_name REGEXP '\\.' ORDER BY vend_name;Classe de caractères #Match
| expression | Signification de l'expression |
|---|---|
| [: Scooping] | Toutes les lettres et tous les chiffres (comme [a-zA-Z0-9]) |
| [:alpha:] | Tout caractère (identique à [a-zA-Z]) |
| [:Vide:] | Espaces et onglets (identiques à [\\ t]) |
| [: cntrl:] | Caractères de contrôle ASCII (ASCII 0 à 31 et 127) |
| [:chiffre:] | N'importe quel nombre (identique à [0-9]) |
| [:graphique:] | Identique à [: print:] mais n'inclut pas d'espaces |
| [:inférieur:] | Toute lettre minuscule (identique à [az]) |
| [:impression:] | Tout caractère imprimable |
| [:point:] | Tout caractère qui n'est ni dans [: alnum:] ni dans [: cntrl:] |
| [:espace:] | Tout caractère vide, y compris les espaces (identique à [\\ f \\ n \\ r \\ t \\ v]) |
| [:plus haut:] | Toute lettre majuscule (identique à [AZ]) |
| [: Xdigit] | Tout nombre hexadécimal (identique à [a-fA-F0-9]) |
| Rencontre | Description de la fonction |
|---|---|
| * | 0 correspondance ou plus |
| + | 1 ou plusieurs correspondances (égal à {1,}) |
| ? | 0 ou 1 correspondance (égal à {0,1}) |
| {n} | Nombre spécifié de correspondances |
| {n,} | Pas moins que le nombre spécifié de correspondances |
| {n, m} | Plage de nombres correspondants (m ne dépasse pas 255) |
SELECT prod_name FROM products WHERE prod_name REGEXP '\\([0-9] sticks?\\)' ORDER BY prod_name;
SELECT prod_name FROM products WHERE prod_name REGEXP '[[:digit:]]{4}' ORDER BY prod_name;
SELECT prod_name FROM products WHERE prod_name REGEXP '[0-9][0-9][0-9][0-9]' ORDER BY prod_name;#Locator
| Nom du localisateur | Description de la fonction |
|---|---|
| ^ | Début du texte |
| $ | Fin du texte |
| [[: <:]] | Le début du mot |
| [[:>:]] | Fin de mot |
#Recherchez avec un nombre (y compris les nombres commençant par un point décimal)
SELECT prod_name FROM products WHERE prod_name REGEXP '^[0-9\\.]' ORDER BY prod_name;Huit, créez un champ calculé
# Champs d'épissage, effet de sortie: ACME (USA)
SELECT CONCAT(vend_name, '(', vend_country, ')') FROM vendors ORDER BY vend_name;# Utiliser un alias
SELECT CONCAT(RTRIM(vend_name), '(', RTRIM(vend_country), ')') AS vend_title FROM vendors ORDER BY vend_name;
# Effectuer des opérations arithmétiques
SELECT prod_id, quantity, item_price, quantity * item_price AS expand_price FROM orderitems WHERE order_num = 20005;Neuf, utilisez les fonctions de traitement des données
# La portabilité de la fonction n'est pas très forte. Si vous décidez d'utiliser la fonction, vous devez vous assurer de faire des commentaires sur le code afin que vous (ou d'autres) puissiez connaître exactement la signification du code SQL compilé.
# Upper () Convertit le texte en majuscules
SELECT vend_name, Upper(vend_name) AS vend_name_upcase FROM vendors ORDER BY vend_name;
| Traitement du nom de la fonction de chaîne | Description de la fonction |
|---|---|
| La gauche() | Renvoie le caractère à gauche de la chaîne |
| Longueur() | Renvoie la longueur de la chaîne |
| Localiser() | Rechercher une sous-chaîne |
| Inférieur() | Convertir la chaîne en minuscules |
| LTrim () | Supprimez l'espace sur le côté gauche de la chaîne |
| Droite() | Renvoie le caractère à droite de la chaîne |
| RTrim () | Supprimez l'espace sur le côté droit de la chaîne |
| Soundex () | Renvoie la valeur SOUNDEX de la chaîne |
| Sous-chaîne () | Renvoie le caractère de la sous-chaîne |
| Plus haut() | Convertir la chaîne en majuscules |
# Fonction de traitement de la date et de l'heure, la date doit être au format aaaa-mm-jj
| Nom de la fonction | Description de la fonction |
|---|---|
| AddDate () | Ajouter une date (jour, semaine, etc.) |
| Ajouter du temps() | Ajoutez une heure (heure, minute, etc.) |
| CurDate () | Retourner la date actuelle |
| CurTime () | Retourner l'heure actuelle |
| Date() | Renvoie la partie date de la date et de l'heure |
| DateDiff () | Calculez la différence entre deux dates |
| Date_Add () | Fonction de calcul de date très flexible |
| Format de date() | Renvoie une chaîne de date ou d'heure formatée |
| Journée() | Renvoie la partie jours d'une date |
| Jour de la semaine () | Pour une date, retournez le jour de la semaine correspondant |
| Heure() | Renvoie la partie heure d'une heure |
| Minute() | 返回一个时间的分钟部分 |
| Month() | 返回一个日期的月份部分 |
| Now() | 返回当前日期和时间 |
| Second() | 返回一个时间的秒部分 |
| Time() | 返回一个日期时间的时间部分 |
| Year() | 返回一个日期的年份部分 |
# 如果要的是日期，请使用Date()，应该使用第二种方式，查询2005-09-01当天的记录
SELECT cust_id, order_num FROM orders WHERE order_date = '2005-09-01';
SELECT cust_id, order_num FROM orders WHERE Date(order_date) = '2005-09-01';# 检索出2005年9月下的所有定单
SELECT cust_id, order_num, order_date FROM orders WHERE Date(order_date) BETWEEN '2005-09-01' AND '2005-09-30';# 一种不需要记住每个月中有多少天或不需要操心闰年2月的办法
SELECT cust_id, order_num, order_date FROM orders WHERE Year(order_date) = 2005 AND Month(order_date) = 9;# 数值处理函数
| 函数名称 | 函数功能 |
|---|---|
| Abs() | 返回一个数的绝对值 |
| Cos() | 返回一个角度的余弦 |
| Exp() | 返回一个数的指数值 |
| Mod() | 返回除操作的余数 |
| Pi() | 返回圆周率 |
| Rand() | 返回一个随机数 |
| Sin() | 返回一个角度的正弦 |
| Sqrt() | 返回一个数的平方根 |
| Tan() | 返回一个角度的正切 |
十、汇总数据
| 函数名称 | 函数功能 |
|---|---|
| AVG() | 返回某列的平均值 |
| COUNT() | 返回某列的行数 |
| MAX() | 返回某列的最大值 |
| MIN() | 返回某列的最小值 |
| SUM() | 返回某列值之和 |
# AVG()函数
SELECT AVG(prod_price) AS prod_avg_price FROM products;
SELECT AVG(prod_price) AS avg_price FROM products WHERE vend_id = 1003;# COUNT()函数
SELECT COUNT(*) AS num_cust FROM customers;
SELECT COUNT(cust_email) AS num_cust FROM customers;# MAX()函数
SELECT MAX(prod_price) AS max_prod_price FROM products;# MIN()函数
SELECT MIN(prod_price) AS min_price FROM products;# SUM()函数
SELECT SUM(quantity) AS items_ordered FROM orderitems WHERE order_num = 20005;# 聚集不同值
SELECT AVG(DISTINCT prod_price) AS prod_price FROM products WHERE vend_id = 1003;# 组合聚集函数
SELECT COUNT(*) AS num_items, MIN(prod_price) AS min_price, MAX(prod_price) AS max_price, AVG(prod_price) AS avg_price FROM products;十一、分组数据
# 创建分组，GROUP BY子句指示MYSQL按vend_id排序并分组数据
SELECT vend_id, COUNT(*) AS num_prods FROM products GROUP BY vend_id;# 过滤分组
# WHERE过滤行，而HAVING过滤分组
SELECT cust_id, COUNT(*) AS orders_num FROM orders GROUP BY cust_id HAVING COUNT(*) >= 2;
SELECT cust_id, COUNT(*) AS orders_num FROM orders GROUP BY cust_id HAVING cust_id = 10001;
SELECT vend_id, COUNT(*) AS num_prods FROM products WHERE prod_price >= 10 GROUP BY vend_id HAVING COUNT(*) >= 2;
SELECT vend_id, COUNT(*) AS num_prods FROM products GROUP BY vend_id HAVING COUNT(*) >= 2;# 分组和排序 ORDER BY GROUP BY
排序产生的输出 分组行。但输出可能不是分组的顺序任意列都可以使用（甚至非选择的列也可以使用）只可能使用选择列或表达式列，而且必须使用每个选择列表达式不一定需要 如果与聚集函数一起使用列（或表达式），则必须使用
# 不要忘记ORDER BY，一般在使用GROUP BY 子句时，应该也给出ORDER BY 子句，
# SELECT 子句顺序
--子句--------说明-------------------是否必须使用-------------
SELECT 要返回的列或表达式 是
FROM 从中检索数据的表仅在从表选择数据时使用
WHERE 行级过滤否
GROUP BY 分组说明 仅在按组计算聚集时使用
HAVING 组级过滤否
ORDER BY 输出排序顺序否
LIMIT 要检索的行数否
十二、使用子查询
# 利用子查询进行过滤
# 列出订购物品TNT2的所有客户
SELECT cust_id, cust_name FROM customers WHERE cust_id IN (SELECT cust_id FROM orders WHERE order_num IN (SELECT order_num FROM orderitems WHERE prod_id = 'TNT2'));# 作为计算字段使用
# 需要显示customers表中每个客户的订单总数
SELECT cust_name, cust_state, (SELECT COUNT(*) FROM orders WHERE orders.cust_id = customers.cust_id) AS orders_num FROM customers ORDER BY cust_name;十三、联结表
外键（foreign key） 外键为某个表中的一列，它包含另一个表的主键值，定义了两个表之间的关系。
# 为什么要使用联结
# 正如所述，分解数据为多个表能更有效地存储，更方便地处理，并且具有更大的可伸缩性。但这些好处是有代价的。如果数据存储在多个表中，怎样用单条SELECT语句检索出数据？答案是使用联结。简单地说，联结是一种机制，用来在一条SELECT语句中关联表，因此称之为联结。使用特殊的语法，可以联结多个表返回一组输出，联结在运行时关联表中正确的行。
# 创建联结
SELECT vend_name, prod_name, prod_price FROM vendors, products WHERE vendors.vend_id = products.vend_id ORDER BY vend_name, prod_name;# 利用WHERE子句建立联结，必须WHERE子句作为过滤条件
不要忘了WHERE子句 应该保证所有联结都有WHERE子句，否则MySQL将返回比想要的数据多得多的数据。同理，应该保证WHERE子句的正确性。不正确的过滤条件将导致MySQL返回不正确的数据。
# 内部联结(与上述运行结果一致)
SELECT vend_name, prod_name, prod_price FROM vendors INNER JOIN products ON vendors.vend_id = products.vend_id;# 使用哪种语法 ANSI SQL规范首选INNER JOIN语法。此外，尽管使用WHERE子句定义联结的确比较简单，但是使用明确的联结语法能够确保不会忘记联结条件，有时候这样做也能影响性能。
# 性能考虑 MySQL在运行时关联指定的每个表以处理联结。这种处理可能是非常耗费资源的，因此应该仔细，不要联结不必要的表。联结的表越多，性能下降越厉害。
SELECT prod_name, vend_name, prod_price, quantity
FROM
products, orderitems, vendors
WHERE products.prod_id = orderitems.prod_id AND vendors.vend_id = products.vend_id AND order_num = 20005;# 查询订购产品TNT2的客户列表
SELECT cust_name, cust_address
FROM customers
WHERE cust_id IN
(SELECT cust_id
FROM orders
WHERE order_num IN
(SELECT order_num
FROM orderitems
WHERE prod_id = 'TNT2'));SELECT cust_name, cust_address
FROM customers, orders, orderitems
WHERE customers.cust_id = orders.cust_id AND orders.order_num = orderitems.order_num AND orderitems.prod_id = 'TNT2';十四、创建高级联结
# 使用表别名
SELECT cust_name, cust_contact
FROM customers AS c, orders AS o, orderitems AS oi
WHERE o.cust_id = c.cust_id AND o.order_num = oi.order_num AND oi.prod_id = 'TNT2';# 自联结
SELECT prod_id, prod_name
FROM products
WHERE vend_id =
(SELECT vend_id
FROM products
WHERE prod_id = 'DTNTR');SELECT p1.prod_id, p1.prod_name
FROM products AS p1, products AS p2
WHERE p1.vend_id = p2.vend_id AND p2.prod_id = 'DTNTR';用自联结而不用子查询 自联结通常作为外部语句用来替代从相同表中检索数据时使用的子查询语句。虽然最终的结果是相同的，但有时候处理联结远比处理子查询快得多。应该试一下两种方法，以确定哪一种的性能更好。
# 自然联结
无论何时对表进行联结，应该至少有一个列出现在不止一个表中（被联结的列）。标准的联结（前一章中介绍的内部联结）返回所有数据，甚至相同的列多次出现。自然联结排除多次出现，使每个列只返回一次。怎样完成这项工作呢？答案是，系统不完成这项工作，由你自己完成它。自然联结是这样一种联结，其中你只能选择那些唯一的列。这一般是通过对表使用通配符（SELECT *），对所有其他表的列使用明确的子集来完成的。下面举一个例子：
SELECT c.*, o.order_num, o.order_date, oi.prod_id, oi.quantity, oi.item_price
FROM customers AS c, orders AS o, orderitems AS oi
WHERE c.cust_id = o.cust_id AND o.order_num = oi.order_num AND prod_id = 'FB';# 外部联结
# 如下是内部联结
SELECT customers.cust_id, orders.order_num
FROM customers INNER JOIN orders
ON customers.cust_id = orders.cust_id;# 如下是外部联结
SELECT customers.cust_id, orders.order_num
FROM customers LEFT OUTER JOIN orders
ON customers.cust_id = orders.cust_id;
在使用OUTER JOIN语法时，必须使用RIGHT或LEFT关键字指定包括其所有行的表（RIGHT指出的是OUTER JOIN右边的表，而LEFT指出的是OUTER JOIN左边的表）。
# 检索所有客户及每个客户所下的订单数
SELECT customers.cust_name, customers.cust_id, COUNT(orders.order_num) AS total_order_num
FROM customers LEFT OUTER JOIN orders
ON orders.cust_id = customers.cust_id GROUP BY customers.cust_id;十五、组合查询
# 使用UNION。UNION的使用很简单。所需做的只是给出每条SELECT语句，在各条语句之间放上关键字UNION。
# UNION规则。UNION必须由两条或两条以上的SELECT语句组成，语句之间用关键字UNION分隔（因此，如果组合4条SELECT语句，将要使用3个
UNION关键字）。 UNION中的每个查询必须包含相同的列、表达式或聚集函数（不过分析各个列不需要以相同的次序列出）。列数据类型必须兼容：类型不必完全相同，但必须是DBMS可以隐含地转换的类型（例如，不同的数值类型或不同的日期类型）。如果遵守了这些基本规则或限制，则可以将并用于任何数据检索任务。
# 包含或取消重复的行。如果想返回所有匹配行，可使用UNION ALL而不是UNION。默认是取消重复行
# 对组合查询结果排序。SELECT语句的输出用ORDER BY子句排序。在用UNION组合查询时，只能使用一条ORDER BY子句，它必须出现在最后一条SELECT语句之后。对于结果集，不存在用一种方式排序一部分，而又用另一种方式排序另一部分的情况，因此不允许使用多条ORDER BY子句。
SELECT vend_id, prod_id, prod_price
FROM products WHERE prod_price <= 5
UNION ALL
SELECT vend_id, prod_id, prod_price
FROM products
WHERE vend_id IN (1001,1002)
ORDER BY vend_id, prod_id;
十六、全文本搜索
# 启用全文本搜索支持
一般在创建表时启用全文本搜索。CREATE TABLE语句接受FULLTEXT子句，它给出被索引列的一个逗号分隔的列表。
# 进行全文本搜索。在索引之后，使用两个函数Match()和Against()执行全文本搜索，其中Match()指定被搜索的列，Against()指定要使用的搜索表达式。
SELECT note_text FROM productnotes WHERE Match(note_text) Against('rabbit');全文本搜索的一个重要部分就是对结果排序。具有较高等级的行先返回（因为这些行很可能是你真正想要的行）。
# 使用查询扩展
SELECT note_text FROM productnotes WHERE Match(note_text) Against('anvils' WITH QUERY EXPANSION);# 布尔文本搜索
SELECT note_text FROM productnotes WHERE Match(note_text) Against('heavy' IN BOOLEAN MODE);# 为了匹配包含heavy但不包含任意以rope开始的词的行
SELECT note_text FROM productnotes WHERE Match(note_text) Against('heavy -rope*' IN BOOLEAN MODE);
| 操作符名称 | 功能说明 |
|---|---|
| + | 包含，词必须存在 |
| - | 排除，词必须不出现 |
| > | 包含，而且增加等级值 |
| < | 包含，且减少等级值 |
| () | 把词组成子表达式（允许这些子表达式作为一个组被包含、排除、排列等） |
| ~ | 取消一个词的排序值 |
| * | 词尾的通配符 |
| "" | 定义一个短语（与单个词的列表不一样，它匹配整个短语以便包含或排除这个短语） |
十七、插入数据
# 插入完整行
INSERT INTO customers
(cust_name, cust_address, cust_city, cust_state, cust_zip, cust_country, cust_contact, cust_email)
VALUES
('Pep E. LaPew', '100 Main Street', 'Los Angeles', 'CA', '90046', 'USA', NULL, NULL);# 插入多个行
INSERT INTO customers
(cust_name, cust_address, cust_city, cust_state, cust_zip, cust_country)
VALUES
('Pep E. LaPew', '100 Main Street', 'Los Angeles', 'CA', '90046', 'USA'),
('M. Martian', '42 Galaxy Way', 'New York', 'NY', '11213', 'USA');提高 Insert 的性能 此技术可以提高数据库处理的性能，因为MySQL用单条 Insert语句处理多个插入比使用多条Insert语句快。
# 插入检索出的数据
INSERT一般用来给表插入一个指定列值的行。但是，INSERT还存在另一种形式，可以利用它将一条SELECT语句的结果插入表中。这就是所谓的INSERT SELECT，顾名思义，它是由一条INSERT语句和一条SELECT语句组成的。
INSERT INTO customers
(cust_name, cust_address, cust_city, cust_state, cust_zip, cust_country)
SELECT
cust_name, cust_address, cust_city, cust_state, cust_zip, cust_country
FROM custNew;十八、更新和删除数据
# 更新数据
UPDATE customers SET cust_email = '[email protected]' WHERE cust_id = 10005;
UPDATE customers SET cust_name = 'The Fudds', cust_email = '[email protected]' WHERE cust_id = 10005;# 为了删除某列的值，可设置它为NULL（假如表定义允许NULL值）
UPDATE customers SET cust_email = NULL WHERE cust_id = 10005;# 删除数据
DELECT FROM customers WHERE cust_id = 10006;# 删除表所有内容(第二条语句更快)，（TRUNCATE实际是删除原来的表并重新创建一个表，而不是逐行删除表中的数据）。
DELECT FROM customers;
TRUNCATE TABLE customers;
下面是许多SQL程序员使用UPDATE或DELETE时所遵循的习惯。除非确实打算更新和删除每一行，否则绝对不要使用不带WHERE 子句的UPDATE或DELETE语句。保证每个表都有主键，尽可能像WHERE子句那样使用它（可以指定各主键、多个值或值的范围）。在对UPDATE或DELETE语句使用WHERE子句前，应该先用SELECT进行测试，保证它过滤的是正确的记录，以防编写的WHERE子句不正确。 使用强制实施引用完整性的数据库，这样MySQL将不允许删除具有与其他表相关联的数据的行。
十九、创建和操纵表
# 创建表
为利用CREATE TABLE创建表，必须给出下列信息：新表的名字，在关键字CREATE TABLE之后给出；表列的名字和定义，用逗号分隔。
CREATE TABLE IF NOT EXISTS customers_Test(
cust_id int NOT NULL AUTO_INCREMENT,
cust_name char(50)NOT NULL,
cust_address char(50)NULL,
cust_city char(50) NULL,
cust_state char(5) NULL,
cust_zip char(10) NULL,
cust_country char(50)NULL,
cust_contact char(50)NULL,
cust_email char(255) NULL,
PRIMARY KEY (cust_id)
) ENGINE=InnoDB;# 使用NULL值
NULL值就是没有值或缺值。允许NULL值的列也允许在插入行时不给出该列的值。不允许NULL值的列不接受该列没有值的行，换句话说，在插入或更新行时，该列必须有值。每个表列或者是NULL列，或者是NOT NULL列，这种状态在创建时由表的定义规定。
CREATE TABLE IF NOT EXISTS orders_test (
order_num intNOT NULL AUTO_INCREMENT,
order_date datetimeNOT NULL,
cust_id int NOT NULL,
PRIMARY KEY (order_num)
) ENGINE = InnoDB;# 主键再介绍
主键值必须唯一。即，表中的每个行必须具有唯一的主键值。如果主键使用单个列，则它的值必须唯一。如果使用多个列，则这些列的组合值必须唯一。迄今为止我们看到的CREATE TABLE例子都是用单个列作为主键。其中主键用以下的类似的语句定义：为创建由多个列组成的主键，应该以逗号分隔的列表给出各列名。
# 使用AUTO_INCREMENT
每个表只允许一个AUTO_INCREMENT列，而且它必须被索引（如，通过使它成为主键）。
# 指定默认值
CREATE TABLE IF NOT EXISTS orderitems_test (
order_num intNOT NULL,
order_item int NOT NULL,
prod_id char(10)NOT NULL,
quantity int NOT NULL DEFAULT 1,
item_price decimal(8,2)NOT NULL,
PRIMARY KEY (order_num, order_item)
) ENGINE = InnoDB;
# 引擎类型
以下是几个需要知道的引擎：InnoDB是一个可靠的事务处理引擎，它不支持全文本搜索；MEMORY在功能等同于MyISAM，但由于数据存储在内存（不是磁盘）中，速度很快（特别适合于临时表）；MyISAM是一个性能极高的引擎，它支持全文本搜索，但不支持事务处理。
# 更新表
# 增加列
ALTER TABLE vendors ADD vend_phone CHAR(20);# 删除列
ALTER TABLE vendors DROP COLUMN vend_phone;注意：小心使用ALTER TABLE 使用ALTER TABLE要极为小心，应该在进行改动前做一个完整的备份（模式和数据的备份）。数据库表的更改不能撤销，如果增加了不需要的列，可能不能删除它们。类似地，如果删除了不应该删除的列，可能会丢失该列中的所有数据。
# 删除表
DROP TABLE orderitems_test;# 重命名表
RENAME TABLE customers2 TO customers;
二十、使用视图
重要的是知道视图仅仅是用来查看存储在别处的数据的一种设施。视图本身不包含数据，因此它们返回的数据是从其他表中检索出来的。在添加或更改这些表中的数据时，视图将返回改变过的数据。
性能问题 因为视图不包含数据，所以每次使用视图时，都必须处理查询执行时所需的任一个检索。如果你用多个联结和过滤创建了复杂的视图或者嵌套了视图，可能会发现性能下降得很厉害。因此，在部署使用了大量视图的应用前，应该进行测试。
CREATE VIEW productcustomers AS SELECT cust_name, cust_contact, prod_id
FROM customers, orders, orderitems
WHERE customers.cust_id = orders.cust_id AND orders.order_num = orderitems.order_num;
SELECT cust_name, cust_contact FROM productcustomers WHERE prod_id = 'TNT2';创建可重用的视图 创建不受特定数据限制的视图是一种好办法。例如，上面创建的视图返回生产所有产品的客户而不仅仅是生产TNT2的客户。扩展视图的范围不仅使得它能被重用，而且甚至更有用。这样做不需要创建和维护多个类似视图。
CREATE VIEW vendorlocations AS
SELECT Concat(RTrim(vend_name), '(', RTrim(vend_country), ')') AS vend_title
FROM vendors ORDER BY vend_name;SELECT * FROM vendorlocations;CREATE VIEW customers_email_list AS
SELECT cust_name, cust_email
FROM customers WHERE cust_email IS NOT NULL;select * from customers_email_list;CREATE VIEW orderitems_expand_price AS
SELECT order_num, prod_id, quantity, item_price, quantity*item_price AS expanded_price FROM orderitems;
SELECT * FROM orderitems_expand_price WHERE order_num = 20005;
二十二.使用存储过程
存储过程简单来说，就是为以后的使用而保存的一条或多条MySQL语句的集合。可将其视为批文件，虽然它们的作用不仅限于批处理。
# 创建存储过程
DELIMITER //
CREATE PROCEDURE productpricing()
BEGIN
SELECT Avg(prod_price) AS priceaverage FROM products;
END; //
DELIMITER ;# 使用存储过程，存储过程实际上是一种函数，所以存储过程名后需要有()符号（即使不传递参数也需要）。
CALL productpricing();# 删除存储过程
DROP PROCEDURE productpricing;
DROP PROCEDURE IF EXISTS productpricing;# 使用参数
DELIMITER //
CREATE PROCEDURE productpricing(
OUT pl DECIMAL(8,2),
OUT ph DECIMAL(8,2),
OUT pa DECIMAL(8,2)
)
BEGIN
SELECT Min(prod_price)
INTO pl
FROM products;
SELECT Max(prod_price)
INTO ph
FROM products;
SELECT Avg(prod_price)
INTO pa
FROM products;
END; //
DELIMITER ;此存储过程接受3个参数：pl存储产品最低价格，ph存储产品最高价格，pa存储产品平均价格。每个参数必须具有指定的类型，这里使用十进制值。关键字OUT指出相应的参数用来从存储过程传出一个值（返回给调用者）。MySQL支持IN（传递给存储过程）、OUT（从存储过程传出，如这里所用）和INOUT（对存储过程传入和传出）类型的参数。存储过程的代码位于BEGIN和END语句内，如前所见，它们是一系列SELECT语句，用来检索值，然后保存到相应的变量（通过指定INTO关键字）。
CALL productpricing(@pricelow, @pricehigh, @priceaverage);
SELECT @priceaverage;
SELECT @pricehigh, @pricelow, @priceaverage;# 使用IN和OUT参数，ordertotal接受订单号并返回订单的合计：
DELIMITER //
CREATE PROCEDURE ordertotal(
IN onumber INT,
OUT ototal DECIMAL(8,2)
)
BEGIN
SELECT Sum(item_price * quantity) FROM orderitems WHERE order_num = onumber INTO ototal;
END; //
DELIMITER ;
CALL ordertotal(20005, @total);
SELECT @total;
# 建立智能存储过程
考虑这个场景。你需要获得与以前一样的订单合计，但需要对合计增加营业税，不过只针对某些顾客（或许是你所在州中那些顾客）。那么，你需要做下面几件事情：获得合计（与以前一样）；把营业税有条件地添加到合计；返回合计（带或不带税）。存储过程的完整工作如下：
DELIMITER //
CREATE PROCEDURE ordertotal(
IN onumber INT,
IN taxable BOOLEAN,
OUT ototal DECIMAL(8,2)
) COMMENT 'Obtain order total, optionally adding tax'
BEGIN
Declare total DECIMAL(8,2);
Declare taxrate INT DEFAULT 6;
SELECT Sum(item_price * quantity)
FROM orderitems
WHERE order_num = onumber
INTO total;
IF taxable THEN
SELECT total+(total/100*taxrate) INTO total;
END IF;
SELECT total INTO ototal;
END; //
DELIMITER ;
CALL ordertotal(20005, 0, @total);
SELECT @total;二十三、使用游标
游标（cursor）是一个存储在MySQL服务器上的数据库查询，它不是一条SELECT语句，而是被该语句检索出来的结果集。在存储了游标之后，应用程序可以根据需要滚动或浏览其中的数据。
游标主要用于交互式应用，其中用户需要滚动屏幕上的数据，并对数据进行浏览或做出更改。
文章最后，给大家推荐一些受欢迎的技术博客链接：
- JAVA相关的深度技术博客链接
- Flink 相关技术博客链接
- Spark 核心技术链接
- 设计模式 —— 深度技术博客链接
- 机器学习 —— 深度技术博客链接
- Hadoop相关技术博客链接
- 超全干货--Flink思维导图，花了3周左右编写、校对
- 深入JAVA 的JVM核心原理解决线上各种故障【附案例】
- 请谈谈你对volatile的理解？--最近小李子与面试官的一场“硬核较量”
- 聊聊RPC通信，经常被问到的一道面试题。源码+笔记，包懂
- 深入聊聊Java 垃圾回收机制【附原理图及调优方法】
欢迎扫描下方的二维码或 搜索 公众号“大数据高级架构师”，我们会有更多、且及时的资料推送给您，欢迎多多交流！
