Aide-mémoire SQL : Guide rapide des commandes essentielles

En tant que programmeur ou analyste de données, vous vous retrouverez souvent à travailler avec de gros volumes de données. L'un des outils les plus puissants à votre disposition est SQL (Structured Query Language).

Cette aide-mémoire SQL vous donne les objets et commandes SQL les plus courants, y compris les types de données, les instructions DML et DDL, les fonctions d'agrégation, les fonctions de chaîne et de date et les sous-requêtes.

Il est conçu pour être une référence rapide et pratique que vous pouvez consulter chaque fois que vous interagissez avec une base de données relationnelle.

Si vous êtes comme nous et que vous souhaitez télécharger et imprimer ou stocker la feuille de triche sur votre ordinateur, vous pouvez la télécharger ci-dessous.

Télécharger la feuille de triche SQL

Table des matières

• Types de données SQL
  • 1. Types numériques
  • 2. Types de date et d'heure
  • 3. Types de chaîne
• Instruction SELECT
• Clause OÙ
• Clause ORDRE PAR
• Joindre plusieurs tables en SQL
  • 1. JOINT INTERNE
  • 2. JOINT GAUCHE
  • 3. JOINDRE À DROITE
  • 4. JOINT COMPLET
• Fonctions d'agrégation SQL
  • 1. Fonction COMPTER
  • 2. Fonction SOMME
  • 3. Fonction AVG
  • 4. Fonction MAX
  • 5. Fonction MIN
• Fonctions de chaîne courantes
• Fonctions numériques courantes
• Fonctions de date courantes
• GROUPER PAR Et AYANT
  • 1. Grouper par clause
  • 2. Avoir une clause
  • Astuces rapides
• Sous-requêtes
  • 1. Opérateur IN
  • 2. Opérateur EXISTE
  • 3. TOUT Opérateur
  • 4. TOUS Opérateur
• Manipulation de données (LMD)
  • 1. INSÉRER la déclaration
  • 2. Déclaration de mise à jour
  • 3. DELETE Déclaration
• Gestion de base de données avec DDL
  • 1. CRÉER une déclaration
  • 2. Déclaration ALTER
    • AJOUTER UNE NOUVELLE COLONNE
    • Modifier le type de données d'une colonne
    • Déposer une colonne
    • Ajouter une contrainte unique
    • Ajouter une clé étrangère entre les tables
  • 3. Déclaration d'abandon
• Transactions
  • 1. COMMENCER
  • 2. ENGAGEZ-VOUS
  • 3. RETOUR EN ARRIÈRE
• Dernières pensées

Types de données SQL

Les types de données pour des systèmes de gestion de base de données spécifiques (SGBD) peuvent varier (par exemple, Microsoft SQL Server vs MySQL ). Cependant, il y en a plusieurs que l'on trouve sur la plupart des systèmes. Vous pouvez les diviser en trois catégories :

1. Numérique

2. Date et l'heure

3. Chaîne

1. Types numériques

Voici les types numériques les plus courants :

• INTEGER : Un nombre entier sans point décimal.

• SMALLINT : Une plus petite plage de nombres entiers

• BIGINT : Une plus grande plage de nombres entiers.

• DECIMAL(p, s) ou NUMERIC(p, s) : Par exemple, un decimal(5,2) correspondrait à 123,45.

• REAL : Un nombre à virgule flottante, avec une précision d'au moins 6 chiffres décimaux.

• FLOAT(n) : Un nombre à virgule flottante, avec une précision d'au moins n chiffres.

2. Types de date et d'heure

• DATE : une valeur de date, généralement au format "AAAA-MM-JJ".

• TIME : Une valeur de temps, généralement au format 'HH:MM:SS'.

• DATETIME ou TIMESTAMP : Une combinaison de valeurs de date et d'heure.

3. Types de chaîne

• CHAR(n) : Une chaîne de longueur fixe avec n caractères.

• VARCHAR(n) ou CHARACTER VARYING(n) : Une chaîne de longueur variable.

• TEXT : Une chaîne de longueur variable avec une longueur maximale déterminée par le SGBD.

Instruction SELECT

L'instruction SELECT est utilisée pour récupérer des données d'une ou plusieurs tables. Vous pouvez spécifier les colonnes que vous souhaitez récupérer et à partir de quelle table. Une instruction SELECT de base ressemble à ceci :

