devstory

Le Tutoriel de SQL pour débutant avec SQL Server

  1. Giới thiệu
  2. Outils de visualisation pour travailler avec SQL Server
  3. La base de données pour apprendre SQL (LearningSQL)
  4. Các câu lệnh truy vấn (Query)
  5. Các câu lệnh trèn dữ liệu (Insert)
  6. Câu lệnh cập nhập (Update)
  7. Câu lệnh xóa dữ liệu (Delete)
  8. SQL Functions
  9. SQL Join
  10. Câu truy vấn con (Subquery)
  11. Tutoriel de programmation SQL Server Transact-SQL

1. Giới thiệu

Ce document est tout particulièrement destiné aux débutants qui veulent apprendre SQL. Ce document est basé sur:
  • SQL Server (2008-2014)
Ses contenues comprennes:
  • Le langage SQL
  • La syntaxe de SQL
  • La sytaxe spécifique SQL de SQL Server
  • SQL Server (2008 - 2020)
Son contenu comprend :
  • Langage SQL
  • Syntaxe SQL (syntaxe de base, standard pour chaque DB)
  • Syntaxe SQL spécifique de SQLServer.
En savoir plus:
  • Hướng dẫn học SQL cho người mới bắt đầu với MySQL
  • SQL Tutorial for Beginners with Oracle

2. Outils de visualisation pour travailler avec SQL Server

Dans cette instruction, j'utilise le SQLServer Management Studio, un outil disponible dans le SQL Server. Après l'avoir installé, vous serez libre de l'utiliser. Pour avoir plus d'instruction de l'installation du SQLServer, veuillez consulter à:

3. La base de données pour apprendre SQL (LearningSQL)

Ce document est utilisé la base de données de LearningSQL (version SQLServer). Il est nécessaire pour vous de créer une base de données pour la convenance de votre apprentissage ( il vous demande moins de 5 minutes).

Le Script crée la base de donnée et sa structure, pour aller plus loin, veuillez consulter à:

4. Các câu lệnh truy vấn (Query)

SQL Select
La commande Select est une commande basique dans le SQL. L'utilisation basique de cette commande est de s'effectuer la requête de base de données dans des tables (Table).
  • PRODUCT_TYPE: Une table de la base de donnée des produits (Service type of bank).
C'est une commande Select de requête de la base de données dans la table PRODUCT_TYPE
-- Query entire column of Product_Type table.

Select * From Product_Type;


-- The above statement and the following statement are equivalent.
-- Pty is alias (a alias of Product_Type table).


Select Pty.* From Product_Type Pty;

-- Query some columns.

Select Pty.Product_Type_Cd
     ,Pty.Name
From   Product_Type Pty;
Les résutats de requête:
La requête de la base de données dans la table EMPLOYEE:
-- Query 4 columns on the Employee table
-- Using Emp as alias for Employee

Select Emp.Emp_Id
     ,Emp.First_Name
     ,Emp.Last_Name
     ,Emp.Dept_Id
From   Employee Emp;
Les résultats de requête:
Alias sur une colonne:
-- Using Convert(Varchar, <intvalue>) to convert int to Varchar (Function of SQL Server)
-- Using + operation to  concatenate two strings together.
-- We have a new column, use 'as' to define column name for this column.

Select Emp.Emp_Id
    ,Emp.First_Name
    ,Emp.Last_Name
    ,Emp.Dept_Id
    ,'EMP' +  Convert(Varchar,Emp.Emp_Id) As Emp_No2  -- Cột mới
From   Employee Emp;

-- Maybe not need 'as' in the definition Alias column
Select Emp.Emp_Id
    ,Emp.First_Name
    ,Emp.Last_Name
    ,Emp.Dept_Id
    ,'EMP' + Convert(varchar,Emp.Emp_Id ) Emp_No2  -- New column
