Database
 sql >> Base de données >  >> RDS >> Database

Table de référence SQL :comment créer et écrire des requêtes de base

Cet article se concentrera sur l'écriture de requêtes SQL sur la table de référence de la base de données avec une structure assez simple à comprendre et à mettre en œuvre.

De plus, nous allons clarifier les concepts derrière l'écriture de requêtes SQL efficaces ainsi que quelques conseils de vie professionnelle.

Avant d'interroger les tables de la base de données

Comme cet article concerne l'interrogation des tables de base de données à l'aide de scripts SQL, les lecteurs doivent avoir une certaine expérience pour bien comprendre les concepts et les exemples. Nous devons avoir l'impression de comment référencer une table. De plus, le matériel nécessaire doit être présent :

Vous avez besoin :

  1. La connaissance de base des bases de données relationnelles et de SQL.
  2. Un serveur de base de données SQL installé localement ou à distance.
  3. Outils de gestion de base de données tels que SQL Server Management Studio ou dbForge Studio pour SQL Server.

Vous devriez être en mesure de créer un exemple de base de données (à l'aide des scripts fournis), de vous connecter au serveur SQL et de l'exécuter sur cet exemple de base de données.

Avant de procéder à l'exécution de requêtes sur une base de données vierge, vous devrez peut-être vous référer à l'article précédent dédié au sujet pour rafraîchir les connaissances :

Comment écrire des requêtes SQL simples à partir d'une base de données vide

Écrire des requêtes SQL à partir de tables de référence

Nous devons écrire des requêtes SQL sur un exemple de base de données contenant deux tables. Le plan consiste à afficher les données de l'une des tables appelées table de référence SQL. Remarque :La table de référence peut être n'importe quelle table ne nécessitant pas de données d'une autre table.

Tout d'abord, nous devons comprendre la structure de l'exemple de base de données pour l'interroger avec précision.

Exemple de table de référence de base de données

Nous utilisons un exemple BookSimple2 base de données composée de deux tables, BookType et réserver .

Le BookType table contient les types de livres à affecter à un livre. Le Livre le tableau contient les noms, les types et le stock (nombre d'exemplaires disponibles) des livres.

Il est facile de deviner que les deux tables sont liées via des clés. Le type de livre stocké dans le Livre la table est définie à l'origine dans le BookType table. Cela permet de garder les données cohérentes et fiables.

Par conséquent, le BookType table est une table de référence - elle fournit sa référence (type de livre) au Livre principal tableau.

Regardez l'illustration ci-dessous :

Si nous ne lions pas le livre tableau avec BookType pour obtenir le type du livre, il faut définir le type nécessaire à chaque fois qu'un nouveau livre est stocké. En conséquence, des erreurs se produiront bientôt car nous stockons le même type encore et encore. De plus, nous pouvons finir par créer beaucoup plus de types en raison de fautes d'orthographe.

Disons que si nous ignorons l'utilisation de tables de référence et ne créons qu'une seule table principale, nous pouvons utiliser différentes manières de représenter un type, comme Design , Conception , et Designs . Cela prête à confusion, en particulier lors de l'interrogation et de la compréhension des données.

Vous pouvez également vous référer à l'article précédent pour plus d'informations sur la façon dont les tables sont liées les unes aux autres dans SQL :

Apprendre la conception de bases de données avec SQL Server Management Studio (SSMS) - Partie 2

Maintenant que vous voyez le contexte de l'utilisation des tables de référence et des tables principales, nous pouvons passer aux exemples.

Comment créer une table de référence en SQL

Ouvrez l'outil de développement de base de données (il peut s'agir de SQL Server Management Studio ou de dbForge Studio pour SQL Server) et connectez-vous à l'instance de serveur SQL installée.

Écrivez le script suivant sur la base de données principale pour configurer un exemple de base de données BookSimple2 avec deux tableaux :

-- Create sample database BookSimple2
USE MASTER
GO

CREATE DATABASE BookSimple2
GO

USE BookSimple2

-- Creating a reference table BookType
CREATE TABLE dbo.BookType
(
	BookTypeId INT IDENTITY(1,1),
	Name VARCHAR(50)NOT NULL,
	Detail VARCHAR(200)NULL 
	CONSTRAINT PK_BookType_BookTypeId PRIMARY KEY (BookTypeId)
)
GO

-- Populating (adding rows to the) table BookType
SET IDENTITY_INSERT dbo.BookType ON
GO
INSERT INTO dbo.BookType
(
  BookTypeId
 ,Name
 ,Detail
)
VALUES
(
  1  -- ID - INT Primary Key
 ,'Designing' -- Name - varchar(50) NOT NULL
 ,'This is Designing' -- Detail - varchar(200)
),
(
  2  -- ID - INT Primary Key
 ,'Testing' -- Name - varchar(50) NOT NULL
 ,'This is Testing' -- Detail - varchar(200)
),
(
  3  -- ID - INT Primary Key
 ,'Coding' -- Name - varchar(50) NOT NULL
 ,'This is Coding' -- Detail - varchar(200)
);
GO
SET IDENTITY_INSERT dbo.BookType OFF
GO

-- Creating a table Book
CREATE TABLE dbo.Book
(
	BookId INT IDENTITY(1,1),
	Name VARCHAR(50),
	BookTypeId INT,
	Stock INT,
	CONSTRAINT PK_Book_BookId PRIMARY KEY (BookId)
)
GO

Après avoir exécuté le script, vous pouvez afficher la base de données nouvellement créée dans l'explorateur d'objets SSMS ou la section Explorateur de base de données de dbForge Studio pour SQL Server :

Comment référencer deux tables avec une clé étrangère SQL

J'ai délibérément exclu la partie du script qui crée la relation entre la table de référence (BookType ) et le tableau principal (Livre ) sous forme de clés.

Exécutez le script suivant sur l'exemple de base de données pour lier la table de référence à la table principale :

-- Creating foreign key constraint on Book table to get BookTypeId values from BookType table
ALTER TABLE dbo.Book
    ADD CONSTRAINT [FK_Book_BookType_BookTypeId] 
FOREIGN KEY ([BookTypeId]) REFERENCES dbo.[BookType] ([BookTypeId]);

Développez le BookSimple2 base de données> Réserver tableau> Clés dossier :

Nous pouvons voir que les deux tables sont liées avec succès.

Ce qui précède est la capture d'écran de SQL Server Management Studio. Cependant, la vue est exactement la même si vous affichez la base de données dans l'explorateur de base de données de dbForge Studio pour SQL Server.

Un conseil important sur la sélection de la base de données souhaitée : Vous devez vous assurer que vous exécutez des requêtes sur la bonne base de données, la base de données exemple. Par conséquent, sélectionnez-le dans la liste des bases de données disponibles ou exécutez le script suivant :

-- Select the sample SQL database to query it
USE BookSimple2

Important! L'utilisation d'un script pour sélectionner la base de données n'est pas applicable si vous travaillez avec une version cloud de la base de données SQL appelée Azure SQL Database.

Rédaction de la première requête

Pour interroger les tables de la base de données, nous n'avons qu'à l'esprit l'instruction SELECT sous la forme suivante :

SELECT * FROM <TableName>

Remplacez par le nom d'une table existante, et le script vous renverra tous les enregistrements (lignes) de cette table.

L'instruction SELECT est beaucoup plus flexible, mais pour l'instant, nous nous concentrerons uniquement sur l'affichage de tous les enregistrements (lignes) d'une table.

Un conseil important sur SQL  :N'oubliez pas que SQL (en particulier en ce qui concerne T-SQL) n'est pas sensible à la casse . Il concerne à la fois le mot réservé SQL (SELECT est identique à Sélectionner ) ou des noms définis par l'utilisateur (BookType est identique à booktype ) .

Afficher toutes les lignes de la table de référence BookType

Écrivez le script suivant sur l'exemple de base de données :

-- View all data from the BookType table
SELECT * FROM dbo.BookType

La sortie est :

Nous pouvons voir toutes les colonnes et lignes du tableau. C'est de loin la méthode la plus rapide pour obtenir toutes les données d'une table.

Conseil important à propos de SELECT * : Vous devez utiliser SELECT * pour obtenir toutes les lignes et colonnes d'une table uniquement lorsque vous cochez une petite table (telle qu'une table de référence). Sinon, cela peut prendre beaucoup de temps, alors que nous pourrions avoir besoin des données sur quelques colonnes et lignes d'une table plus grande.

