Quelle est l’utilité des requêtes dans une base de données ?

SQL est incroyablement puissant et comme toutoutil de développement bien fait , il a quelques commandes que tout bon développeur devrait connaître. Voici quelques-unes des commandes les plus importantes : chacune de ces requêtes est requise pour pratiquement n’importe quel système qui fonctionne avec une base de données SQL.

MAX

1. Requête pour lire des tables

Cette requête peut être exécutée pour produire une liste des tables dans une base de données où la base de données est My_Schema.

A lire également : Les logiciels gratuits pour éditer des images sur ordinateur : notre sélection des meilleurs outils

SÉLECTIONNER* À PARTIR DE MY_SCHÉMA.TABLES ;

2. Requête pour Sélectionner les colonnes d’une table

C’ est peut-être la requête SQL la plus largement utilisée. Dans l’exemple ci-dessous, nous extrayons la colonne « Student_ID » ou les attributs de la table Student.

A voir aussi : Optimisez la gestion de vos fichiers et dossiers sur votre ordinateur pour une efficacité maximale

SÉLECTIONNER STUDENT_ID À PARTIR DE L’ÉTUDIANT Si vous voulez afficher tous les attributs d’une table particulière, alors c’est la bonne requête :

SÉLECTIONNEZ* DE L’ÉTUDIANT ;

3. Requête pour produire des données à l’aide d’une contrainte

Cette requête renvoie certains attributs d’une table sur la contrainte Employé ID =0000.

SÉLECTIONNEZ EMP_ID, NOM DE EMPLOYEE_TBL OÙ EMP_ID = ‘0000’ ;

4. Requête pour sortir des données triées à l’aide de « Order By »

Cette requête trie les résultats en fonction des attributs spécifiés par « Order By » . Ainsi, si l’attribut a un type de données entier, les résultats sont affichés dans l’ordre croissant ou décroissant. Si le type de données est une chaîne, les résultats sont affichés par ordre alphabétique.

SÉLECTIONNER EMP_ID, LAST_NAME DE L’EMPLOYÉ OÙ VILLE = ‘Seattle’ COMMANDER PAR EMP_ID L’ ordre du résultat peut également être contrôlé manuellement en utilisant « asc » pour ascendant et « desc » pour descendre.

SÉLECTIONNEZ EMP_ID, LAST_NAME DANS EMPLOYEE_TBL OÙ VILLE = ‘INDIANAPOLIS’ ORDRE PAR EMP_ID asc ;

5. Requête pour sortir des données triées à l’aide de « Grouper par »

La fonction « Grouper par « regroupe les données de sortie à l’aide d’un attribut spécifié.

SELECT Nom, Âge DES Patients OÙ Âge >

40 REGROUPER PAR Âge Ordre par nom Requêtes pour manipuler des données à l’aide de fonctions mathématiques

Il y a beaucoup de fonctions mathématiques intégrées, telles que COUNT et AVG, qui fournissent des fonctionnalités de base pour compter le nombre de résultats et les moyennes. calculer.

6. Manipulation de données à l’aide de COUNT

Cette requête affiche le nombre complet de clients en comptant chaque ID client individuel. En outre, il regroupe les résultats par pays de chaque client.

SELECT COUNT (CustomerID), Pays FROM Clients GROUP BY Pays ;

7. Manipulation de données en utilisant

SUM calcule la somme des attributs contenus dans chaque argument.

Sélectionnez SUM (salaire) DE L’employé OÙ Emp_Age <

30 ;

8. Manipulation de données avec AVG

C’ est simple — la moyenne de l’attribut mentionné.

SELECT AVG (Prix) FROM Produits ;

9. Requête pour répertorier toutes les vues

Cette requête répertorie toutes les vues incluses dans ce schéma.

SÉLECTIONNEZ* À PARTIR DE MY_SCHEMA.VIEWS ;

10. Requête pour créer une vue

Une vue (=vue) est une table personnalisée créée par les résultats une requête a été générée. Il a des tables et des lignes comme presque n’importe quelle autre table. C’est généralement une bonne idée d’exécuter des requêtes en tant que vues indépendantes car il permet de les appeler plus tard pour voir les résultats d’une requête. L’alternative serait d’avoir à exécuter la même requête encore et encore pour une quantité particulière de sortie.