From   Employee Emp;
Les résultats de requête:
SQL Distinct
L'utilisation de la commande distinct et la commande Selecte vise à sélectionner- select des bases de données et en évitant des redondances dans les résultats. Sa syntaxte est:
Select distinct <column1>, <column2>  ....
Exemple:
-- Query Product table.
Select Pro.Product_Cd
    ,Pro.Name
    ,Pro.Product_Type_Cd
From   Product Pro;

-- Query Product_Type in Product table.
Select Pro.Product_Type_Cd from Product Pro;

-- Distinct need to use to remove the duplicates.
Select Distinct Pro.Product_Type_Cd from Product Pro;
Les résultats qui apparaissent sur ces commandes:
SQL Where
Une requête SQL peut être restreinte à l'aide de la condition Where. Par exemple, vous voulez chercher le service des produits qui sont Crédit individuel et commercial (Individual and Business Loans).
  • Product_Type_Cd = 'LOAN'.
Il faut requérir dans PRODUCT, où il y a Product_Type_Cd= 'LOAN'.
-- Querying the Product table to find the type of products:
-- "Individual and Business Loans".
-- Corresponding column: Product_Type_Cd = 'LOAN'.

Select * From Product Pro Where Pro.Product_Type_Cd = 'LOAN';
Les résultats de requête:
Un autre exemple utilise la commande where avec des conditions.
SQL And Or
Des opérateurs And et Or sont à ajoutés dans la condition where:
Par exemple, vous voulez faire une liste des employés dont la prénom commence par la lettre "S" et qui travaillent dans le département opérationnel (Operations).
-- Query the employee whose first name starts with S.
Select Emp.Emp_Id
     ,Emp.First_Name
     ,Emp.Last_Name
     ,Emp.Dept_Id
From   Employee Emp
Where  Emp.First_Name Like 'S%';

-- Query the employee whose first name starts with S.
-- and work in Operation department.  Dept_Id  = 1.

Select Emp.Emp_Id
     ,Emp.First_Name
     ,Emp.Last_Name
     ,Emp.Dept_Id
From   Employee Emp
Where  Emp.First_Name Like 'S%'
And    Emp.Dept_Id = 1;
Les résultats de requête:
Exemple:
-- Find the employees whose first name starts with S or P.
-- and work in Operation department.  Dept_Id  = 1.
Select Emp.Emp_Id
     ,Emp.First_Name
     ,Emp.Last_Name
     ,Emp.Dept_Id
From   Employee Emp
Where  (Emp.First_Name Like 'S%' Or Emp.First_Name Like 'P%')
And    Emp.Dept_Id = 1;
Les résulats de requête:
SQL IN
L'opérateur logique in s'utilise dans la commande where pour vérifier si une colonne est égale à une des valeurs comprise dans set de valeurs déterminées. Cet opérateur fonctionne avec toutes sortes des valeurs de la base de données.
-- This command searches the employee named
-- Susan or  Paula or Helen.

Select Emp.Emp_Id
     ,Emp.First_Name
     ,Emp.Last_Name
     ,Emp.Dept_Id
From   Employee Emp
Where  Emp.First_Name In ('Susan'
                        ,'Paula'
                        ,'Helen');
Les résultats de requête:
SQL Between
-- Find employees, with Emp_Id between 5 and 10.
Select Emp.Emp_Id
    ,Emp.First_Name
    ,Emp.Last_Name
    ,Emp.Start_Date
From   Employee Emp
Where  (Emp.Emp_Id Between 5 And 10);

-- The statement above is equivalent to:
Select Emp.Emp_Id
     ,Emp.First_Name
     ,Emp.Last_Name
     ,Emp.Start_Date
From   Employee Emp
Where  Emp.Emp_Id >= 5
And    Emp.Emp_Id <= 10;
Query Results:
L'opérateur BETWEEN est utilisé pour sélectionner un intervalle de données dans une requête utilisant where. Par exemple, vous cherchez des employés qui commencent à travailler dans un période de temps.
  • 03-05-2002 ==> 09-08-2002 (dd-MM-yyyy)