Rechercher toutes les lignes de la table BookType à l'aide du nom de la table

Il existe une meilleure façon d'interroger la table. Nous nommons une table et la lions avec toutes les colonnes comme indiqué ci-dessous :

-- View all data from the BookType table using bt alias
SELECT bt.* FROM dbo.BookType bt

Afficher les colonnes sélectionnées à partir du tableau de référence

L'utilisation de noms de table apporte plus d'avantages. Tout d'abord, nous pouvons sélectionner rapidement la colonne souhaitée dans le tableau. Ensuite, cela rend l'utilisation des tables et des colonnes limitées plus claire car dans la plupart des cas, nous n'avons besoin que de quelques colonnes.

Voici un exemple d'obtention d'identifiants et de noms uniquement à partir du BookType tableau :

-- View book type id and name columns from the reference table
SELECT bt.BookTypeId,bt.Name FROM dbo.BookType bt

Le résultat est :

Amélioration de la syntaxe SELECT

Ainsi, sur la base des informations mentionnées ci-dessus, nous pouvons améliorer la syntaxe SELECT comme suit :

SELECT t.<column1>,t.<column2> FROM <TableName> t

Trier les données par colonne de nom à l'aide de la clause Trier par

Vous pouvez trier le jeu de résultats en fonction d'une colonne ou d'un ensemble de colonnes spécifique. Trier les données donne un point de vue différent.