CRÉER LA VUE Failing_Students EN TANT SÉLECTIONNEZ S_NAME, STUDENT_ID DE L’ÉTUDIANT OÙ GPA >

40

11. requête pour lire une vue

La syntaxe par défaut pour sélectionner les attributs d’une table peut également être appliquée à une vue.

SÉLECTIONNER* DE failing_students ;

12. Requête pour mettre à jour une vue

Cette requête met à jour la vue nommée « Liste des produits ». Si cette vue n’existe pas, la vue Liste des produits est générée de la même manière que celle spécifiée dans la requête a été.

CRÉER OU REMPLACER LA VUE SELECT ProductID, ProductName, Catégorie FROM Produits OÙ interrompu = Non ;

13. Requête pour supprimer une vue

Cette requête supprime la vue nommée « V1″.

DROP VIEW V1

14. Requête pour les utilisateurs pour afficher les tables

Une table utilisateur est la représentation des informations définies dans une table. Il peut être utilisé comme argument d’un processus ou comme fonction utilisateur. Parce qu’ils sont si utiles, c’est une bonne idée de les garder à l’œil en utilisant la requête suivante.

SELECT * FROM SYS.Objects WHERE type=’u’

15. Requête pour afficher les clés primaires

Une clé primaire identifie toutes les valeurs uniques d’une table. La requête suivante répertorie tous les champs marqués comme clés primaires .

SELECT * à partir de Sys.Objects WHERE TYPE=’PK’

16. Requête pour afficher des clés uniques

Une clé unique permet à une colonne de s’assurer que toutes ses valeurs sont uniques.

SELECT * FROM Sys.Objects WHERE TYPE=’UQ’

17. Afficher les clés étrangères

clés étrangères joignent Les les tables. Ce sont les attributs d’une table qui font référence à la clé primaire d’une autre table.

SELECT * FROM SYS.Objects WHERE TYPE=’F’

18. Afficher les déclencheurs

Un déclencheur est quelque chose d’un « chien de surveillance des événements » — il s’agit donc d’un bloc d’instructions prédéterminé qui sont exécutées lorsqu’un événement particulier se produit. La liste des déclencheurs définis peut être affichée en appliquant la requête suivante.

SELECT * FROM SYS.Objects WHERE TYPE=’TR’

19. Tables internes

Lestables internes sont générées en tant que module complémentaire auxactions de l’utilisateurmontrer et ne sont généralement pas accessibles. Les données des tables internes ne peuvent pas être manipulées. Cependant, les métadonnées des tables internes peuvent être affichées à l’aide de la requête suivante.

SELECT * FROM SYS.Objects WHERE TYPE=’IT’

20. Afficher une liste de processus

Un processus stocké est un ensemble de requêtes SQL qui forment une seule unité logique et effectuent une tâche spécifique. Vous pouvez garder un œil sur eux en les interrogeant :

SELECT * FROM Sys.Objects WHERE type=’p’ .. et VINGT requêtes SQL plus avancées !

21. Échangez les valeurs de deux colonnes d’une table

Dans cet exemple et d’autres, nous utiliserons une base de données commune d’entreprise, y compris des tables qui sont très faciles sont construits. Notre base de données pratiques comprendra une table client (=Client) et une table de commande (=Commande). La table client contiendra des colonnes évidentes telles que ID, nom, adresse, code postal (=zip), e-mail et autres. Supposons maintenant que la clé primaire pour l’indexation est le champ Customer_ID.

Tout en gardant cela à l’esprit, nous pouvons facilement imaginer une table de commande qui a également le champ Customer_ID indexé et plus d’informations sur chaque commande passée par le client. Cette table inclura les champs numéro (=nombre), Quantité (=Quantité), Date (=Date), Article et Prix (=Prix). Dans notre premier exemple SQL, imaginez que tous les champs de téléphone et zip ont été échangés et que tous les numéros de téléphone ont été incorrectement saisis dans le champ zip. En utilisant la commande SQL suivante, nous pouvons facilement résoudre ce problème :

MISE À JOUR Clients SET Zip=Téléphone, Téléphone=Zip

22. Lecture d’une colonne de valeurs uniques