-- This statement helps find employees who have begun working for a period of time
-- specify it in where statement.
-- For example,  03-05-2002 ==> 09-08-2002  (Format: dd-MM-yyyy)
Select Emp.Emp_Id
     ,Emp.First_Name
     ,Emp.Last_Name
     ,Emp.Start_Date
     , -- Convert(Varchar, <Date>, 105) Function convert Date to varchar Varchar with DD-MM-YYYY format
      -- This is function of SQL Server (It may not exist in other DB).
      Convert(Varchar, Emp.Start_Date
             ,105) Start_Date_Vn
From   Employee Emp
Where
-- Convert(Datetime, <Varchar>, 105)  Function convert text with DD-MM-YYYY format to Datetime
-- (This is function of  SQLServer, (It may not exist in other DB))
( --
 Emp.Start_Date Between Convert(Datetime, '03-05-2002'
                               ,105) And
 Convert(Datetime,'09-08-2002'
        ,105) --
);
Query Result:
SQL Wildcard
Il y a 2 caractères spécials dans SQL:
  1. Le caractère %
  2. Le caractère _
Ses significations:
  • % est remplacé par 0, 1 ou tous les autres caractères.
  • _ est remplacé par un seul caractère uniquement.
Ces deux caractères sont généralement utilisés dans l'opérateur LIKE.
-- Find Customers whose FED_ID is formatted:
-- The initial part is random, following by -, then two any characters, then -, and the last part is any.
-- Use two dashes (_) for illustrating two characters.
-- (Each dash (_) is a unique character).


Select Cus.Cust_Id
     ,Cus.Fed_Id
     ,Cus.Address
From   Customer Cus
where cus.fed_id like '%-__-%';
Query Results:
SQL Like
Vous êtes déjà familier avec cette commande dans des exemples dessus.
SQL Order By
Une requête où l'ont souhaite filtrer des résultats, utiliser la commande Order by va permettre de trier les lignes dans cette requête.
-- Syntax:

SELECT "column_name"
FROM "table_name"
[WHERE "condition"]
ORDER BY "column_name1" [ASC, DESC], "column_name2" [ASC, DESC];

-- Note:
-- ASC: ascending (default)
-- DESC: descending order..
Exemple:
-- Arrange Product_Type_Cd in ascending order
-- Next, arrange Name in ascending order, too.

Select Pro.Product_Cd
     ,Pro.Product_Type_Cd
     ,Pro.Name
From   Product Pro
Order  By Pro.Product_Type_Cd Asc
        ,Pro.Name            Asc;
       
       

-- In Order BY, ASC is defaulted.
-- Thus, it is unnecessary to write ASC.

Select Pro.Product_Cd
     ,Pro.Product_Type_Cd
     ,Pro.Name
From   Product Pro
Order  By Pro.Product_Type_Cd
        ,Pro.Name;

-- Arrange Product_Type_Cd in descending order
-- Next, arrange Name in ascending order
Select Pro.Product_Cd
     ,Pro.Product_Type_Cd
     ,Pro.Name
From   Product Pro
Order  By Pro.Product_Type_Cd Desc
        ,Pro.Name            Asc;
Query Results:
La commande Order By se trouve toujours en arrière de la commande where.
-- Find the employees whose first name starts with S.
-- Sort descending by start date of work.

Select Emp.Emp_Id
     ,Emp.First_Name
     ,Emp.Last_Name
     ,Emp.Start_Date
From   Employee Emp
Where  Emp.First_Name Like 'S%'
Order  By Emp.Start_Date Desc;
Query Results:
OR:
-- Apply the order of column to Order by clause.
-- First_Name is the second column in Select clause.
-- Be able to use Order by 2 in lieu of Order by First_Name.

Select Emp.Emp_Id
    ,Emp.First_Name
    ,Emp.Last_Name
    ,Emp.Start_Date