SELECT column1, column2
FROM table;

Pour récupérer tous les enregistrements des colonnes 'name' et 'country_id' de la table 'city', votre requête SQL ressemble à ceci :

SELECT name, country_id
FROM city;

Clause OÙ

La clause WHERE vous permet de filtrer les résultats d'une instruction SELECT en fonction de conditions spécifiques.

SELECT column1, column2
FROM table
WHERE condition;

Pour récupérer les enregistrements de la table "ville" où la "population" est supérieure à 1 000 000, votre requête ressemble à ceci :

SELECT name, population
FROM city
WHERE population > 1000000;

Clause ORDRE PAR

La clause ORDER BY vous permet de trier les résultats d'une instruction SELECT sur une ou plusieurs colonnes. Vous pouvez trier les résultats par ordre croissant (ASC) ou décroissant (DESC) :

SELECT column1, column2
FROM table
ORDER BY column1 ASC, column2 DESC;

Par exemple, pour récupérer des enregistrements de la table 'ville' triés par 'population' dans l'ordre décroissant, votre requête ressemble à ceci :

SELECT name, population
FROM city
ORDER BY population DESC;

Joindre plusieurs tables en SQL

Il existe quatre jointures couramment utilisées en SQL :

1. JOINTURE INTERNE

2. JOINT GAUCHE

3. JOINDRE À DROITE

4. JOINT COMPLET

1. JOINT INTERNE

Un INNER JOIN récupère les enregistrements qui ont des valeurs correspondantes dans les deux tables.

Prenons un exemple d'une base de données d'artistes et d'albums, et vous voulez trouver toutes les combinaisons d'artistes et d'albums. C'est la JOINTURE INTERNE :

SELECT *
FROM artists AS a
INNER JOIN albums AS b
ON a.artist_id = b.artist_id;

Avec un INNER JOIN, seules les lignes avec des valeurs correspondantes dans les champs spécifiés seront renvoyées dans les résultats.

2. JOINT GAUCHE

Une LEFT JOIN est également connue sous le nom de LEFT OUTER JOIN. Il renvoie tous les enregistrements de la table de gauche et les enregistrements correspondants de la table de droite. S'il n'y a pas de correspondance dans la bonne table, le résultat contiendra des valeurs NULL.