Imaginez maintenant que notre collecteur de données a saisi les mêmes données client plusieurs fois dans la même table client. Comme vous le savez, une indexation appropriée ne peut se produire que si les champs clés ont des valeurs uniques. Pour résoudre ce problème, nous allons utiliser la commande SELECT DISTINCT pour générer une liste indexable de clients uniques :

SÉLECTIONNER UN IDENTIFIANT DISTINCT DES CLIENTS

23. Créer un Top 25 avec la clause SELECT TOP

Ensuite, imaginez que notre table client a augmenté de plusieurs milliers d’entrées. Cependant, nous ne voulons regarder que 25 de ces postes pour montrer les en-têtes des colonnes. La clause SELECT TOP nous permet de générer un certain nombre d’entrées, comme la liste des 25 premiers. Dans cet exemple, nous verrons les 25 premiers de la table Clients sortie :

SÉLECTIONNEZ LES 25 MEILLEURS CLIENTS OÙ CUSTOMER_ID

NULL

24. Recherche de tables SQL à l’aide de caractères génériques

caractères génériques ou les opérateurs comme « % » facilitent la recherche de chaînes spécifiques dans une grande table de milliers d’entrées. Supposons que nous voulions trouver tous les clients dont le nom commence par « Herb », tels que Herberts et Herbertson. Lesymbole%Wildcard peut être utilisé pour obtenir un tel résultat de recherche. La commande SQL suivante affiche toutes les lignes de la table client où le champ nom_client Les commence par « Herb » :

SELECTE* A partir des clients OÙ Nom AIME ‘Herb%’

25. Entre le lundi et le mardi

Aujourd’hui c’est mercredi, nous arrivons au travail et notons que notre nouvel employé de maintenance a incorrectement saisi toutes les commandes pour le lundi et le mardi. Nous voulons enseigner à notre nouvel apprenti peut trouver et corriger toutes les entrées erronées. Quel est le moyen le plus simple d’afficher toutes les entrées de table de commandes entrées lundi et mardi ? La clause BETHER rend quelque chose comme ça très facile :

SÉLECTIONNEZ ID DANS LES COMMANDES OÙ DATE ENTRE ’01/12/2018′ ET ’01/13/2018′

26. Trouver l’intersection entre deux tables

Sans aucun doute, la raison pour laquelle les bases de données relationnelles existent est que vous pouvez trouver des entrées correspondantes dans deux tables ! La commande JOIN permet cette fonctionnalité de base de SQL et facilite cette tâche. Ici, nous obtenons une liste de toutes les entrées qui s’appliquent à la fois aux tables client et commande :

SÉLECTIONNER ID À PARTIR DES CLIENTS INTERNES JOIGNEZ les commandes ON Customers.id = orders.id

Dans ce cas, la motivation derrière INNER JOIN est de sélectionner toutes les entrées de la table client qui ont des valeurs d’ID client correspondantes dans la table commandes. et ne jouer que ceux-ci. Bien sûr, il existe de nombreux types de JOIN, par exemple, FULL, SELF et LEFT. Mais laissons cela simple pour commencer et regardons des requêtes de plus en plus diverses.

27. Doublez les forces avec l’aide d’UNION

Nous pouvons naturellement combiner les résultats de deux requêtes SQL en une en utilisant le mot-clé UNION. Supposons que nous voulons créer une nouvelle table qui combine « customer_name » et « phone » de la table client avec une liste des commandes récentes de ce client afin que nous puissions identifier les modèles et anticiper les achats futurs. Voici un moyen rapide d’effectuer cette tâche :

SÉLECTIONNER un téléphone parmi les clients UNION SELECT article des commandes

Le mot-clé UNION permet de combiner JOINTS et d’autres critères pour obtenir un potentiel très puissant de génération de table.

28. Colonnes Rendre les étiquettes plus lisibles

Asgner des pseudonymes sur les étiquettes de colonne nous permet de renommer les étiquettes de colonne en quelque chose de plus facile à lire. Il y a un compromis lors de l’attribution de noms de colonnes pour les rendre courtes et concises. Cela se traduit souvent par une lisibilité réduite dans l’utilisation quotidienne. Dans notre tableau de commande, la colonne article contient la description des produits achetés. Voyons comment nous pouvons temporairement renommer la colonne Item pour qu’il soit facile pour l’utilisateur de lire :