From   Employee Emp
Order  By 2 Desc;
SQL Group By
D'abord, nous devons comprendre ce qui les fonctions d'agrégation sont:
  • Sum: la fonction calcule la somme sur un ensemble d'enregistrement
  • Avg: la fonction calcule la moyenne sur un ensemble d'enregistrement
  • Count: la fonctioncompte le nombre d'enregistrement
  • Min: la fonction récupère la valeur minumum
  • Max: la fonction récupère la valeur maximum
Elles sont les fonctions d'agrégation courantes. Tous ces fonctions prennent tout leur sens lorsqu'elles sont utilisées avec la commande Group by.
-- Query Account table.

Select Acc.Account_Id
     ,Acc.Product_Cd
     ,Acc.Avail_Balance
     ,Acc.Pending_Balance
From   Account Acc;
La question qui se pose est que vous voulez voir la somme de l'argent dans le compte, par rapport à chaque catégorie de différents services (Product_Cd). Ca veut dire que vous avez besoin de grouper dans Product_Cd.
Select Acc.Product_Cd
     ,Count(Acc.Product_Cd) As Count_Acc
     ,Sum(Acc.Avail_Balance) As Sum_Avail_Balance
     ,Avg(Acc.Avail_Balance) As Avg_Avail_Balance
From   Account Acc
Group  By Acc.Product_Cd;
Results:
Donc, vous avez une évaluation sur:
  • Il y a 4 comptes qui prennent part au service du "Compte d'épargne"(SAV) avec le somme totale atteinte à 1855.76 et chaque compte contient 463.94 en moyen
  • ...
SQL Having
La condition HAVING vous permet d'indiquer des condition de sélection pour filtrer des groupes des résultats.

La commande WHERE met en oeuvre des conditions dans des colonnes sélectionnées, alors que la commande HAVING met en oeuvre des conditions les groupes qui sont créés par l'opérateur GROUP BY.
Supposons que vous voudriez grouper des catégories du service (Product_Cd) dans la table Account et qu'ils n'affichent que les catégories ayant plus de 3 (> 3) participants.
Select Acc.Product_Cd
     ,Count(Acc.Product_Cd) As Count_Acc
     ,Sum(Acc.Avail_Balance) As Sum_Avail_Balance 
     ,Avg(Acc.Avail_Balance) As Avg_Avail_Balance 
From   Account Acc
Group  By Acc.Product_Cd
Having Count(Acc.Product_Cd) > 3;
Query Results:
La distinction entre Where et Having
Vous devez differencier entre Where et Having dans la même commande.
  • Where est une commande utilisée à filtrer la base de données devant du groupe (Group)
  • Having est une commande usagée à filtrer la base de données après du groupe (Group)
Si vous voulez obtenir des informations générales d'une succursale de la banque (BRANCH Table), vous pouvez user la commande where afin de filtrer la base de données avant de group.
Select Acc.Product_Cd
     ,Count(Acc.Product_Cd) As Count_Acc
     ,Sum(Acc.Avail_Balance) As Sum_Avail_Balance
     ,Avg(Acc.Avail_Balance) As Avg_Avail_Balance
From   Account Acc

-- Using WHERE to filter data before group
Where  Acc.Open_Branch_Id = 1
Group  By Acc.Product_Cd
-- Using HAVING to filter data after group
Having Count(Acc.Product_Cd) > 1;
Query Results:

5. Các câu lệnh trèn dữ liệu (Insert)

SQL Insert Into
Syntaxe:
-- Syntax of Insert Into:

INSERT INTO "table_name" ("column1", "column2", ...)
VALUES ("value1", "value2", ...);
Par exemple,vous insérez une transaction du client dans la table ACC_TRANSACTION:
-- Insert a record in Acc_Transaction table
-- numeric value is automatically generated for Txn_ID.
-- Current_Timestamp is function of SQL Server, return system datetime
-- Current_Timestamp : System datetime

