Questions d'entretien MySQL avec réponses-2019

Avec l'avancement et le développement de la technologie, les intervieweurs ont des exigences de plus en plus élevées envers les personnes interrogées. Désormais, tant qu'il s'agit d'un poste de développement back-end, l'entretien sera certainement le cas. posez des questions sur la base de données Des connaissances pertinentes, et mysql est actuellement la technologie gratuite de gestion de bases de données relationnelles la plus populaire Il n'est pas surprenant que des questions à ce sujet soient posées lors des entretiens. Alors maintenant, nous avons rassemblé pour vous quelques questions et réponses d’entretien. Jetons un coup d'oeil.

Tutoriel recommandé : Vidéo d'introduction à MySQL

1. Clé primaire super clé candidate clé étrangère

Clé primaire :

Stocker la paire dans la table de base de données Combinaison de colonnes de données ou d'attributs qui identifie de manière unique et complète un objet de données. Une colonne de données ne peut avoir qu'une seule clé primaire et la valeur de la clé primaire ne peut pas manquer, c'est-à-dire qu'elle ne peut pas être nulle.

Super clé :

L'ensemble des attributs qui peuvent identifier de manière unique un tuple dans une relation est appelé la super clé de la clé du modèle relationnel. Un attribut peut être utilisé comme super clé, et plusieurs attributs combinés peuvent également être utilisés comme super clé. La super clé contient la clé candidate et la clé primaire.

Clé candidate :

est la super-clé minimale, c'est-à-dire une super-clé sans éléments redondants.

Clé étrangère :

La clé primaire d'une autre table qui existe dans une table est appelée clé étrangère de ce tableau.

2. Quatre caractéristiques et significations des transactions de base de données

Quatre éléments de base pour l'exécution correcte des transactions de base de données . ACIDE, Atomicité, Correspondance, Isolement, Durabilité.

Atomicité : Toutes les opérations de l'ensemble de la transaction sont soit terminées, soit non terminées, et il est impossible de stagner dans un lien intermédiaire. Si une erreur se produit lors de l'exécution de la transaction, elle sera restaurée à l'état avant le début de la transaction, comme si la transaction n'avait jamais été exécutée.

Cohérence : Les contraintes d'intégrité de la base de données ne sont pas violées avant le début de la transaction et après la fin de la transaction.

Isolement : L'état d'isolement exécute les transactions de manière à ce qu'elles apparaissent comme les seules opérations effectuées par le système à un moment donné. S'il y a deux transactions exécutées en même temps et remplissant la même fonction, l'isolation des transactions garantira que chaque transaction du système pense que seule cette transaction utilise le système. Cette propriété est parfois appelée sérialisation. Pour éviter toute confusion entre les opérations de transaction, les requêtes doivent être sérialisées ou désérialisées afin qu'il n'y ait qu'une seule requête pour les mêmes données à la fois.

Persistance : Une fois la transaction terminée, les modifications apportées à la base de données par la transaction sont enregistrées de manière permanente dans la base de données et ne seront pas être annulé.

3. Le rôle de la vue La vue peut-elle être modifiée ?

Une vue est une table virtuelle Contrairement à une table contenant des données, une vue contient uniquement des requêtes qui récupèrent dynamiquement des données lorsqu'elles sont utilisées, elle ne contient aucune colonne ni donnée. L'utilisation de vues peut simplifier des opérations SQL complexes, masquer des détails spécifiques et protéger les données ; une fois les vues créées, elles peuvent être utilisées de la même manière que les tables.

La vue ne peut pas être indexée, et elle ne peut pas non plus avoir de déclencheurs associés ou de valeurs par défaut. S'il y a un ordre par dans la vue elle-même, l'ordre par à nouveau sur la vue sera écrasé.

Créer une vue : créez la vue XXX en tant que XXXXXXXXXXXXX ; elle peut être mise à jour, et les mises à jour de la vue mettront à jour la table de base, cependant, la vue est principalement utilisée pour simplifier la récupération et la protection ; données, pas pour la mise à jour, et la plupart des vues ne peuvent pas être mises à jour.

4. La différence entre supprimer, supprimer et tronquer