SELECT Item AS item_description FROM Commandes

29. Toujours et partout !

Ne serait-ce pas génial s’il y avait un ensemble de conditions sur lesquelles vous pouvez toujours compter ? Les commandes SQL qui utilisent ANY et ALL peuvent faire de ce rêve une réalité ! Jetons un coup d’oeil à la façon dont le mot-clé ALL est utilisé pour obtenir des entrées avec si le jeu de conditions s’applique à TOUTES les entrées. Dans l’exemple ci-dessous, nous allons sortir des entrées de la table d’ordre, où l’idée est d’obtenir une liste d’un grand volume d’ordres pour une certaine position. Dans ce cas, pour les clients qui ont commandé plus de 50 de ce produit.

SELECT Article FROM Commandes OÙ id = TOUS (SELECT ID FROM Commandes OÙ quantité >

50)

30. Écriture SQL convivial pour les développeurs

— one-liner et le /* .. */ LesUn élément souvent négligé, mais toujours très important du script SQL est d’ajouter des commentaires à un script de requête qui explique ce que fait la requête. Cela facilitera les futurs développeurs qui souhaitent réviser et mettre à jour les anciennes requêtes. Le délimiteurs multilignes nous permettent d’ajouter des commentaires utiles à notre script. Cette peut être atteint d’une autre manière très précieuse. Parfois, une partie du code n’est pas utilisée. Nous ne voulons pas le supprimer, car nous pourrions en avoir besoin à nouveau. Ici, nous pouvons simplement ajouter un délimiteur de commentaire pour désactiver le code pour le moment :

/*La requête du bas ne s’exécute pas car elle est annotée*/ /* SELECT article FROM Commandes WHERE DATE ALL = (SÉLECTIONNER ORDER_ID À PARTIR DES COMMANDES OÙ quantité > 50) */ /* la requête sql est exécutée le texte après « — » est ignoré */ SELECT item — commentaire unique FROM Orders — Un autre commentaire Où id ALL = (SELECT ID FROM Orders OÙ quantité >

25)

31. instructions SQL pour la gestion de base de données

Jusqu’ à présent, nous avons exploré les commandes de requête SQL pour interroger les tables et combiner des entrées de plusieurs requêtes. Maintenant, il est temps d’aller plus loin et de mettre à jour la base de données sur un niveau structurel. Commençons par la commande SQL la plus simple jamais, qui est celle qui crée une nouvelle base de données. Ici, nous allons utiliser une nouvelle base de données comme conteneur pour notre table client et commande, que nous avons déjà découvert dans nos dix derniers exemples :

CRÉER UNE BASE DE DONNÉES ALLSales

32. Ajouter de nouvelles tables à notre nouvelle base de données

Ensuite, nous ajouterons la table Clients que nous avons utilisée dans nos exemples précédents, en ajoutant les noms de colonnes que nous avons déjà connus :

CREATE TABLE Clients ( ID varchar (80), nom varchar (80), Téléphone varchar (20), … ) ;

Bien que la plupart des bases de données soient créées à l’aide de programmes tels que Access ou OpenOffice, il est important de savoir comment créer et supprimer des bases de données et des tables au niveau du code à l’aide de commandes SQL. Cela est particulièrement vrai lorsque vous utilisez de nouvelles applications Web installé et l’interface utilisateur demande aux nouveaux utilisateurs d’entrer les noms des bases de données à ajouter lors de l’installation.

33. Modification et suppression de tables à l’aide de SQL

Imaginez envoyer une carte d’anniversaire à vos clients pour exprimer votre gratitude pour avoir fait affaire avec eux. Vous souhaitez donc ajouter un champ d’anniversaire à votre table client. SQL facilite la modification des tables existantes avec AGE :

ALTER TABLE CLIENTS AJOUTER Anniversaire varchar (80) Si une table a été endommagée par des données incorrectes, vous pouvez facilement la supprimer en procédant comme suit :

DROP TABLE nom_table

34. La clé d’une indexation réussie

L’ indexation précise exige que la colonne de clé primaire ne contienne que des valeurs uniques, pour cette raison même. Cela garantit que les commandes JOIN étaient l’intégrité et la sortie des résultats valides. Créons à nouveau notre table client et définissons la colonne ID comme clé primaire :