Insert Into Acc_Transaction
  (Amount
  ,Funds_Avail_Date
  ,Txn_Date
  ,Txn_Type_Cd
  ,Account_Id
  ,Execution_Branch_Id
  ,Teller_Emp_Id)
Values
  (100 -- Amount
  ,Current_Timestamp -- Funds_Avail_Date
  ,Current_Timestamp -- Txn_Date
  ,'CDT' -- Txn_Type_Cd
  ,2 -- Account_Id
  ,Null -- Execution_Branch_Id
  ,Null -- Teller_Emp_Id
   );
SQL Insert Into Select
Vous pouvez utiliser la condition Select afin de fournir la base de données dans la commande Insert. En utilisant la commande Insert Into ... Select:
-- Syntax of INSERT INTO .. SELECT

INSERT INTO "table1" ("column1", "column2", ...)
SELECT "column3", "column4", ...
FROM "table2";
Exemple:
-- Insert multi record in Acc_Transaction table
-- Use Select statement to provide data.
-- numeric value is automatically generated for Txn_ID.

Insert Into Acc_Transaction
( Txn_Date
,Account_Id
,Txn_Type_Cd
,Amount
,Funds_Avail_Date)
Select Acc.Open_Date -- Txn_Date
      ,Acc.Account_Id -- Account_Id
      ,'CDT' -- Txn_Type_Cd
      ,200 -- Amount
      ,Acc.Open_Date -- Funds_Avail_Date
From   Account Acc
Where  Acc.Product_Cd = 'CD';

6. Câu lệnh cập nhập (Update)

-- Syntax of Update:

UPDATE "table_name"
SET "column_1" = "new value 1", "column_2"= "new value 2"
WHERE "condition";
Si vous voulez mettre à jour et augmenter la somme d'argent dans le compte du client, utilisez CUST_ID = 1 à 2%.
La commande Update:
-- Update, increase the amount of money in customers' account with CUST_ID = 1 by 2%.

Update Account
Set    Avail_Balance   = Avail_Balance + 2 * Avail_Balance / 100
     ,Pending_Balance = Pending_Balance + 2 * Pending_Balance / 100
Where  Cust_Id = 1;
Requérez, après Update.

7. Câu lệnh xóa dữ liệu (Delete)

La synthèse de supprimer de la bases de données dans la table.
-- Delete two records in the Acc_Transaction table

DELETE FROM "table_name"
WHERE "condition";
-- Delete two records in the Acc_Transaction table

Delete From Acc_Transaction
Where Txn_Id In (25
                   ,26);

8. SQL Functions

SQL Count
La fonction Count() permet de compter le nombre de ligns en correspondants des critères spécifiques dans Query.En généralement,en terme de performance il est plustôt conseillé de filtrer les lignes avec Group by.
-- Count the number of rows in the Account table

Select Count(Acc.Account_Id) As Count_Acc From Account Acc;
Comptez le nombre des comptes qui effectuent la transaction bancaire (Table Acc_Transaction)
-- Count the number of accounts having transaction with the bank

Select Count(distinct txn.Account_id) as Distinct_Acc From Acc_Transaction txn;
Group by
Un client peut ouvrir plusieurs comptes bancaires. Chaque compte est équivalent à un produit (service) de la banque.
Vous voulez énumérer les clients (CUST_ID) et ses comptes.
-- Count the number of accounts opened for each customer....

Select Acc.Cust_Id
     ,Count(Acc.Account_Id) As Count_Acc
From   Account Acc
Group  By Acc.Cust_Id;
SQL Sum
La fonction d’agrégation SUM() permet de calculer la somme totale d’une colonne contenant des valeurs numériques.
-- Syntax:

SELECT SUM("column_name")
FROM "table_name";
Exemple:
-- Find the sum of the money in customers' accounts with CUST_ID = = 1
Select Sum(Acc.Avail_Balance)  As Sum_Avail_Balance
From Account Acc Where Acc.Cust_Id = 1;