Supprimer supprime directement la table et tronquer supprime les données dans le tableau. Lors de l'insertion à nouveau, l'identifiant augmentera automatiquement et la suppression commencera à 1 pour supprimer les données du tableau. Vous pouvez ajouter une clause Where.

(1) Le processus de suppression par l'instruction DELETE consiste à supprimer une ligne de la table à la fois, et en même temps, l'opération de suppression de la ligne est enregistrée dans le journal en tant qu'enregistrement de transaction pour l'opération de restauration. TRUNCATE TABLE supprime toutes les données de la table en même temps et n'enregistre pas les enregistrements d'opérations de suppression individuelles dans le journal. Les lignes supprimées ne peuvent pas être récupérées. Et le déclencheur de suppression lié à la table ne sera pas activé pendant le processus de suppression. La vitesse d'exécution est rapide.

　 (2) L'espace occupé par les tables et les index. Lorsqu'une table est TRUNCATE, l'espace occupé par la table et les index sera restauré à sa taille d'origine et l'opération DELETE ne réduira pas l'espace occupé par la table ou les index. L'instruction drop libère tout l'espace occupé par la table.

(3) De manière générale, supprimez > tronquer > supprimer

(4) Champ d'application. TRUNCATE ne peut être utilisé que pour TABLE ; DELETE peut être une table et une vue

(5) TRUNCATE et DELETE suppriment uniquement les données, tandis que DROP supprime la table entière (structure et données).

(6) tronquer et supprimer sans où : supprime uniquement les données, mais pas la structure (définition) de la table L'instruction drop supprimera les contraintes (contrainte) sur lesquelles la. la structure de la table dépend. , Index de déclenchement (index) ; les procédures/fonctions stockées qui dépendent de la table seront conservées, mais leur statut deviendra : invalide.

(7) L'instruction de suppression est DML (langage de maintenance des données). Cette opération sera placée dans le segment de restauration et prendra effet après la soumission de la transaction. S'il existe un tigre correspondant, il sera déclenché lors de l'exécution.

(8) tronquer et supprimer sont des DLL (langage de définition des données). Les opérations prennent effet immédiatement. Les données d'origine ne sont pas placées dans le segment de restauration et ne peuvent pas être restaurées .

　(9) S'il n'y a pas de sauvegarde, utilisez drop et troncate avec prudence. Pour supprimer certaines lignes de données, utilisez delete et combinez-les avec où limiter la portée de l'influence. Le segment d'annulation doit être suffisamment grand. Pour supprimer une table, utilisez drop ; si vous souhaitez conserver la table mais supprimer les données de la table, si cela n'a rien à voir avec la transaction, utilisez truncate. Si cela est lié à une transaction ou si l'enseignant souhaite déclencher un déclencheur, utilisez toujours la suppression.

　(10) Truncate table Le nom de la table est rapide et efficace car :
truncate table est fonctionnellement identique à l'instruction DELETE sans clause WHERE : les deux suppriment toutes les lignes de la table . Cependant, TRUNCATE TABLE est plus rapide que DELETE et utilise moins de ressources système et du journal des transactions. L'instruction DELETE supprime une ligne à la fois et enregistre une entrée dans le journal des transactions pour chaque ligne supprimée. TRUNCATE TABLE supprime les données en libérant les pages de données utilisées pour stocker les données de la table et enregistre uniquement la page libérée dans le journal des transactions.

　 (11) TRUNCATE TABLE supprime toutes les lignes de la table, mais la structure de la table et ses colonnes, contraintes, index, etc. restent inchangés. Le nombre utilisé pour identifier les nouvelles lignes est réinitialisé à la valeur de départ de cette colonne. Si vous souhaitez conserver la valeur du nombre d'identités, utilisez plutôt DELETE. Si vous souhaitez supprimer une définition de table et ses données, utilisez l'instruction DROP TABLE.

　 (12) Pour les tables référencées par des contraintes FOREIGN KEY, TRUNCATE TABLE ne peut pas être utilisée, mais une instruction DELETE sans clause WHERE doit être utilisée. Étant donné que TRUNCATE TABLE n'est pas journalisé, il ne peut pas activer le déclencheur.

5. Le principe de fonctionnement et les types d'index

　L'index de base de données est une base de données Une structure de données triée dans le système de gestion pour aider à interroger et mettre à jour rapidement les données dans les tables de base de données. L'implémentation de l'index utilise généralement B-tree et sa variante B+-tree.

En plus des données, le système de base de données conserve également des structures de données qui satisfont des algorithmes de recherche spécifiques. Ces structures de données font référence (pointent vers) les données d'une manière ou d'une autre, de sorte que ces structures de données. peut mettre en œuvre des algorithmes de recherche avancés. Cette structure de données est un index.

Il y a un prix à payer pour définir un index sur une table : premièrement, cela augmente l'espace de stockage de la base de données, et deuxièmement, cela prend plus de temps pour insérer et modifier les données ( car l'index doit également être modifié à tout moment).

L'image montre une méthode d'indexation possible. Sur la gauche se trouve un tableau de données avec un total de deux colonnes et sept enregistrements. Celui le plus à gauche est l'adresse physique de l'enregistrement de données (notez que les enregistrements logiquement adjacents ne sont pas nécessairement physiquement adjacents sur le disque). Afin d'accélérer la recherche de Col2, vous pouvez conserver un arbre de recherche binaire comme indiqué à droite. Chaque nœud contient la valeur de la clé d'index et un pointeur vers l'adresse physique de l'enregistrement de données correspondant. recherche binaire dans O(log2n) Les données correspondantes sont obtenues dans la complexité.

La création d'un index peut grandement améliorer les performances du système.

Premièrement, en créant un index unique, l'unicité de chaque ligne de données dans la table de la base de données peut être garantie.

Deuxièmement, cela peut considérablement accélérer la récupération des données, ce qui est également la principale raison de la création d'un index.

Troisièmement, cela peut accélérer la connexion entre les tables, ce qui est particulièrement important pour atteindre l'intégrité référentielle des données.

Quatrièmement, lors de l'utilisation de clauses de regroupement et de tri pour la récupération de données, le temps de regroupement et de tri dans la requête peut également être considérablement réduit.

Cinquièmement, en utilisant des index, vous pouvez utiliser des caches d'optimisation pendant le processus de requête pour améliorer les performances du système.

Quelqu'un pourrait se demander : il y a tellement d'avantages à ajouter un index, pourquoi ne pas créer un index pour chaque colonne du tableau ? Car l’ajout d’index présente également de nombreux inconvénients.

Premièrement, la création et la maintenance des index prennent du temps, et ce temps augmente à mesure que la quantité de données augmente.

Deuxièmement, les index doivent occuper de l'espace physique en plus de l'espace de données occupé par la table de données, chaque index occupe également une certaine quantité d'espace physique. index clusterisé, alors vous avez besoin L'espace sera plus grand.

Troisièmement, lorsque les données de la table sont ajoutées, supprimées et modifiées, l'index doit être maintenu dynamiquement, ce qui réduit la vitesse de maintenance des données.

Les index sont construits sur certaines colonnes de la table de la base de données. Lors de la création d'un index, vous devez déterminer sur quelles colonnes peuvent être indexées et quelles colonnes ne peuvent pas être indexées. De manière générale, des index doivent être créés sur ces colonnes : sur les colonnes fréquemment recherchées, cela peut accélérer les recherches ; sur les colonnes qui servent de clés primaires, cela renforce l'unicité de la colonne et organise la structure de disposition des données dans la table. ; sur les colonnes souvent recherchées, Utilisées sur les colonnes connectées, ces colonnes sont principalement des clés étrangères, ce qui peut accélérer la connexion ; la plage spécifiée est continue ; dans souvent nécessaire Créer un index sur la colonne triée, car l'index a été trié, afin que la requête puisse utiliser le tri de l'index pour accélérer le temps de requête de tri ; souvent utilisé dans la clause WHERE pour accélérer le jugement des conditions.

De même, les index ne doivent pas être créés pour certaines colonnes. De manière générale, ces colonnes qui ne doivent pas être indexées présentent les caractéristiques suivantes :

Premièrement, les index ne doivent pas être créés pour des colonnes rarement utilisées ou référencées dans les requêtes. En effet, ces colonnes étant rarement utilisées, l’indexation ou non n’améliore pas la vitesse des requêtes. Au contraire, du fait de l’ajout d’index, la vitesse de maintenance du système est réduite et les besoins en espace sont augmentés.

Deuxièmement, les index ne doivent pas être ajoutés aux colonnes avec peu de valeurs de données. En effet, comme ces colonnes ont très peu de valeurs, comme la colonne sexe de la table personnel, dans les résultats de la requête, les lignes de données du jeu de résultats représentent une grande proportion des lignes de données de la table, c'est-à-dire : les données qui doivent être recherchées dans le tableau La proportion de lignes est énorme. L'augmentation de l'index n'accélère pas significativement la récupération.

Troisièmement, les index ne doivent pas être ajoutés aux colonnes définies comme types de données texte, image et bits. En effet, le volume de données de ces colonnes est soit assez important, soit très peu de valeurs.

Quatrièmement, lorsque les performances de modification sont bien supérieures aux performances de récupération, l'index ne doit pas être créé. En effet, les performances de modification et les performances de récupération sont contradictoires. Lors de l'ajout d'index, les performances de récupération seront améliorées, mais les performances de modification seront réduites. Lors de la réduction des index, les performances de modification augmenteront et les performances de récupération diminueront. Par conséquent, lorsque les performances de modification sont bien supérieures aux performances de récupération, les index ne doivent pas être créés.

En fonction des fonctions de la base de données, trois types d'index peuvent être créés dans le concepteur de base de données : index unique, index de clé primaire et index clusterisé.

Index unique

Un index unique est un index qui ne permet pas à deux lignes d'avoir la même valeur d'index.

La plupart des bases de données ne permettent pas d'enregistrer les index uniques nouvellement créés avec la table lorsqu'il y a des valeurs de clé en double dans les données existantes. La base de données peut également empêcher l'ajout de nouvelles données qui créeraient des valeurs de clé en double dans le tableau. Par exemple, si un index unique est créé sur le nom de famille de l'employé (lname) dans la table des employés, deux employés ne peuvent pas avoir le même nom de famille. Les tables de la base de données d'index de clé primaire comportent souvent une colonne ou une combinaison de colonnes dont les valeurs identifient de manière unique chaque ligne de la table. Cette colonne est appelée clé primaire de la table. La définition d'une clé primaire pour une table dans un diagramme de base de données crée automatiquement un index de clé primaire, qui est un type spécifique d'index unique. L'index exige que chaque valeur de la clé primaire soit unique. Il permet également un accès rapide aux données lorsqu'un index de clé primaire est utilisé dans les requêtes. Index clusterisé Dans un index clusterisé, l'ordre physique des lignes de la table est le même que l'ordre logique (index) des valeurs clés. Une table ne peut contenir qu'un seul index clusterisé.

Si un index n'est pas un index clusterisé, l'ordre physique des lignes du tableau ne correspond pas à l'ordre logique des valeurs clés. Les index clusterisés offrent généralement un accès aux données plus rapide que les index non clusterisés.

Principe de localité et lecture anticipée du disque

En raison des caractéristiques du support de stockage, le disque lui-même accède est plus lente que le disque principal. Le stockage est beaucoup plus lent. Associé au coût du mouvement mécanique, la vitesse d'accès du disque est souvent un centième de celle de la mémoire principale. Par conséquent, afin d'améliorer l'efficacité, les E/S du disque doivent être minimisées. . Afin d'atteindre cet objectif, le disque ne lit souvent pas strictement à la demande, mais lit à l'avance à chaque fois. Même si un seul octet est nécessaire, le disque démarre à partir de cette position et lit séquentiellement une certaine longueur de données vers l'arrière. mémoire. La base théorique en est le principe de localité bien connu en informatique : lorsqu’une donnée est utilisée, les données proches sont généralement utilisées immédiatement. Les données requises lors de l'exécution du programme sont généralement concentrées.

Étant donné que les lectures séquentielles sur disque sont très efficaces (pas de temps de recherche, très peu de temps de rotation), la lecture anticipée peut être utilisée pour les programmes avec une localité qui améliore l'efficacité des E/S.