CREATE TABLE Clients ( ID int PAS NULL Nom varchar (80) PAS NULL CLÉ PRIMAIRE (ID) ) ; Nous pouvons étendre la fonctionnalité de la clé primaire afin qu’elle s’engage automatiquement à partir d’une base. Modifiez l’entrée d’ID ci-dessus pour ajouter le mot-clé AUTO_INCREMENT comme dans la commande suivante :

ID int PAS NULL AUTO_INCREMENT

35. Concepts avancés pour améliorer les performances

Bien que cela puisse sembler pratique, il est préférable de placer les noms de colonne dans une commande SELECT que d’utiliser le séparateur* comme caractère générique et de sélectionner toutes les colonnes. SQL Server doit effectuer une recherche pour trouver toutes les colonnes de votre table et les écrire dans une commande pour vous (pour chaque fois que la commande SELECT est exécutée). Par exemple :

SELECT * PARMI LES Clients serait en fait exécutez dans notre base de données beaucoup plus rapidement si vous le mettez comme ceci :

SELECT Nom, Anniversaire, Téléphone, Adresse, Zip FROM Clients

Les discontinuités de performance peuvent être contournées de différentes manières. Par exemple, ne perdez pas de temps à forcer SQL Server à vérifier la base de données System/Master à chaque fois en utilisant uniquement les noms de processus stockés et ne définissez jamais le préfixe SP_. L’utilisation de NOCOUNT ON réduit également le temps nécessaire à SQL Server pour compter les lignes affectées par INSERT, DELETE et d’autres commandes. L’utilisation d’INNER JOIN avec une condition est beaucoup plus rapide que les clauses WHERE associées à une condition. Nous encourageons les développeurs à porter leur connaissance des requêtes SQL Server à un niveau avancé pour cette raison. Pour des raisons de production, ces conseils peuvent être essentiels pour des performances adéquates. Au cas où vous ne l’auriez pas encore remarqué, nos exemples favorisent INNER JOIN.

36. Résultats des sous-requêtes conditionnelles

L’ opérateur SQL EXISTS vérifie l’existence d’entrées dans les sous-requêtes et renvoie TRUE si une sous-requête renvoie une ou plusieurs entrées. Jetez un oeil à cette requête avec une condition de sous-requête :

SÉLECTIONNER UN NOM À PARTIR DES CLIENTS OÙ EXISTE (SÉLECTIONNER l’article DANS les commandes WHERE Customers.id = orders.id et prix > 50)

Dans l’exemple ci-dessus, SELECT renvoie la valeur TRUE si les commandes d’un client sont inférieures à 50$.

37. Copier la table dans la sélection de table

Il existe d’innombrables utilisations pour cet outil SQL. Supposons que vous souhaitiez enregistrer la table de commande annuelle dans une grande table d’archive. L’exemple suivant vous montre comment cela fonctionne.

INSÉRER DANS Yearly_Orders SÉLECTIONNEZ* PARMI LES COMMANDES WHER<=1/1/2018

Cet exemple affichera toutes les entrées ajouter aux archives de l’année 2018

38. capturer des résultats zéro

Dans les cas où des valeurs NULL sont autorisées dans un champ, les calculs sur ces valeurs renvoient également NULL. Cela peut être évité en utilisant l’opérateur IFNULL. Cet exemple suivant montre une valeur de zéro, par opposition à une valeur NULL si le calcul rencontre un champ avec une valeur NULL :

SELECT Article, Prix * (qtyinstock IFNULL (QtyonOrder, 0)) FROM Commandes

39. AVOIR peut apporter du soulagement !

Le problème était que la clause SQL WHERE ne pouvait pas agir sur les fonctions fusionnées. Ce problème a été résolu par la clause AVING. Pour illustrer cela, cette prochaine requête affichera une liste de clients, regroupés par région, où au moins un client par région est stocké :

SELECT COUNT (ID) région FROM Clients GROUPE PAR Région AYANT COUNT (ID) >

0 ;

40. Fermez le sac avec des cordes !