-- Use Group by.
-- Find the sum of the money in accounts owned by each customer.
Select Acc.Cust_Id
    ,Sum(Acc.Avail_Balance) As Sum_Avail_Balance
From   Account Acc
Group  By Acc.Cust_Id;
SQL AVG
La fonction d’agrégation AVG() permet de calculer une valeur moyenne sur un ensemble d’enregistrement.
-- Syntax:

SELECT AVG("column_name")
FROM "table_name";
Example
-- Find the average of money equivalent to each type of deposit.

Select Avg(Acc.Avail_Balance)  As Avg_Avail_Balance
From   Account Acc
Where  Acc.Product_Cd = 'SAV';



-- Use Group by.
-- A customer can own one or more account.
-- Find the average of money in each account owned by each customer
-- (In the bank with Branch_ID = 1)
Select Acc.Cust_Id
    ,Avg(Acc.Avail_Balance) As Avg_Avail_Balance
From   Account Acc
Where  Acc.Open_Branch_Id = 1
Group  By Acc.Cust_Id;
SQL MIN
La fonction Min() de SQL permet de retourner la plus petite valeur d’une colonne.
-- Syntax:

SELECT MIN ("column_name")
FROM "table_name";
Example:
-- Find the minimum amount of deposit.
Select Min(Acc.Avail_Balance) As Min_Avail_Balance
From   Account Acc
Where  Acc.Product_Cd = 'SAV';



-- Use Group by.
-- A customer can own one or more account.
-- Accounts can be opened in different branches.
-- Find the amount in the account, minimum for each branch

Select Acc.Open_Branch_Id
     ,Min(Acc.Avail_Balance) As Min_Avail_Balance
From   Account Acc
Group  By Acc.Open_Branch_Id;
SQL MAX
La fonction MAX() permet de récupérer la valeur maximum d’une colonne sur un ensemble de ligne, de la même manière que MIN. Vous pouvez donc faire la référence dans les exemples de MIN.
-- Syntax:

SELECT MAX("column_name")
FROM "table_name";

9. SQL Join

Par exemple, vous voulez voir des informations d'un(e) employé(e) dans la table EMPLOYEE. Vous pouvez chercher un(e) employé(e) que vous savez son département ID. Mais c'est seulement un numéro insensé. Pour trouver le département, il est néssaire de chercher dans la table DEPARTEMENT. Le fait d’associer plusieurs tables dans une même requête pour obtenir des résultats complets est des jointures en SQL.
Il y a plusieurs méthodes pour associer 2 tables ensemble. Voici la liste de 4 différentes techniques qui sont utilisées :
  • INNER JOIN (JOIN)
  • LEFT OUTER JOIN (LEFT JOIN)
  • RIGHT OUTER JOIN (RIGHT JOIN)
  • FULL OUTER JOIN (OUTER JOIN)
  • CROSS JOIN
INNER JOIN (or JOIN)
Le mot- clé INNER JOIN permet de retourner les enregistrements lorsqu’il y a au moins une ligne dans chaque colonne qui correspond à la condition.
Syntaxe:
-- Syntax:

SELECT column_name(s)
FROM table1
INNER JOIN table2
ON table1.column_name=table2.column_name;


-- INNER JOIN can replaced by JOIN
-- Same Meaning, and result.

SELECT column_name(s)
FROM table1
JOIN table2
ON table1.column_name=table2.column_name;
Example:
-- INNER JOIN 2 table: EMPLOYEE and DEPARTMENT.

Select Emp.Emp_Id
     ,Emp.First_Name
     ,Emp.Last_Name
     ,Emp.Dept_Id
     ,Dep.Name Dept_Name
From   Employee Emp
Inner  Join Department Dep
On     Emp.Dept_Id = Dep.Dept_Id
Order  By Emp.Emp_Id;
Syntaxe propre de SQLServer:
-- Other SQL Server syntax to join two tables:

Select Emp.Emp_Id
   ,Emp.First_Name
   ,Emp.Last_Name
   ,Emp.Dept_Id
   ,Dep.Name Dept_Name