La longueur de prélecture est généralement un multiple entier de la page. Les pages sont des blocs logiques de mémoire gérée par l'ordinateur. Le matériel et les systèmes d'exploitation divisent souvent les zones de mémoire principale et de stockage sur disque en blocs consécutifs de taille égale. Chaque bloc de stockage est appelé une page (dans de nombreux systèmes d'exploitation, la taille de la page est généralement de 4 Ko). la mémoire principale et le disque échangent des données en unités de pages. Lorsque les données à lire par le programme ne sont pas dans la mémoire principale, une exception de défaut de page sera déclenchée. À ce moment, le système enverra un signal de lecture au disque et le disque trouvera la position de départ des données. et lisez une ou plusieurs pages à l'envers. Chargez-les en mémoire, puis revenez anormalement et le programme continue de s'exécuter.

Analyse des performances de l'indice B-/+Tree

Ici, nous pouvons enfin analyser le B-/+Tree performances de l’indice.

Comme mentionné ci-dessus, le nombre d'E/S disque est généralement utilisé pour évaluer la qualité de la structure de l'index. Commençons par l’analyse B-Tree. Selon la définition de B-Tree, on peut voir qu’un maximum de h nœuds doivent être visités pour une récupération. Les concepteurs du système de base de données ont intelligemment tiré parti du principe de lecture anticipée du disque et ont fixé la taille d'un nœud à une page, afin que chaque nœud puisse être entièrement chargé avec une seule E/S. Afin d'atteindre cet objectif, les techniques suivantes doivent être utilisées dans la mise en œuvre réelle de B-Tree :

Chaque fois qu'un nouveau nœud est créé, une page d'espace est directement appliquée car, garantissant ainsi qu'un nœud est physiquement stocké dans une page et que l'allocation de stockage informatique est alignée sur la page, un nœud n'a donc besoin que d'une seule E/S.

Une récupération dans B-Tree nécessite au plus h-1 E/S (mémoire résidente du nœud racine), et la complexité asymptotique est O(h)=O(logdN). Dans les applications pratiques générales, le degré sortant d est un très grand nombre, généralement supérieur à 100, donc h est très petit (généralement pas plus de 3).

Pour les structures comme les arbres rouge-noir, h est évidemment beaucoup plus profond. Puisque les nœuds logiquement proches (parents et enfants) peuvent être physiquement éloignés, la localité ne peut pas être exploitée, donc la complexité asymptotique d'E/S de l'arbre rouge-noir est également O(h), et l'efficacité est évidemment bien pire que celle de le B-Tree.

En résumé, utiliser B-Tree comme structure d'index est très efficace.

6. Type de connexion

Exécuter dans l'analyseur de requêtes :
--Créez des tables table1, table2 :

create table table1(id int,name varchar(10))
create table table2(id int,score int)
insert into table1 select 1,'lee'
insert into table1 select 2,'zhang'
insert into table1 select 4,'wang'
insert into table2 select 1,90
insert into table2 select 2,100
insert into table2 select 3,70

Par exemple, la table

-------------------------------------------------
table1 | table2 |
-------------------------------------------------
id name |id score |
1 lee |1 90|
2 zhang| 2 100|
4 wang| 3 70|
-------------------------------------------------

Les éléments suivants sont tous dans l'analyse des requêtes Exécuté dans le processeur
1. Jointure externe
1. Concept : y compris la jointure externe gauche, la jointure externe droite ou la jointure externe complète

2.左连接：left join 或 left outer join

　　(1)左向外联接的结果集包括 LEFT OUTER 子句中指定的左表的所有行，而不仅仅是联接列所匹配的行。如果左表的某行在右表中没有匹配行，则在相关联的结果集行中右表的所有选择列表列均为空值(null)。
　　(2)sql 语句

select * from table1 left join table2 on table1.id=table2.id

-------------结果-------------
idnameidscore
------------------------------
1lee190
2zhang2100
4wangNULLNULL
------------------------------

注释：包含table1的所有子句，根据指定条件返回table2相应的字段，不符合的以null显示

3.右连接：right join 或 right outer join

　　(1)右向外联接是左向外联接的反向联接。将返回右表的所有行。如果右表的某行在左表中没有匹配行，则将为左表返回空值。

　　(2)sql 语句

select * from table1 right join table2 on table1.id=table2.id

-------------结果-------------
idnameidscore
------------------------------
1lee190
2zhang2100
NULLNULL370
------------------------------

注释：包含table2的所有子句，根据指定条件返回table1相应的字段，不符合的以null显示

4.完整外部联接:full join 或 full outer join

　　(1)完整外部联接返回左表和右表中的所有行。当某行在另一个表中没有匹配行时，则另一个表的选择列表列包含空值。如果表之间有匹配行，则整个结果集行包含基表的数据值。

　　(2)sql 语句

select * from table1 full join table2 on table1.id=table2.id

-------------结果-------------
idnameidscore
------------------------------
1lee190
2zhang2100
4wangNULLNULL
NULLNULL370
------------------------------

注释：返回左右连接的和（见上左、右连接）

二、内连接

　　1.概念：内联接是用比较运算符比较要联接列的值的联接

　　2.内连接：join 或 inner join

　　3.sql 语句

select * from table1 join table2 on table1.id=table2.id

-------------结果-------------
idnameidscore
------------------------------
1lee190
2zhang2100
------------------------------

注释：只返回符合条件的table1和table2的列

　　4.等价（与下列执行效果相同）

　　A:select a.*,b.* from table1 a,table2 b where a.id=b.id

　　B:select * from table1 cross join table2 where table1.id=table2.id (注：cross join后加条件只能用where,不能用on)

三、交叉连接(完全)

　　1.概念：没有 WHERE 子句的交叉联接将产生联接所涉及的表的笛卡尔积。第一个表的行数乘以第二个表的行数等于笛卡尔积结果集的大小。（table1和table2交叉连接产生3*3=9条记录）

　　2.交叉连接：cross join (不带条件where...)

　　3.sql语句

select * from table1 cross join table2

-------------结果-------------
idnameidscore
------------------------------
1lee190
2zhang190
4wang190
1lee2100
2zhang2100
4wang2100
1lee370
2zhang370
4wang370
------------------------------

注释：返回3*3=9条记录，即笛卡尔积

　　4.等价（与下列执行效果相同）

　　A:select * from table1,table2

7、数据库范式

　　1） 第一范式（1NF）

　　在任何一个关系数据库中，第一范式（1NF）是对关系模式的基本要求，不满足第一范式（1NF）的数据库就不是关系数据库。
所谓第一范式（1NF）是指数据库表的每一列都是不可分割的基本数据项，同一列中不能有多个值，即实体中的某个属性不能有多个值或者不能有重复的属性。如果出现重复的属性，就可能需要定义一个新的实体，新的实体由重复的属性构成，新实体与原实体之间为一对多关系。在第一范式（1NF）中表的每一行只包含一个实例的信息。简而言之，第一范式就是无重复的列。

　　2 ）第二范式（2NF）

　　第二范式（2NF）是在第一范式（1NF）的基础上建立起来的，即满足第二范式（2NF）必须先满足第一范式（1NF）。第二范式（2NF）要求数据库表中的每个实例或行必须可以被惟一地区分。为实现区分通常需要为表加上一个列，以存储各个实例的惟一标识。这个惟一属性列被称为主关键字或主键、主码。

　　第二范式（2NF）要求实体的属性完全依赖于主关键字。所谓完全依赖是指不能存在仅依赖主关键字一部分的属性，如果存在，那么这个属性和主关键字的这一部分应该分离出来形成一个新的实体，新实体与原实体之间是一对多的关系。为实现区分通常需要为表加上一个列，以存储各个实例的惟一标识。简而言之，第二范式就是非主属性非部分依赖于主关键字。

　　3 ）第三范式（3NF）

　　满足第三范式（3NF）必须先满足第二范式（2NF）。简而言之，第三范式（3NF）要求一个数据库表中不包含已在其它表中已包含的非主关键字信息。例如，存在一个部门信息表，其中每个部门有部门编号（dept_id）、部门名称、部门简介等信息。那么在员工信息表中列出部门编号后就不能再将部门名称、部门简介等与部门有关的信息再加入员工信息表中。如果不存在部门信息表，则根据第三范式（3NF）也应该构建它，否则就会有大量的数据冗余。简而言之，第三范式就是属性不依赖于其它非主属性。（我的理解是消除冗余）

 8、数据库优化的思路

　　这个我借鉴了慕课上关于数据库优化的课程。

一、SQL语句优化

　　1）应尽量避免在 where 子句中使用!=或操作符，否则将引擎放弃使用索引而进行全表扫描。

　　2）应尽量避免在 where 子句中对字段进行 null 值判断，否则将导致引擎放弃使用索引而进行全表扫描，如：

select id from t where num is null

　　可以在num上设置默认值0，确保表中num列没有null值，然后这样查询：

select id from t where num=0

　　3）很多时候用 exists 代替 in 是一个好的选择

　　4）用Where子句替换HAVING 子句 因为HAVING 只会在检索出所有记录之后才对结果集进行过滤

二、索引优化

　　看上文索引

三、数据库结构优化

　　1）范式优化： 比如消除冗余（节省空间。。）

　　 2）反范式优化：比如适当加冗余等（减少join）

　　 3）拆分表： 分区将数据在物理上分隔开，不同分区的数据可以制定保存在处于不同磁盘上的数据文件里。这样，当对这个表进行查询时，只需要在表分区中进行扫描，而不必进行全表扫描，明显缩短了查询时间，另外处于不同磁盘的分区也将对这个表的数据传输分散在不同的磁盘I/O，一个精心设置的分区可以将数据传输对磁盘I/O竞争均匀地分散开。对数据量大的时时表可采取此方法。可按月自动建表分区。
　　4）拆分其实又分垂直拆分和水平拆分： 案例： 简单购物系统暂设涉及如下表： 1.产品表（数据量10w，稳定） 2.订单表（数据量200w，且有增长趋势） 3.用户表 （数据量100w，且有增长趋势） 以mysql为例讲述下水平拆分和垂直拆分，mysql能容忍的数量级在百万静态数据可以到千万 垂直拆分：解决问题：表与表之间的io竞争 不解决问题：单表中数据量增长出现的压力 方案： 把产品表和用户表放到一个server上 订单表单独放到一个server上 水平拆分： 解决问题：单表中数据量增长出现的压力 不解决问题：表与表之间的io争夺

　　方案： 用户表通过性别拆分为男用户表和女用户表 订单表通过已完成和完成中拆分为已完成订单和未完成订单 产品表 未完成订单放一个server上 已完成订单表盒男用户表放一个server上 女用户表放一个server上(女的爱购物 哈哈)

四、服务器硬件优化

　　这个么多花钱咯！

9、存储过程与触发器的区别

Les déclencheurs sont très similaires aux procédures stockées. Les déclencheurs sont également des ensembles d'instructions SQL. La seule différence entre les deux est que les déclencheurs ne peuvent pas être appelés avec des instructions EXECUTE, mais sont automatiquement déclenchés (activés) lorsque l'utilisateur exécute une opération. Instruction Transact-SQL implémentée. Un déclencheur est une procédure stockée exécutée lorsque les données d'une table spécifiée sont modifiées. Les déclencheurs sont souvent créés pour garantir l'intégrité référentielle et la cohérence des données logiquement liées dans différentes tables. Étant donné que les utilisateurs ne peuvent pas contourner les déclencheurs, ils peuvent être utilisés pour appliquer des règles métier complexes afin de garantir l'intégrité des données. Les déclencheurs sont différents des procédures stockées. Les déclencheurs sont principalement exécutés via des déclencheurs d'exécution d'événements, tandis que les procédures stockées peuvent être appelées directement via le nom de la procédure stockée. Lorsque des opérations telles que UPDATE, INSERT et DELETE sont effectuées sur une certaine table, SQLSERVER exécutera automatiquement les instructions SQL définies par le déclencheur, garantissant ainsi que le traitement des données doit être conforme aux règles définies par ces instructions SQL.

Adresse originale : https://www.cnblogs.com/frankielf0921/p/5930743.html

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!