L'utilisation de Trier par clause dans ce cas est :

SELECT t.<column1>,t.<column2> FROM <TableName> t order by t.<column1>

Par exemple, nous voulons voir les types de livres classés par nom de type (ordre alphabétique). Dans ce cas, nous utilisons la clause Order By dans le script d'instruction SELECT comme suit :

-- View book types (name) sorted by type name 
SELECT bt.Name FROM dbo.BookType bt ORDER BY bt.Name

La sortie est :

Trier les données par nom de colonne dans l'ordre décroissant

Nous pouvons également trier les données par ordre décroissant selon les besoins. Par exemple, nous voulons voir la liste de tous les types de livres en fonction de la colonne Nom dans l'ordre décroissant (Z à A). La syntaxe sera :

SELECT t.<column1>,t.<column2> FROM <TableName> t order by t.<column1> desc

Le script T-SQL est le suivant :

-- View book types (name) sorted by a type name in descending order (from Z to A)
SELECT bt.Name FROM dbo.BookType bt ORDER BY bt.Name desc

Le jeu de résultats est ci-dessous :

Afficher les N TOP d'enregistrements d'un tableau

Enfin, nous pouvons sélectionner le nombre souhaité de lignes à extraire d'une base de données en utilisant la clause TOP. Après cette clause, nous devons fournir le nombre requis :

SELECT Top N t.<column1>,t.<column2> FROM <TableName> t

Cependant, la clause TOP sans ordre n'est pas la meilleure option. Nous devons spécifier l'ordre des colonnes à prendre en compte lors de la sélection des n premières lignes.

Ici, nous pouvons améliorer la syntaxe ci-dessus comme suit :

SELECT Top N t.<column1>,t.<column2> FROM <TableName> t order by <column> Desc/Asc

N'oubliez pas qu'il faut mentionner l'ordre décroissant en utilisant DESC à la fin. Cependant, l'ordre croissant n'est pas obligatoire à mentionner - c'est l'option par défaut.

Voyons les 2 principaux types de livres classés par nom dans l'ordre décroissant :

--View Top 2 types of the books ordered by name in descending order (from Z to A)
SELECT TOP 2 bt.Name FROM dbo.BookType bt 
ORDER BY bt.Name DESC

La sortie est :

Astuce importante à propos de TOP N : utilisez la clause TOP N (avec un ordre par) pour visualiser une table plutôt que de visualiser toutes les lignes de la table si vous souhaitez vérifier rapidement les données appelées aperçu.

Dans les scénarios de la vie professionnelle, la clause Top N sert à mettre à jour de grandes quantités de données à partir d'une grande table par étapes.

Maintenant, nous avons interrogé avec succès la table d'une base de données SQL. En outre, nous nous sommes familiarisés avec quelques astuces pour exécuter des requêtes comme un professionnel et avons appris quelques bonnes pratiques pour la rédaction de requêtes SQL.

Pratique du tableau de référence DB

Vous pouvez désormais écrire, exécuter et augmenter l'efficacité des requêtes SQL sur n'importe quelle table. Essayez les exercices suivants pour améliorer les nouvelles compétences :

  1. Essayez d'écrire un script pour afficher l'identifiant du type de livre (BookTypeId ) avec les détails (Détail ) colonnes uniquement.
  2. Essayez de trier la référence BookType tableau par identifiants (BookTypeId ) par ordre décroissant (de 3 à 1).
  3. Essayez d'obtenir les 2 premières lignes du BookType table comprenant uniquement l'identifiant (BookTypeId ) et les détails (Détail ) du type de livre trié par Détail colonne.