From   Employee   Emp
   ,Department Dep
Where  Emp.Dept_Id = Dep.Dept_Id
Order  By Emp.Emp_Id;
LEFT OUTER JOIN (or LEFT JOIN)
La mot-clé LEFT OUTER JOIN est une jointure externe pour récupérer les informations de la table de gauche( table1) tout en récupérant les données associées avec la table de droite (table 2). S’il n’y a pas de correspondance les colonnes de la table de droite (table 2) vaudront toutes NULL.
Observez l'illustration suivant:
Exemple:
-- Customer LEFT OUTER JOIN Officer
-- LEFT OUTER JOIN Can be replaced by LEFT JOIN (meaning, and the result is the same)

Select Cus.Cust_Id
     ,Cus.Fed_Id
     ,Cus.State
     ,Ofc.Cust_Id As Ofc_Cust_Id
     ,Ofc.Officer_Id
     ,Ofc.Start_Date
     ,Ofc.Title
From   Customer Cus  -- Table1
Left   Outer Join Officer Ofc  -- Table2
On     Cus.Cust_Id = Ofc.Cust_Id;
Résultat:
RIGHT OUTER JOIN (or RIGHT JOIN)
L'utilisation de la commande RIGHT OUTER JOIN est assez similaire à celle de LEFT OUTER JOIN:
FULL OUTER JOIN (or OUTER JOIN)
La commande FULL OUTER JOIN est la combinaison de la commande LEFT OUTER JOIN et la commande RIGHT OUTER JOIN
-- Syntax:  (FULL OUTER JOIN)
-- Or: FULL JOIN

SELECT columns
FROM table1
FULL [OUTER] JOIN table2
ON table1.column = table2.column;

10. Câu truy vấn con (Subquery)

Dans le langage SQL, une sous-requête consiste à exécuter une requête à l’intérieur d’une autre requête. Une sous-requête dans la commande SQL est souvent utilisée au sein d’une clause WHERE, la clause FROM ou la clause SELECT.
Subquery in the Where clause
Des sous-requête se trouvent assez fréquemment dans la clause WHERE. Ces sous requête est également appelée des requêtes imbriquées.
Select Acc.Account_Id
     ,Acc.Open_Date
     ,Acc.Product_Cd
     ,Acc.Avail_Balance
From   Account Acc
Where  Acc.Cust_Id In
      (Select Cus.Cust_Id From Customer Cus Where Cus.Cust_Type_Cd = 'B')
Subquery in the From clause
Une sous requête est également trouvée dans la clause FROM. Elle s'appelle inline views.
Select Cus.Cust_Id
     ,Cus.Address
     ,Cus.Fed_Id
     ,Acc2.Sum_Avail_Balance
From   Customer Cus
     , -- Define a inline view.
      (Select Acc.Cust_Id
             ,Sum(Acc.Avail_Balance) As Sum_Avail_Balance
       From   Account Acc
       Group  By Acc.Cust_Id) Acc2
Where  Cus.Cust_Id = Acc2.Cust_Id;
Subquery in the Select clause
Une sous requête est ainsi trouvée dans la clause SELECT.
Select Cus.Cust_Id
     ,Cus.Address
     ,Cus.Fed_Id
     ,(Select Sum(Acc.Avail_Balance)
       From   Account Acc
       Where  Acc.Cust_Id = Cus.Cust_Id) As Sum_Avail_Balance
From   Customer Cus;
L'artifice de mettre une sous-requête dans la clause select est que cette sous- requête doit rendre un seul résultat uniquement. Ca explique la raison pour laquelle des fonctions d'agrégation comme la fonction SUM, COUNT, MIN ou MAX sont souvent usées dans la sous-requête.

11. Tutoriel de programmation SQL Server Transact-SQL

Si vous voulez faire la référence des vocabulaires de Transact-SQL de SQL Server, veuillez consulter à: