SQL est l'un des langages de programmation les plus courants pour créer et gérer une base de données, ainsi que pour effectuer diverses actions avec les données elles-mêmes.
Comme le montre la pratique, il est assez facile à apprendre et utilise au maximum le vocabulaire standard. En anglais. Comme tout autre langage de programmation, SQL possède sa propre logique et sa propre syntaxe, un ensemble de commandes de base et de règles pour leur utilisation.
Classification des commandes SQLTous les standards peuvent être considérés en fonction de leur objectif. Les ensembles suivants peuvent être pris comme base pour une classification informelle :
Commandes pour créer des requêtes.
Commandes de procédures et fonctions intégrées.
Commandes pour les déclencheurs et les tables système.
Ensembles de combinaisons pour travailler avec des variables de date et de chaîne.
Commandes pour travailler avec des données et des tables.
Cette classification peut être poursuivie indéfiniment, mais les principaux ensembles de commandes SQL seront construits précisément sur la base de ces types.
En ce qui concerne la classification du langage, on ne peut manquer de mentionner qu'il est universel, comme en témoigne l'étendue de son usage. Ce langage de programmation et ses variantes sont utilisés non seulement dans l'environnement standard, mais également dans d'autres programmes que vous avez utilisés d'une manière ou d'une autre.
Le champ d'utilisation de SQL peut être considéré du point de vue du bureau logiciel, à savoir MicrosoftAccess. Ce langage, ou plutôt sa version - MySQL, permet d'administrer des bases de données dans Réseaux Internet. Même l'environnement de développement Oracle utilise des commandes SQL au cœur de ses requêtes.
Utilisation de SQL dans MicrosoftAccessUn des plus exemples simples Le langage utilisé pour la programmation des bases de données est considéré comme le progiciel Microsoft Office. L'étude de ce produit logiciel est incluse dans le cours d'informatique de l'école et, en onzième année, le système de gestion de base de données MicrosoftAccess est abordé.
C’est en apprenant cette application que les étudiants se familiarisent avec le langage de développement de bases de données et acquièrent une compréhension de base de tout ce que cela implique. Les commandes Access SQL sont bien sûr assez primitives si vous les considérez à un niveau professionnel. L'exécution de telles commandes est très simple et elles sont créées dans un éditeur de code personnalisé.
Considérons exemple spécifique:
SELECT Pe_SurName
OÙ Pe_Name = "Marie" ;
Sur la base de la syntaxe de la commande, vous pouvez comprendre qu'elle renverra à l'utilisateur le nom de famille d'une personne, en l'occurrence une femme nommée Mary, qui est stockée dans la table de la base de données Contacts.
Bien que l'utilisation de SQL dans Access soit limitée, des requêtes aussi simples peuvent parfois grandement simplifier la tâche à accomplir.
Utilisation des commandes SQL dans OracleOracle est probablement le seul concurrent sérieux MicrosoftSQL Serveur. C'est cet environnement de développement et de gestion qui conduit constamment à l'amélioration des fonctionnalités du produit logiciel de Microsoft, puisque la concurrence est le moteur du progrès. Malgré une concurrence constante, les équipes SQL d'Oracle répliquent SQL. Il convient de noter que bien qu'Oracle soit considéré comme une copie presque complète de SQL, la logique de ce système et du langage dans son ensemble sont considérés comme plus simples.
Le système Oracle, lorsqu'il utilise un certain ensemble de commandes, n'a pas une structure aussi complexe. Compte tenu des capacités de ces environnements de développement de bases de données, Oracle ne dispose pas d'une structure de requêtes imbriquées complexe.
Cette différence permet d'accélérer plusieurs fois le travail avec les données, mais conduit au contraire à une utilisation irrationnelle de la mémoire, dans certains cas individuels. La structure d'Oracle repose principalement sur des tables temporaires et leur utilisation. A titre d'exemple : les commandes SQL de ce système sont construites par analogie avec les standards du langage SQL lui-même, bien qu'elles en diffèrent légèrement.
SELECTCONCAT(CONCAT(CONCAT('Employé', sname), CONCAT(SUBSTR(fname, 0, 1), SUBSTR(otch, 0, 1)), CONCAT('accepted', acceptdate)) FROM employés WHERE acceptdate > to_date ( '01.01.80′, 'jj.mm.aaaa');
Cette requête renverra des données sur les employés embauchés au cours d'une certaine période. Bien que la structure des requêtes soit différente, l'exécution des commandes SQL dans ces systèmes est similaire, à l'exception de détails mineurs.
Utiliser SQL sur InternetAvec l'avènement de World Wide Web, c'est-à-dire Internet, le champ d'utilisation du langage SQL s'élargit. Comme vous le savez, de nombreuses informations sont stockées sur le réseau, mais elles ne sont pas localisées au hasard, mais placées sur des sites et des serveurs selon certains critères.
Les bases de données sont directement responsables du stockage des informations sur Internet, comme ailleurs, et les sites Web sont des systèmes de gestion. En règle générale, les sites et leurs code de programme sont organisées en différents langages de programmation, mais les bases de données sont basées sur l'une des variétés de SQL, à savoir le langage de création de bases de données, orienté vers les interfaces web MySQL.
La syntaxe et l'ensemble de commandes de base de ce langage copient complètement le SQL familier, mais avec certains de ses propres ajouts, qui le différencient de Microsoft tSQL Server.
Les commandes SQL sont complètement similaires non seulement en termes de syntaxe, mais également en termes de ensemble standard mots de fonction. La seule différence réside dans l’appel et la structuration de la requête. Par exemple, vous pouvez considérer une demande de création d’un nouveau tableau ; c’est la première chose qu’on enseigne aux enfants dans les écoles d’informatique :
$link = mysqli_connect("localhost", "root", "", "testeur");
if (!$link) die("Erreur");
$query = "créer des utilisateurs de table (
connectez-vous VARCHAR (20),
mot de passe VARCHAR(20)
if (mysqli_query($link, $query)) echo "La table a été créée.";
elseecho "Table non créée : ".mysqli_error();
mysqli_close($lien);
À la suite de l'exécution d'une telle requête, vous pouvez obtenir une nouvelle table « Utilisateurs », qui comportera deux champs : login et mot de passe.
La syntaxe a été modifiée pour le Web, mais est basée sur les commandes MicrosoftSQLServer.
Création de requêtes MicrosoftSQLServerLa sélection à partir des tables d'un ensemble de données spécifique est l'une des tâches principales de SQL. La commande select en SQL est fournie pour de telles opérations. C’est ce qui sera discuté ci-dessous.
Les règles de construction d'une commande sont très simples et la commande select elle-même en SQL est construite comme suit. Par exemple, il existe une table qui contient des données sur un employé, qui porte par exemple le nom Personne. Définissons la tâche selon laquelle, dans le tableau, vous devez sélectionner des données sur les employés dont la date de naissance se situe dans l'intervalle du premier janvier au premier mars de l'année en cours inclus. Pour une telle sélection, vous devez exécuter une commande SQL, qui contiendra non seulement la construction standard, mais également la condition de sélection :
Sélectionnez * dans Personne
Où P_BerthDay >= '01/01/2016' et P_BerthDay= '01/01/2016' et P_BerthDay= @DB et P_BerthDay (SELECT avg(stock) FROM books)) GROUP BY Members.firstname, Members.lastname ;
Ouais ! Cela fera fuir tout débutant, ou même un développeur de niveau intermédiaire s'il voit SQL pour la première fois. Mais ce n’est pas si mal.
Il est facile de se souvenir de ce qui est intuitif, et avec ce guide, j'espère réduire la barrière à l'entrée dans SQL pour les débutants et offrir à ceux déjà expérimentés une nouvelle façon d'appréhender SQL.
Bien que la syntaxe SQL soit presque la même entre les différentes bases de données, cet article utilise PostgreSQL pour les requêtes. Certains exemples fonctionneront dans MySQL et d'autres bases de données.
1. Trois mots magiquesIl existe de nombreux mots-clés dans SQL, mais SELECT, FROM et WHERE sont présents dans presque toutes les requêtes. Un peu plus tard, vous comprendrez que ces trois mots représentent les aspects les plus fondamentaux de la construction de requêtes de base de données, et que d'autres requêtes plus complexes ne sont que des ajouts par-dessus.
2. Notre socleJetons un coup d'œil à la base de données que nous utiliserons comme exemple dans cet article :
Nous avons une bibliothèque de livres et des gens. Il existe également une table spéciale pour enregistrer les livres publiés.
- La table « livres » stocke des informations sur le titre, l'auteur, la date de publication et la disponibilité du livre. C'est simple.
- Dans le tableau « membres » - les noms et prénoms de toutes les personnes inscrites à la bibliothèque.
- Le tableau « emprunts » stocke les informations sur les livres empruntés à la bibliothèque. La colonne bookid fait référence à l'identifiant du livre pris dans la table « books », et la colonne memberid fait référence à la personne correspondante de la table « Members ». Nous avons également une date d'émission et une date à laquelle le livre doit être retourné.
Commençons avec simple demande: nous avons besoin des noms Et identifiants(id) de tous les livres écrits par l'auteur « Dan Brown »
La requête ressemblera à ceci :
SELECT bookid AS "id", titre FROM livres WHERE author="Dan Brown";
Et le résultat est comme ceci :
| 2 | Le symbole perdu |
| 4 | Enfer |
Assez facile. Examinons la demande pour comprendre ce qui se passe.
3.1 FROM - d'où nous obtenons les donnéesCela peut sembler évident maintenant, mais FROM sera très important plus tard lorsque nous aborderons les jointures et les sous-requêtes.
FROM pointe vers la table à interroger. Il peut s'agir d'une table existante (comme dans l'exemple ci-dessus) ou d'une table créée à la volée via des jointures ou des sous-requêtes.
3.2 OÙ – quelles données sont affichéesWHERE agit simplement comme un filtre pour les lignes que nous souhaitons afficher. Dans notre cas, nous souhaitons uniquement voir les lignes dont la valeur dans la colonne auteur est « Dan Brown ».
3.3 SELECT - comment afficher les donnéesMaintenant que nous disposons de toutes les colonnes dont nous avons besoin dans le tableau dont nous avons besoin, nous devons décider comment exactement afficher ces données. Dans notre cas, nous n’avons besoin que de titres de livres et d’identifiants, c’est donc ce que nous faisons. choisissons en utilisant SELECT. Dans le même temps, vous pouvez renommer la colonne en utilisant AS.
L'ensemble de la requête peut être visualisé à l'aide d'un simple diagramme :
Nous voulons maintenant voir les titres (pas nécessairement uniques) de tous les livres de Dan Brown qui ont été extraits de la bibliothèque, et quand ces livres doivent être restitués :
SELECT books.title AS "Titre", Borings.returndate AS "Date de retour" FROM emprunts JOIN books ON Borings.bookid=books.bookid OÙ books.author="Dan Brown";
Résultat:
| Le symbole perdu | 2016-03-23 00:00:00 |
| Enfer | 2016-04-13 00:00:00 |
| Le symbole perdu | 2016-04-19 00:00:00 |
La demande est pour l’essentiel similaire à la précédente à l'exception de DE sections. Cela signifie que nous interrogeons les données d'une autre table. Nous n’accédons ni au tableau « livres », ni au tableau « emprunts ». Au lieu de cela, nous nous tournons vers nouveau tableau, qui a été créé en joignant ces deux tables.
emprunts REJOIGNEZ les livres SUR Borings.bookid=books.bookid - c'est-à-dire, considérez, nouveau tableau, qui a été formé en combinant tous les enregistrements des tableaux « livres » et « emprunts » dans lesquels les valeurs bookid correspondent. Le résultat d’une telle fusion sera :
Et puis nous interrogeons cette table de la même manière que dans l'exemple ci-dessus. Cela signifie que lorsque vous joignez des tables, vous n'avez qu'à vous soucier de la manière d'effectuer la jointure. Et alors la demande devient aussi claire que dans le cas de la « simple demande » du point 3.
Essayons une jointure légèrement plus complexe avec deux tables.
Nous voulons maintenant obtenir le prénom et le nom des personnes qui ont pris des livres de la bibliothèque de l'auteur « Dan Brown ».
Cette fois, allons de bas en haut :
Étape Étape 1 : où obtenons-nous les données ? Pour obtenir le résultat dont nous avons besoin, nous devons joindre les tables « membres » et « livres » avec la table « emprunts ». La section JOIN ressemblera à ceci :
emprunts REJOIGNEZ les livres sur les emprunts.bookid=books.bookid REJOIGNEZ les membres sur les membres.memberid=borrowings.memberid
Le résultat de la connexion peut être vu sur le lien.
Étape 2 : quelles données montrons-nous ? Nous ne nous intéressons qu'aux données dont l'auteur du livre est « Dan Brown ».
OÙ livres.auteur="Dan Brown"
Étape 3 : comment afficher les données ? Maintenant que les données ont été reçues, il ne vous reste plus qu'à afficher les noms et prénoms de ceux qui ont pris les livres :
SELECT Members.firstname AS "Prénom", Members.lastname AS "Last Name"
Super! Il ne reste plus qu'à combiner les trois composantes et faire la demande dont nous avons besoin :
SELECT membres.firstname AS "Prénom", membres.lastname AS "Last Name" FROM emprunts REJOIGNEZ les livres ON Borrowings.bookid=books.bookid REJOIGNEZ les membres ON Members.memberid=borrowings.memberid OÙ books.author="Dan Brown";
Ce qui nous donnera :
| Mike | Willis |
| Hélène | Horton |
| Hélène | Horton |
Super! Mais les noms sont répétés (ils ne sont pas uniques). Nous allons résoudre ce problème bientôt.
5. AgrégationGrosso modo, Des agrégations sont nécessaires pour convertir plusieurs lignes en une seule. Dans le même temps, lors de l'agrégation, une logique différente est utilisée pour différentes colonnes.
Continuons avec notre exemple où des noms en double apparaissent. Il est clair qu'Ellen Horton a pris plus d'un livre, mais ce n'est pas la meilleure façon de montrer cette information. Vous pouvez faire une autre demande :
SELECT membres.firstname AS "Prénom", membres.lastname AS "Nom", count(*) AS "Nombre de livres empruntés" FROM emprunts JOIN livres ON emprunts.bookid=books.bookid JOIN membres ON membres.memberid=emprunts .memberid OÙ livres.auteur="Dan Brown" GROUP BY membres.prénom, membres.nom;
Ce qui nous donnera le résultat souhaité :
| Mike | Willis | 1 |
| Hélène | Horton | 2 |
Presque toutes les agrégations sont accompagnées d'une clause GROUP BY. Cette chose transforme une table qui pourrait être récupérée par une requête en groupes de tables. Chaque groupe correspond à une valeur unique (ou groupe de valeurs) de la colonne que nous avons spécifiée dans GROUP BY . Dans notre exemple, nous convertissons le résultat de l’exercice précédent en un groupe de lignes. Nous effectuons également une agrégation avec count , qui convertit plusieurs lignes en une valeur entière (dans notre cas, le nombre de lignes). Cette signification est ensuite attribuée à chaque groupe.
Chaque ligne du résultat représente le résultat de l'agrégation de chaque groupe.
On peut arriver à la conclusion logique que tous les champs du résultat doivent soit être spécifiés dans GROUP BY , soit une agrégation doit être effectuée sur eux. Parce que tous les autres champs peuvent différer les uns des autres sur différentes lignes, et si vous les sélectionnez avec SELECT, il n'est pas clair laquelle des valeurs possibles doit être prise.
Dans l'exemple ci-dessus, la fonction count traitait toutes les lignes (puisque nous comptions le nombre de lignes). D'autres fonctions comme sum ou max traitent uniquement les lignes spécifiées. Par exemple, si nous voulons connaître le nombre de livres écrits par chaque auteur, alors nous avons besoin de la requête suivante :
SELECT auteur, somme(stock) FROM livres GROUP BY auteur ;
Résultat:
| Robin Sharma | 4 |
| Dan Brun | 6 |
| John Green | 3 |
| Amish Tripathi | 2 |
Ici, la fonction somme traite uniquement la colonne stock et calcule la somme de toutes les valeurs de chaque groupe.
6. Sous-requêtes
Les sous-requêtes sont des requêtes SQL classiques intégrées dans des requêtes plus volumineuses. Ils sont divisés en trois types en fonction du type de résultat renvoyé.
6.1 Tableau bidimensionnelCertaines requêtes renvoient plusieurs colonnes. Un bon exemple est la requête issue de l’exercice d’agrégation précédent. Étant une sous-requête, elle renverra simplement une autre table sur laquelle de nouvelles requêtes pourront être effectuées. Dans la continuité de l'exercice précédent, si l'on veut connaître le nombre de livres écrits par l'auteur « Robin Sharma », alors l'un des moyens possibles- utiliser des sous-requêtes :
SELECT * FROM (SELECT auteur, somme (stock) FROM livres GROUP BY auteur) AS résultats OÙ auteur="Robin Sharma";
Résultat:
Peut s'écrire : ["Robin Sharma", "Dan Brown"]
2. Nous utilisons maintenant ce résultat dans une nouvelle requête :
SELECT titre, bookid FROM livres WHERE auteur IN (SELECT auteur FROM (SELECT auteur, somme (stock) FROM livres GROUP BY auteur) AS résultats WHERE somme > 3);
Résultat:
| Le symbole perdu | 2 |
| Qui pleurera quand tu mourras ? | 3 |
| Enfer | 4 |
C'est la même chose que :
SELECT title, bookid FROM books WHERE author IN ("Robin Sharma", "Dan Brown"); 6.3 Valeurs individuelles
Certaines requêtes aboutissent à une seule ligne et une seule colonne. Ils peuvent être traités comme des valeurs constantes et peuvent être utilisés partout où des valeurs sont utilisées, par exemple dans les opérateurs de comparaison. Ils peuvent également être utilisés comme tableaux bidimensionnels ou tableaux à un seul élément.
Obtenons, par exemple, des informations sur tous les livres dont le nombre dans la bibliothèque dépasse la moyenne actuelle.
La moyenne peut être obtenue de cette façon :
sélectionnez avg(stock) dans les livres ;
Ce qui nous donne :
7. Opérations d'écriture
La plupart des opérations d'écriture dans la base de données sont assez simples par rapport aux opérations de lecture plus complexes.
7.1 Mise à jourLa syntaxe d'une requête UPDATE est sémantiquement la même qu'une requête de lecture. La seule différence est qu'au lieu de sélectionner les colonnes avec SELECT, nous définissons les connaissances avec SET.
Si tous les livres de Dan Brown sont perdus, vous devez alors réinitialiser la valeur de la quantité. La requête pour cela serait :
MISE À JOUR des livres SET stock=0 WHERE author="Dan Brown";
WHERE fait la même chose que précédemment : sélectionne les lignes. Au lieu du SELECT que nous avons utilisé lors de la lecture, nous utilisons maintenant SET. Cependant, vous devez maintenant spécifier non seulement le nom de la colonne, mais également une nouvelle valeur pour cette colonne dans les lignes sélectionnées.
7.2 Supprimer
Une requête DELETE est simplement une requête SELECT ou UPDATE sans noms de colonnes. Sérieusement. Comme pour SELECT et UPDATE , le bloc WHERE reste le même : il sélectionne les lignes à supprimer. L'opération de suppression détruit la ligne entière, cela n'a donc aucun sens de spécifier des colonnes individuelles. Ainsi, si nous décidons de ne pas réinitialiser le nombre de livres de Dan Brown, mais de supprimer complètement tous les enregistrements, nous pouvons alors faire la demande suivante :
SUPPRIMER DES livres OÙ author="Dan Brown"; 7.3 Insérer
La seule chose qui diffère des autres types de requêtes est peut-être INSERT. Le format est :
INSÉRER DANS LES VALEURS x (a,b,c) (x, y, z);
Où a , b , c sont les noms de colonnes, et x , y et z sont les valeurs à insérer dans ces colonnes, dans le même ordre. C'est essentiellement ça.
Regardons un exemple spécifique. Voici une requête INSERT qui remplit toute la table « books » :
INSÉRER DANS les livres (identifiant du livre, titre, auteur, publié, stock) VALEURS (1, "Scion of Ikshvaku", "Amish Tripathi", "22-06-2015", 2), (2, "Le symbole perdu", Dan Brown","22/07/2010",3), (3,"Qui pleurera quand tu mourras ?","Robin Sharma","15/06/2006",4), (4,"Inferno" ,"Dan Brown","05-05-2014",3), (5,"La faute dans nos étoiles","John Green","01-03-2015",3); 8. Vérifiez
Nous sommes arrivés au bout, je vous propose un petit test. Regardez cette demande au tout début de l'article. Pouvez-vous le comprendre ? Essayez de le diviser en sections SELECT , FROM , WHERE , GROUP BY et examinez les composants individuels des sous-requêtes.
Le voici sous une forme plus lisible :
SELECT membres.prénom || " " || membres.lastname AS "Nom complet" FROM emprunts INNER JOIN membres ON membres.memberid=borrowings.memberid INNER JOIN livres ON books.bookid=borrowings.bookid OÙ emprunts.bookid IN (SELECT bookid FROM livres WHERE stock> (SELECT avg(stock ) FROM livres)) GROUP BY membres.prénom, membres.nom;
Cette requête renvoie une liste de personnes ayant emprunté un livre de la bibliothèque dont le nombre total est supérieur à la moyenne.
Résultat:
| Lida Tyler |
J'espère que vous avez pu le comprendre sans aucun problème. Mais sinon, j'apprécierais vos commentaires et réactions afin de pouvoir améliorer cet article.
Balises : Ajouter des balises
Le langage SQL est utilisé pour récupérer les données de la base de données. SQL est un langage de programmation qui ressemble beaucoup à l'anglais mais est destiné aux programmes de gestion de bases de données. SQL est utilisé dans chaque requête dans Access.
Comprendre le fonctionnement de SQL vous aide à créer davantage requêtes exactes et facilite la correction des requêtes qui renvoient des résultats incorrects.
Il s'agit d'un article issu d'une série d'articles sur le langage SQL pour Access. Il décrit les bases de l'utilisation de SQL pour récupérer des données et fournit des exemples de syntaxe SQL.
Dans cet article Qu'est-ce que SQL ?SQL est un langage de programmation conçu pour fonctionner avec des ensembles de faits et les relations entre eux. Dans les programmes de gestion de bases de données relationnelles tels que Microsoft Office Access, le langage SQL est utilisé pour travailler avec les données. Contrairement à de nombreux langages de programmation, SQL est lisible et compréhensible même pour les débutants. Comme de nombreux langages de programmation, SQL est une norme internationale reconnue par les comités de normalisation tels que l'ISO et l'ANSI.
Les ensembles de données sont décrits en SQL pour aider à répondre aux questions. Lorsque vous utilisez SQL, vous devez utiliser la syntaxe correcte. La syntaxe est un ensemble de règles qui permettent de combiner correctement les éléments d'un langage. La syntaxe SQL est basée sur la syntaxe anglaise et partage de nombreux éléments avec la syntaxe Visual Basic pour Applications (VBA).
Par exemple, une simple instruction SQL qui récupère une liste de noms de famille pour les contacts nommés Mary pourrait ressembler à ceci :
SELECT Nom_de_famille
DE Contacts
OÙ Prénom_Name = "Marie" ;
Remarque : SQL est utilisé non seulement pour effectuer des opérations sur les données, mais également pour créer et modifier la structure des objets de base de données, tels que les tables. La partie de SQL utilisée pour créer et modifier des objets de base de données est appelée DDL. DDL n'est pas couvert dans cet article. Pour plus d’informations, consultez Créer ou modifier des tables ou des index à l’aide d’une requête de définition de données.
Instructions SELECTL'instruction SELECT est utilisée pour décrire un ensemble de données en SQL. Il contient Description complète ensemble de données qui doivent être récupérées de la base de données, notamment les suivantes :
des tableaux contenant des données ;
connexions entre les données de différentes sources;
champs ou calculs sur la base desquels les données sont sélectionnées ;
conditions de sélection qui doivent être remplies par les données incluses dans le résultat de la requête ;
nécessité et méthode de tri.
Une instruction SQL est composée de plusieurs parties appelées clauses. Chaque clause d'une instruction SQL a un objectif. Certaines offres sont obligatoires. Le tableau ci-dessous présente les instructions SQL les plus couramment utilisées.
|
Instruction SQL |
Description |
Obligatoire |
|
Définit les champs qui contiennent les données requises. |
||
|
Définit les tables qui contiennent les champs spécifiés dans la clause SELECT. |
||
|
Définit les conditions de sélection de champ que doivent remplir tous les enregistrements inclus dans les résultats. |
||
|
Détermine l'ordre de tri des résultats. |
||
|
Dans une instruction SQL contenant des fonctions d'agrégation, spécifie les champs pour lesquels une valeur récapitulative n'est pas calculée dans la clause SELECT. |
Seulement si de tels champs sont présents |
|
|
Une instruction SQL contenant des fonctions d'agrégation définit les conditions qui s'appliquent aux champs pour lesquels une valeur récapitulative est calculée dans la clause SELECT. |
Chaque phrase SQL est constituée de termes qui peuvent être comparés à des parties du discours. Le tableau ci-dessous montre les types de termes SQL.
|
Terme SQL |
Partie comparable du discours |
Définition |
Exemple |
|
identifiant |
nom |
Nom utilisé pour identifier un objet de base de données, tel qu'un nom de champ. |
Clients.[Numéro de téléphone] |
|
opérateur |
verbe ou adverbe |
Un mot-clé qui représente ou modifie une action. |
|
|
constante |
nom |
Une valeur qui ne change pas, telle qu'un nombre ou NULL. |
|
|
expression |
adjectif |
Combinaison d'identifiants, d'opérateurs, de constantes et de fonctions conçues pour calculer une valeur unique. |
>= Produits.[Prix] |
Le format général des instructions SQL est :
SELECT champ_1
DEPUIS table_1
OÙ critère_1
;
Remarques:
Access ne respecte pas les sauts de ligne dans les instructions SQL. Malgré cela, il est recommandé de commencer chaque phrase par nouvelle ligne afin que l'instruction SQL soit facile à lire à la fois pour la personne qui l'a écrite et pour tout le monde.
Chaque instruction SELECT se termine par un point-virgule (;). Le point-virgule peut apparaître soit à la fin de la dernière phrase, soit sur une ligne distincte à la fin de l'instruction SQL.
L'exemple ci-dessous montre à quoi pourrait ressembler une instruction SQL pour une requête de sélection simple dans Access.
1.Clause SELECT
2. Clause DE
3. Clause OÙ
Regardons l'exemple phrase par phrase pour comprendre comment fonctionne la syntaxe SQL.
Clause SELECTSELECT,Entreprise
Il s'agit d'une clause SELECT. Il contient une instruction (SELECT) suivie de deux identifiants ("[Adresse E-mail]" et "Société").
Si l'identifiant contient des espaces ou signes spéciaux(par exemple, « Adresse e-mail »), elle doit être placée entre crochets rectangulaires.
La clause SELECT ne vous oblige pas à spécifier les tables qui contiennent les champs et vous ne pouvez pas spécifier de conditions de sélection qui doivent être remplies par les données incluses dans les résultats.
Dans une instruction SELECT, la clause SELECT précède toujours la clause FROM.
Clause DEDE Contacts
Il s'agit d'une clause FROM. Il contient une instruction (FROM) suivie d'un identifiant (Contacts).
La clause FROM ne précise pas les champs à sélectionner.
Clause OÙOÙ Ville="Seattle"
Il s'agit de la clause WHERE. Il contient une instruction (WHERE) suivie de l'expression (City="Rostov").
Vous pouvez faire de nombreuses choses avec les clauses SELECT, FROM et WHERE. Pour plus d’informations sur l’utilisation de ces offres, consultez les articles suivants :
Tri des résultats : ORDER PARUn péché Microsoft Excel, dans Access, vous pouvez trier les résultats d'une requête dans un tableau. En utilisant la clause ORDER BY, vous pouvez également spécifier comment les résultats sont triés lors de l'exécution de la requête. Si une clause ORDER BY est utilisée, elle doit apparaître à la fin de l'instruction SQL.
La clause ORDER BY contient une liste de champs à trier, dans le même ordre dans lequel le tri sera appliqué.
Supposons, par exemple, que les résultats doivent d'abord être triés par le champ « Société » par ordre décroissant, puis s'il existe des enregistrements avec la même valeur champs "Entreprise", - triez-les par le champ "Adresse e-mail" par ordre croissant. La clause ORDER BY ressemblerait à ceci :
COMMANDE PAR Société DESC,
Remarque : Par défaut, Access trie les valeurs par ordre croissant (A à Z, de la plus petite à la plus grande). Pour trier les valeurs par ordre décroissant, vous devez spécifier le mot-clé DESC.
Pour plus d’informations sur la clause ORDER BY, consultez l’article sur la clause ORDER BY.
Travailler avec des données récapitulatives : clauses GROUP BY et HAVINGParfois, vous devez travailler avec des données récapitulatives, telles que les ventes totales du mois ou les articles les plus chers en stock. Pour ce faire, la clause SELECT applique une fonction d'agrégation au champ. Par exemple, si vous deviez exécuter une requête pour obtenir le nombre d'adresses e-mail pour chaque entreprise, la clause SELECT pourrait ressembler à ceci :
La possibilité d'utiliser une fonction d'agrégation particulière dépend du type de données dans le champ et de l'expression souhaitée. Pour plus d’informations sur les fonctions d’agrégation disponibles, consultez Fonctions statistiques SQL.
Spécification des champs qui ne sont pas utilisés dans une fonction d'agrégation : clause GROUP BYLorsque vous utilisez des fonctions d'agrégation, vous devez généralement créer une clause GROUP BY. La clause GROUP BY spécifie tous les champs auxquels la fonction d'agrégation ne s'applique pas. Si les fonctions d'agrégation s'appliquent à tous les champs de la requête, vous n'avez pas besoin de créer une clause GROUP BY.
La clause GROUP BY doit immédiatement suivre la clause WHERE ou FROM s'il n'y a pas de clause WHERE. La clause GROUP BY répertorie les champs dans le même ordre que la clause SELECT.
Continuons l'exemple précédent. Dans la clause SELECT, si la fonction d'agrégation s'applique uniquement au champ [Adresse e-mail], alors la clause GROUP BY ressemblerait à ceci :
GROUPER PAR Société
Pour plus d’informations sur la clause GROUP BY, consultez l’article sur la clause GROUP BY.
Restreindre les valeurs agrégées à l'aide de conditions de regroupement : la clause HAVINGSi vous devez spécifier des conditions pour limiter les résultats, mais que le champ auquel vous souhaitez les appliquer est utilisé dans une fonction d'agrégation, vous ne pouvez pas utiliser de clause WHERE. La clause HAVING doit être utilisée à la place. La clause HAVING fonctionne de la même manière que la clause WHERE, mais est utilisée pour les données agrégées.
Par exemple, supposons que la fonction AVG (qui calcule la moyenne) soit appliquée au premier champ de la clause SELECT :
SELECT COUNT(), Société
Si vous souhaitez limiter les résultats de la requête en fonction de la valeur de la fonction COUNT, vous ne pouvez pas appliquer de condition de sélection à ce champ dans la clause WHERE. Au lieu de cela, la condition doit être placée dans la clause HAVING. Par exemple, si vous souhaitez que votre requête renvoie des lignes uniquement si une entreprise possède plusieurs adresses e-mail, vous pouvez utiliser la clause HAVING suivante :
AVOIR COUNT()>1
Remarque : Une requête peut inclure à la fois une clause WHERE et une clause HAVING, avec des conditions de sélection pour les champs qui ne sont pas utilisés dans fonctions statistiques, sont spécifiés dans la clause WHERE et les conditions des champs utilisés dans les fonctions statistiques sont spécifiées dans la clause HAVING.
Pour plus d’informations sur la clause HAVING, consultez l’article sur la clause HAVING.
Combinaison des résultats de requête : opérateur UNIONL'opérateur UNION est utilisé pour afficher simultanément toutes les données renvoyées par plusieurs requêtes de sélection similaires sous la forme d'un ensemble combiné.
L'opérateur UNION vous permet de combiner deux instructions SELECT en une seule. Les instructions SELECT en cours de fusion doivent avoir le même nombre et le même ordre de champs de sortie avec des types de données identiques ou compatibles. Lorsqu'une requête est exécutée, les données de chaque ensemble de champs correspondants sont combinées en un seul champ de sortie, de sorte que la sortie de la requête comporte autant de champs que chaque instruction SELECT individuelle.
Remarque : Dans les requêtes pour joindre des valeurs numériques et types de texte les données sont compatibles.
À l'aide de l'opérateur UNION, vous pouvez spécifier si les lignes en double, le cas échéant, doivent être incluses dans les résultats de la requête. Pour ce faire, utilisez le mot clé ALL.
Une requête pour combiner deux instructions SELECT a la syntaxe de base suivante :
SELECT champ_1
DEPUIS table_1
SYNDICAT
SELECT champ_a
DEPUIS table_a
;
Par exemple, supposons que vous ayez deux tables appelées « Produits » et « Services ». Les deux tableaux contiennent des champs avec le nom du produit ou du service, des informations sur le prix et la garantie, ainsi qu'un champ qui indique l'exclusivité du produit ou du service proposé. Bien que les tableaux « Produits » et « Services » fournissent différents types garanties, les informations de base sont les mêmes (que certains produits ou services soient fournis avec une garantie de qualité). Vous pouvez utiliser la requête de jointure suivante pour joindre quatre champs de deux tables :
SELECTIONNEZ le nom, le prix, la garantie_disponible, l'offre_exclusive
DE Produits
UNION TOUS
SELECT nom, prix, garantie_disponible, offre_exclusive
DES Services
;
Pour plus d'informations sur la combinaison d'instructions SELECT à l'aide de l'opérateur UNION, consultez
Ainsi, dans notre base de données de forum, il y a trois tableaux : utilisateurs (utilisateurs), sujets (sujets) et messages (messages). Et nous voulons voir quelles données ils contiennent. Il existe un opérateur pour cela dans SQL SÉLECTIONNER. La syntaxe pour l'utiliser est la suivante :
SELECT what_select FROMwhere_select ;
Au lieu de « what_select » il faut préciser soit le nom de la colonne dont on veut voir les valeurs, soit les noms de plusieurs colonnes séparées par des virgules, soit le symbole astérisque (*), signifiant la sélection de toutes les colonnes du tableau . Au lieu de "from_select", vous devez spécifier le nom de la table.
Examinons d'abord toutes les colonnes de la table des utilisateurs :
SELECT * FROM utilisateurs ;
Ce sont toutes nos données que nous avons entrées dans ce tableau. Mais supposons que nous souhaitions examiner uniquement la colonne id_user (par exemple, dans la dernière leçon, afin de remplir la table des sujets, nous avions besoin de savoir quels id_users se trouvent dans la table des utilisateurs). Pour cela, nous préciserons le nom de cette colonne dans la requête :
SELECT id_user FROM utilisateurs ;
Eh bien, si nous voulons voir, par exemple, les noms et les e-mails de nos utilisateurs, alors nous listerons les colonnes d'intérêt séparées par des virgules :
SELECT le nom, l'adresse e-mail des utilisateurs ;
De même, vous pouvez voir quelles données contiennent nos autres tableaux. Voyons quels sujets nous avons :
SELECT * FROM sujets ;
Maintenant, nous n'avons que 4 sujets, mais et s'il y en avait 100 ? J'aimerais qu'ils soient affichés, par exemple, par ordre alphabétique. Il existe un mot-clé pour cela dans SQL COMMANDÉ PAR suivi du nom de la colonne par laquelle le tri aura lieu. La syntaxe est la suivante :
SELECT nom_colonne FROM nom_table ORDER BY nom_colonne_tri ;
Par défaut le tri est croissant, mais cela peut être modifié en ajoutant un mot-clé DESC
Désormais, nos données sont triées par ordre décroissant.
Le tri peut être effectué sur plusieurs colonnes à la fois. Par exemple, la requête suivante triera les données selon la colonne topic_name, et s'il y a plusieurs lignes identiques dans cette colonne, alors la colonne id_author sera triée par ordre décroissant :
Comparez le résultat avec le résultat de la requête précédente.
Très souvent, nous n’avons pas besoin de toutes les informations du tableau. Par exemple, nous voulons savoir quels sujets ont été créés par l'utilisateur sveta (id=4). Il existe un mot-clé pour cela dans SQL OÙ, la syntaxe d'une telle requête est la suivante :
Pour notre exemple, la condition est l'ID utilisateur, c'est-à-dire Nous n'avons besoin que des lignes dont la colonne id_author contient 4 (ID utilisateur sveta) :
Ou nous voulons savoir qui a créé le thème "vélos":
Bien sûr, il serait plus pratique qu'au lieu de l'identifiant de l'auteur, son nom soit affiché, mais que les noms soient stockés dans une autre table. Dans les leçons suivantes, nous apprendrons à sélectionner des données dans plusieurs tables. En attendant, découvrons quelles conditions peuvent être définies à l'aide du mot-clé WHERE.
| Opérateur | Description |
| = (égal) | Les valeurs égales à la valeur spécifiée sont sélectionnées Exemple: SELECT * FROM sujets WHERE id_author=4; Résultat:
|
| > (plus) | Les valeurs supérieures à celles spécifiées sont sélectionnées Exemple: SELECT * FROM sujets WHERE id_author>2; Résultat:
|
| < (меньше) | Les valeurs inférieures à celles spécifiées sont sélectionnées Exemple: SELECT * FROM sujets OÙ id_author
|
| >= (supérieur ou égal à) | Les valeurs supérieures et égales à la valeur spécifiée sont sélectionnées Exemple: SELECT * FROM sujets WHERE id_author>=2; Résultat:
|
| ENSEMBLE ( | ) .,. .<
COLUMN
name>
=
<
VALUE
expresslon>[OÙ<
predlcate>| OÙ COURANT DE<
cursor name>(*uniquement pour pièce jointe*) ] ; UPDATE pairs SET zone= "voip" ; # met à jour toutes les lignes de la colonne zone de la table des pairs UPDATE stat SET whp= "13x13x13" WHERE id = 1 ; UPDATE country SET nm_ukr= ( SELECT del_countries. ukrainian FROM del_countries WHERE country. nm_en= del_countries. english ) ; Utilisation de WordPress, paramètre : dans la table wp_posts, supprimez toutes les occurrences de la ligne UPDATE wp_posts SET post_content = REPLACE (post_content, "" , "" ) ;SUPPRIMER DE |