Jetons un coup d’oeil à la façon de traiter le contenu des données de champ en utilisant des fonctions. Substring est probablement la plus précieuse de toutes ces fonctions intégrées. Elle vous donne presque toutes les possibilités de regex, mais n’est pas si compliqué pendant longtemps. Supposons que vous vouliez trouver la sous-chaîne à gauche des points dans une adresse Web. Voici comment le faire avec une commande SQL SELECT :

SÉLECTIONNEZ SUBSTRING_INDEX (« www.bytescout.com », ». « , 2) ; Cette ligne jouera tout vers la gauche après la deuxième occurrence de « . » Dans notre cas, ce serait :

www.bytescout.com

.. et 20 autres exemples de requêtes SQL utiles !

41. Utiliser COALESCE pour renvoyer une première expression non nulle

Le code SQL Coalesce est utilisé pour gérer les valeurs nulles de la base de données. Cette méthode utilise les valeurs null avec la méthode Remplacez une valeur personnalisée. La fonction SQL Coalesce évalue les paramètres en série et renvoie toujours la première valeur non nulle de l’enregistrement d’argument spécifié.

Syntaxe

SELECT COALESCE (NULL, NULL, ‘BytesCout’, NULL, ‘Byte’) sortie

BytesCout

42. Utilisez Convertir pour convertir n’importe quelle valeur en un type de données spécifique

Il est utilisé pour convertir une valeur en un type de données défini. Par exemple, si vous souhaitez convertir une certaine valeur en un type de données entier, vous pouvez utiliser la fonction « Convertir ».

Syntaxe

SÉLECTIONNER CONVERT (int, 27.64) sortie

27

43. La requête d’analyse DENSE_RANK ()

Il s’agit d’une requête analytique qui calcule le rang d’une ligne dans une collection arrangée de lignes. Une quantité en sortie est un nombre de 1. DENSE_RANK est l’une des requêtes SQL analytiques les plus importantes. Il spécifie les paramètres de rang comme nombres séquentiels. Dans le cas d’une relation, le rang n’augmente pas. Par exemple, la requête suivante donnera les rangs séquentiels à un employé.

SELECT eno dno Salaire, DENSE_RANK () SUR (PARTITION PAR ORDRE DNO PAR SALAIRE) EN TANT QUE CLASSEMENT DE L’EMPLOYÉ ; ENO DNO CLASSEMENT DES SALAIRES — — — 7933 10 1500 1 7788 10 2650 2 7831 10 6000 3 7362 20 900 1 7870 20 1200 2 7564 20 2575 3 7784 20 4000 4 7903 20 4000 4 7901 30 550 1 7655 30 1450 2 7522 30 1450 2 7844 30 1700 3 7493 30 1500 4 7698 30 2850 5

44. La clause query_partition

query_partition_clause divise le jeu de sortie en distributions ou en collections de données. Le développement de la requête analytique est limité par les limites imposées par les partitions liées au processus. Une clause GROUP BY modifie les performances d’un Fonction d’agrégation. Si la clause query_partition_clause est supprimée, toute la collection en sortie est interprétée comme une partition distincte.

La requête suivante utilise une clause OVER afin que la moyenne affichée soit basée sur les enregistrements du jeu de sortie.

SELECT eno, dno, salaire, AVG (salaire) PLUS () AS avg_sal DE L’EMPLOYÉ ; EO DNO SALAIRE AVG_SAL — — — 7364 20 900 2173.21428 7494 30 1700 2173.21428 7522 30 1350 2173.21428 7567 20 3075 2173.21428 7652 30 1350 2173.21428 7699 30 2950 2173.21428 7783 10 2550 2173.21428 7789 20 3100 2173.21428 7838 10 5100 2173.21428 7845 30 1600 2173.21428 7877 20 1200 2173.21428 7901 30 1050 2173.21428 7903 20 3100 2173.21428 7935 10 1400 2173.21428

45. Recherche des cinq derniers enregistrements d’une table

Maintenant, si vous voulez récupérer les huit derniers enregistrements d’une table, il est toujours difficile de récupérer ces données lorsque le tableau contient de nombreuses informations. Par exemple, si vous souhaitez récupérer les huit derniers enregistrements de la table Employé, vous pouvez utiliser « rownum » et une clause « Union ». Rownum est temporaire en SQL.

Par exemple,

Sélectionnez * dans Employé A où rownum