Par exemple, pour obtenir une liste de tous les artistes et de leurs albums respectifs (s'ils en ont), vous pouvez utiliser un LEFT JOIN :

SELECT *
FROM artists AS a
LEFT JOIN albums AS b
ON a.artist_id = b.artist_id;

Cette requête renverra tous les artistes, même s'ils ne sont associés à aucun album dans la table des albums.

3. JOINDRE À DROITE

Une JOINTURE DROITE est également connue sous le nom de JOINTURE EXTÉRIEURE DROITE. Il renvoie tous les enregistrements de la table de droite et les enregistrements correspondants de la table de gauche. S'il n'y a pas de correspondance dans la table de gauche, le résultat contiendra des valeurs NULL.

Par exemple, pour obtenir des informations sur tous les albums et leurs artistes associés (s'ils existent), vous utiliserez un RIGHT JOIN :

SELECT *
FROM artists AS a
RIGHT JOIN albums AS b
ON a.artist_id = b.artist_id;

Cette requête renverra tous les albums, même s'ils n'ont pas d'artistes associés dans la table des artistes.

4. JOINT COMPLET

Une FULL JOIN est également connue sous le nom de FULL OUTER JOIN. Il combine les résultats des jointures LEFT et RIGHT. En d'autres termes, il renvoie toutes les lignes des tables de gauche et de droite et remplit les valeurs manquantes avec des valeurs NULL lorsqu'il n'y a pas de correspondance.

Voici un exemple utilisant les tableaux artistes et albums :

SELECT *
FROM artists AS a
FULL JOIN albums AS b
ON a.artist_id = b.artist_id;

Cette requête renvoie toutes les lignes des deux tables, en remplissant les valeurs NULL là où il n'y a pas de correspondance dans l'une ou l'autre des tables.

Fonctions d'agrégation SQL

Les fonctions d'agrégat sont utilisées pour calculer un seul résultat à partir d'un ensemble de valeurs d'entrée. Ils sont appelés « agrégats » car ils prennent plusieurs entrées et renvoient une seule sortie. Les plus courants sont :

1. COMPTER

2. SOMME

3. MOY

4. MAX

5. MIN

1. Fonction COMPTER

La fonction COUNT vous permet de compter le nombre de lignes dans un résultat de requête. Vous pouvez utiliser cette fonction d'agrégation pour déterminer le nombre total d'enregistrements dans une table ou le nombre d'enregistrements correspondant à des critères spécifiques.

Voici un exemple :

SELECT COUNT(*) FROM employees;

Cette requête retournera le nombre total d'employés dans la table 'employes'. Gardez à l'esprit que l'ajout d'une clause WHERE peut affiner vos résultats :

SELECT COUNT(*) FROM employees WHERE department = 'HR';

2. Fonction SOMME

The SUM function calculates the total sum of a numeric column. It’s useful when you need to calculate the total value of a particular numeric field. For example, this query returns the total sum of all employee salaries:

SELECT SUM(salary) FROM employees;

3. AVG Function

The AVG function computes the average value of a numeric column. This function is helpful when you want to find the average of a particular numeric field. For instance, this query returns the average salary of all employees:

SELECT AVG(salary) FROM employees;

4. MAX Function

The MAX function finds the maximum value of a column. This is often used to find the highest value in a numeric field or the most recent date in a datetime field. For example, this query returns the highest salary:

SELECT MAX(salary) FROM employees;

5. MIN Function

Lastly, the MIN function helps you find the minimum value of a column. For example, this query returns the lowest salary:

SELECT MIN(salary) FROM employees;

Remember, you can use WHERE clauses in these queries and JOIN with multiple tables.

Common String Functions

Here are the most common string functions that are found in most SQL dialects (the exact syntax can vary):

1. LEN or LENGTH(string): Returns the length of a string.

2. UPPER(string): Converts a string to upper case.

3. LOWER(string): Converts a string to lower case.

4. SUBSTR or SUBSTRING(string, start, length): Extracts a portion from a string.

5. TRIM(string): Removes leading and trailing spaces from a string.

6. LTRIM(string): Removes leading spaces from a string.

7. RTRIM(string): Removes trailing spaces from a string.

Common Numeric Functions

Here are the most common numeric functions that are found in most SQL dialects (the exact syntax can vary):

1. ABS(number): Returns the absolute value of a number.

2. ROUND(number, decimal_places): Rounds a number to a certain number of decimal places.

3. FLOOR(number): Rounds down the number to the nearest integer.

4. CEIL or CEILING(number): Rounds up the number to the nearest integer.

5. RAND(): Returns a random float value from 0 to 1.

6. MOD(n, m): Returns the remainder of n divided by m.

7. POWER(base, exponent): Raises a number to the power of another number.

8. LOG(number): Returns the natural logarithm of a number.

Common Date Functions

Here are the most common date functions that are found in most SQL dialects (the exact syntax can vary):

1. NOW(): Returns the current date and time.

2. DATE(datetime): Extracts the date part of a date or datetime expression.

3. TIME(datetime): Extracts the time part of a date or datetime expression.

4. YEAR(date): Returns the year part.

5. MONTH(date): Returns the month part.

6. DAY(date): Returns the day of the month part.

7. HOUR(time): Returns the hour part from a time.

8. MINUTE(time): Returns the minute part from a time.

9. SECOND(time): Returns the second part from a time.

GROUP BY And HAVING

When working with SQL queries, you may want to further summarize and filter your aggregated data. The GROUP BY and HAVING clauses provide this functionality.

1. Group By Clause

The GROUP BY clause allows you to group rows that share the same values in specified columns. It is commonly used with aggregate functions. This is the syntax:

SELECT column1, column2, aggregate_function(column3)
FROM table_name
WHERE condition
GROUP BY column1, column2;

For example, if you want to calculate the total sales amount for each product category, this is the query:

SELECT product_category, SUM(sales_amount)
FROM sales_data
GROUP BY product_category;

TIP: Combining GROUP BY and COUNT is a good way of finding duplicate values.

2. Having Clause

If you want to filter the aggregated results further, you can use the HAVING clause. The syntax is:

SELECT column1, column2, aggregate_function(column3)
FROM table_name
WHERE condition
GROUP BY column1, column2
HAVING condition;

If you want to find product categories with total sales of more than $1,000,000, you would write:

SELECT product_category, SUM(sales_amount)
FROM sales_data
GROUP BY product_category
HAVING SUM(sales_amount) > 1000000;

Quick Tips

• Always use the GROUP BY clause before the HAVING clause.

• The SELECT statement can only contain specified column names, aggregate functions, constants, and expressions.

• When using the HAVING clause, filter conditions should be applied to the aggregate functions rather than directly to the grouped columns.

By understanding and properly applying the GROUP BY and HAVING clauses, you can better organize and analyze your data using SQL.

Subqueries

A subquery is also known as an inner or nested query. This is a query embedded within another SQL statement (such as a SELECT statement) or even inside another subquery.

Subqueries allow you to retrieve data based on the output of another query. The most common operators used with subqueries are:

1. IN

2. EXISTS

3. ANY

4. ALL

1. IN Operator

The IN operator tests if a value is within a set of values generated by the inner query. The syntax for using the IN operator with a subquery is as follows:

SELECT column_name(s)
FROM table_name
WHERE column_name IN (SELECT column_name FROM other_table);

This returns rows from the outer query where the specified column value matches any of the values provided by the subquery.

Suppose you have an employee table and a departments table. You want to find employees who work in departments based at the head office. Here is a sample query

SELECT first_name, last_name
FROM employee
WHERE department IN (SELECT department FROM departments
                     WHERE location = "HQ");

For a more in-depth look, check out our article on the SQL WHERE IN syntax.

2. EXISTS Operator

The EXISTS operator checks if there is at least one row resulting from the subquery. You can use the EXISTS operator to filter rows based on the existence of related data in another table. This is the syntax:

SELECT column_name(s)
FROM table_name
WHERE EXISTS (SELECT column_name FROM other_table WHERE condition);

When the subquery returns at least one row, the EXISTS operator returns true, and the relevant rows from the outer query are included in the result.

3. ANY Operator

The ANY operator is used to compare a value to any value in a set of values provided by a subquery. It’s commonly used with comparison operators like =, <, >, <=, or >=.

This is the syntax:

SELECT column_name(s)
FROM table_name
WHERE column_name operator ANY (SELECT column_name FROM other_table WHERE condition);

This will return rows from the outer query where the specified column value meets the condition against any value from the subquery.

4. ALL Operator

The ALL operator compares a value to all values within a set of values provided by a subquery. The conditions must be true for every value in the subquery’s result. This is the syntax:

SELECT column_name(s)
FROM table_name
WHERE column_name operator ALL (SELECT column_name FROM other_table WHERE condition);

This returns rows from the outer query only if the specified column value satisfies the condition against all values in the subquery’s output.

Data Manipulation (DML)

Data Manipulation Language (DML) is a sub-language within SQL for managing and updating data. The most common statements are:

1. INSERT

2. UPDATE

3. DELETE

1. INSERT Statement

The INSERT statement allows you to insert rows into a table. Here’s the basic syntax:

INSERT INTO table_name (column1, column2, column3, ...)
VALUES (value1, value2, value3, ...);

For example, if you want to insert a new row into a ‘users’ table with columns ‘id’, ‘name’, and ’email’, you would use the following query:

INSERT INTO users (id, name, email)
VALUES (1, 'John Doe', '[email protected]');

2. UPDATE Statement

The UPDATE statement allows you to modify existing row data in a table. This is the syntax:

UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE condition;

For example, if you want to update the email address of a user with the id ‘1’ in the ‘users’ table, your query would look like this:

UPDATE users
SET email = '[email protected]'
WHERE id = 1;

TIP: remember to include a WHERE clause to avoid updating all rows in the table by mistake.

3. DELETE Statement

The DELETE statement allows you to remove rows from a table. Here’s the syntax:

DELETE FROM table_name
WHERE condition;

Par exemple, si vous souhaitez supprimer un utilisateur avec l'identifiant '1' de la table 'users', votre requête ressemblera à ceci :

DELETE FROM users
WHERE id = 1;

ASTUCE : incluez toujours une clause WHERE pour spécifier les lignes à supprimer et éviter de supprimer toutes les lignes de la table.

Gestion de base de données avec DDL

Le langage de définition de données (DDL) est le sous-langage SQL utilisé pour créer et modifier des tables et la base de données elle-même. Les instructions DDL les plus courantes sont :

1. CRÉER

2. MODIFIER

3. GOUTTE

1. CRÉER une déclaration

L'instruction CREATE vous permet de créer de nouveaux objets de base de données, tels que de nouvelles tables, vues ou index. Lors de la création d'une nouvelle table, vous devez définir les colonnes, leurs types de données et toutes les contraintes.

Voici un exemple de création d'une table de commandes :

CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    product VARCHAR(255) NOT NULL,
    customer_id INT NOT NULL
);

ASTUCE : choisissez les types de données et les contraintes appropriés pour garantir l'intégrité des données dans vos tables.

Pour un aperçu plus détaillé, consultez notre article sur les opérations de table SQL de base .

2. Déclaration ALTER

L'instruction ALTER vous aide à modifier les objets de base de données existants. Les utilisations courantes incluent :

• ajouter, modifier ou supprimer des colonnes.

• ajouter ou supprimer des contraintes d'une table existante.

• ajouter des clés primaires et étrangères.

AJOUTER UNE NOUVELLE COLONNE

ALTER TABLE users ADD COLUMN age INTEGER;

Modifier le type de données d'une colonne

ALTER TABLE users ALTER COLUMN age TYPE FLOAT;

Déposer une colonne

ALTER TABLE users DROP COLUMN age;

Ajouter une contrainte unique

ALTER TABLE users ADD CONSTRAINT users_email_unique UNIQUE(email);

Ajouter une clé étrangère entre les tables

ALTER TABLE users ADD FOREIGN KEY (country_id) REFERENCES Country(country_id);

3. Déclaration d'abandon

L'instruction DROP vous permet de supprimer des objets de base de données tels que des tables, des vues ou des index. Utilisez-le avec prudence, car il supprimera définitivement l'objet spécifié et toutes ses données.

Voici un exemple :

DROP TABLE users;

ASTUCE : Assurez-vous que les sauvegardes appropriées sont en place avant d'exécuter une instruction DROP.

Si vous souhaitez en savoir plus sur la modélisation des données, regardez cette vidéo :

Transactions

Les transactions jouent un rôle crucial dans le maintien de l'intégrité de la base de données , en particulier lorsque plusieurs opérations connexes sont exécutées simultanément. Il existe trois opérations fondamentales dans le traitement des transactions :

1. COMMENCER

2. COMMETTRE

3. RETOUR EN ARRIERE

1. COMMENCER

L'instruction BEGIN signifie le début d'une transaction. Lors de l'exécution de cette commande, vous établissez un point de départ pour votre ensemble d'instructions SQL.

BEGIN;

2. ENGAGEZ-VOUS

Pour finaliser vos modifications et les conserver dans la base de données, utilisez l'instruction COMMIT. Cela garantit que toutes les opérations de la transaction sont exécutées avec succès et de manière permanente.

COMMIT;

Voici un exemple de transaction complète utilisant l'exemple classique de transfert de fonds entre comptes :

BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
UPDATE accounts SET balance = balance + 100 WHERE id = 2;
COMMIT;

3. RETOUR EN ARRIÈRE

Lorsque vous travaillez avec des transactions, il est également essentiel de savoir comment annuler les modifications lorsqu'une erreur se produit. L'instruction ROLLBACK annule toutes les modifications apportées depuis le début de la transaction :

ROLLBACK;

Voici un exemple de transaction avec gestion des erreurs à l'aide de ROLLBACK :

BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
UPDATE accounts SET balance = balance + 100 WHERE id = 2;
IF @@ERROR <> 0
    ROLLBACK;
ELSE
    COMMIT;

Dernières pensées

Comme vous l'avez vu dans cet aide-mémoire SQL, SQL offre une multitude de commandes et de fonctions qui vous permettent de créer, de manipuler et d'interroger des données dans une base de données relationnelle.

Des commandes fondamentales telles que SELECT, INSERT, UPDATE et DELETE aux constructions plus complexes telles que les JOIN et les sous-requêtes, en passant par les fonctions d'agrégation que nous avons couvertes, SQL offre la flexibilité nécessaire pour gérer un large éventail de tâches de données.

Revenez à cette feuille de triche pour accélérer votre voyage vers l'apprentissage de SQL !