SQL est un langage pour faire fonctionner les bases de données; il inclut la création de base de données, la suppression, l'extraction de lignes, la modification de lignes, etc. SQL est unANSI (American National Standards Institute), mais il existe de nombreuses versions différentes du langage SQL.

Qu'est-ce que SQL?

SQL est un langage de requête structuré, qui est un langage informatique pour stocker, manipuler et récupérer des données stockées dans une base de données relationnelle.

SQL est le langage standard pour Relational Database System. Tous les systèmes de gestion de base de données relationnelle (RDMS) comme MySQL, MS Access, Oracle, Sybase, Informix, Postgres et SQL Server utilisent SQL comme langage de base de données standard.

En outre, ils utilisent différents dialectes, tels que -

• MS SQL Server utilisant T-SQL,
• Oracle utilisant PL / SQL,
• La version MS Access de SQL est appelée JET SQL (format natif), etc.

Pourquoi SQL?

SQL est très populaire car il offre les avantages suivants -

• Permet aux utilisateurs d'accéder aux données dans les systèmes de gestion de base de données relationnelle.

• Permet aux utilisateurs de décrire les données.

• Permet aux utilisateurs de définir les données dans une base de données et de manipuler ces données.

• Permet de s'intégrer dans d'autres langages en utilisant des modules SQL, des bibliothèques et des pré-compilateurs.

• Permet aux utilisateurs de créer et de supprimer des bases de données et des tables.

• Permet aux utilisateurs de créer une vue, une procédure stockée, des fonctions dans une base de données.

• Permet aux utilisateurs de définir des autorisations sur les tables, les procédures et les vues.

Une brève histoire de SQL

• 1970- Dr. Edgar F. "Ted" Codd d'IBM est connu comme le père des bases de données relationnelles. Il a décrit un modèle relationnel pour les bases de données.

• 1974 - Le langage de requête structuré est apparu.

• 1978 - IBM a travaillé pour développer les idées de Codd et a publié un produit nommé System / R.

• 1986- IBM a développé le premier prototype de base de données relationnelle et normalisé par l'ANSI. La première base de données relationnelle a été publiée par Relational Software qui est devenu plus tard connu sous le nom d'Oracle.

Processus SQL

Lorsque vous exécutez une commande SQL pour un SGBDR, le système détermine la meilleure façon d'exécuter votre requête et le moteur SQL détermine comment interpréter la tâche.

Plusieurs composants sont inclus dans ce processus.

Ces composants sont -

• Répartiteur de requêtes
• Moteurs d'optimisation
• Moteur de requête classique
• Moteur de requête SQL, etc.

Un moteur de requête classique gère toutes les requêtes non SQL, mais un moteur de requête SQL ne gère pas les fichiers logiques.

Voici un schéma simple montrant l'architecture SQL -

Commandes SQL

Les commandes SQL standard pour interagir avec les bases de données relationnelles sont CREATE, SELECT, INSERT, UPDATE, DELETE et DROP. Ces commandes peuvent être classées dans les groupes suivants en fonction de leur nature -

DDL - Langage de définition de données

N ° Sr.	Commande et description
1	CREATE Crée une nouvelle table, une vue d'une table ou un autre objet dans la base de données.
2	ALTER Modifie un objet de base de données existant, tel qu'une table.
3	DROP Supprime une table entière, une vue d'une table ou d'autres objets de la base de données.

DML - Langage de manipulation de données

N ° Sr.	Commande et description
1	SELECT Récupère certains enregistrements d'une ou plusieurs tables.
2	INSERT Crée un enregistrement.
3	UPDATE Modifie les enregistrements.
4	DELETE Supprime les enregistrements.

DCL - Langage de contrôle des données

N ° Sr.	Commande et description
1	GRANT Donne un privilège à l'utilisateur.
2	REVOKE Reprend les privilèges accordés à l'utilisateur.

Qu'est-ce que le SGBDR?

RDBMS signifie Rexaltation Database Mgestion System. Le SGBDR est la base de SQL et de tous les systèmes de base de données modernes tels que MS SQL Server, IBM DB2, Oracle, MySQL et Microsoft Access.

Un système de gestion de base de données relationnelle (SGBDR) est un système de gestion de base de données (SGBD) basé sur le modèle relationnel introduit par EF Codd.

Qu'est-ce qu'une table?

Les données d'un SGBDR sont stockées dans des objets de base de données appelés tables. Ce tableau est essentiellement une collection d'entrées de données connexes et se compose de nombreuses colonnes et lignes.

N'oubliez pas qu'une table est la forme la plus courante et la plus simple de stockage de données dans une base de données relationnelle. Le programme suivant est un exemple de table CUSTOMERS -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Qu'est-ce qu'un champ?

Chaque table est divisée en entités plus petites appelées champs. Les champs de la table CUSTOMERS sont les suivants: ID, NOM, AGE, ADDRESS et SALARY.

Un champ est une colonne d'une table conçue pour conserver des informations spécifiques sur chaque enregistrement de la table.

Qu'est-ce qu'un enregistrement ou une ligne?

Un enregistrement est également appelé comme ligne de données chaque entrée individuelle qui existe dans une table. Par exemple, il y a 7 enregistrements dans la table CUSTOMERS ci-dessus. Voici une seule ligne de données ou d'enregistrement dans la table CUSTOMERS -

+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

Un enregistrement est une entité horizontale dans une table.

Qu'est-ce qu'une colonne?

Une colonne est une entité verticale dans une table qui contient toutes les informations associées à un champ spécifique dans une table.

Par exemple, une colonne de la table CUSTOMERS est ADDRESS, qui représente la description de l'emplacement et serait comme indiqué ci-dessous -

+-----------+
| ADDRESS   |
+-----------+
| Ahmedabad |
| Delhi     |
| Kota      |
| Mumbai    |
| Bhopal    |
| MP        |
| Indore    |
+----+------+

Qu'est-ce qu'une valeur NULL?

Une valeur NULL dans une table est une valeur dans un champ qui semble vide, ce qui signifie qu'un champ avec une valeur NULL est un champ sans valeur.

Il est très important de comprendre qu'une valeur NULL est différente d'une valeur zéro ou d'un champ qui contient des espaces. Un champ avec une valeur NULL est celui qui a été laissé vide lors de la création d'un enregistrement.

Contraintes SQL

Les contraintes sont les règles appliquées sur les colonnes de données d'une table. Ceux-ci sont utilisés pour limiter le type de données qui peuvent entrer dans une table. Cela garantit l'exactitude et la fiabilité des données de la base de données.

Les contraintes peuvent être au niveau de la colonne ou au niveau de la table. Les contraintes au niveau de la colonne ne sont appliquées qu'à une seule colonne, tandis que les contraintes au niveau de la table sont appliquées à la table entière.

Voici quelques-unes des contraintes les plus couramment utilisées disponibles dans SQL -

• NOT NULL Contrainte - Garantit qu'une colonne ne peut pas avoir une valeur NULL.

• Contrainte DEFAULT - Fournit une valeur par défaut pour une colonne lorsqu'aucune n'est spécifiée.

• Contrainte UNIQUE - Garantit que toutes les valeurs d'une colonne sont différentes.

• Clé PRIMAIRE - Identifie de manière unique chaque ligne / enregistrement dans une table de base de données.

• FOREIGN Key - Identifie de manière unique une ligne / un enregistrement dans une autre table de base de données.

• Contrainte CHECK - La contrainte CHECK garantit que toutes les valeurs d'une colonne satisfont à certaines conditions.

• INDEX - Utilisé pour créer et récupérer très rapidement des données de la base de données.

Intégrité des données

Les catégories suivantes d'intégrité des données existent avec chaque SGBDR -

• Entity Integrity − Il n'y a pas de lignes en double dans une table.

• Domain Integrity − Applique les entrées valides pour une colonne donnée en limitant le type, le format ou la plage de valeurs.

• Referential integrity − Les lignes ne peuvent pas être supprimées, qui sont utilisées par d'autres enregistrements.

• User-Defined Integrity − Applique certaines règles métier spécifiques qui ne relèvent pas de l'entité, du domaine ou de l'intégrité référentielle.

Normalisation de la base de données

La normalisation de la base de données est le processus d'organisation efficace des données dans une base de données. Il y a deux raisons à ce processus de normalisation -

• Éliminer les données redondantes, par exemple, stocker les mêmes données dans plusieurs tables.

• S'assurer que les dépendances des données ont du sens.

Ces deux raisons sont des objectifs louables car elles réduisent la quantité d'espace consommée par une base de données et garantissent que les données sont stockées de manière logique. La normalisation consiste en une série de directives qui vous aident à créer une bonne structure de base de données.

Les directives de normalisation sont divisées en formes normales; Pensez à un formulaire comme au format ou à la façon dont une structure de base de données est présentée. Le but des formulaires normaux est d'organiser la structure de la base de données, de sorte qu'elle soit conforme aux règles de la première forme normale, puis de la deuxième forme normale et enfin de la troisième forme normale.

C'est votre choix d'aller plus loin et de passer à la quatrième forme normale, cinquième forme normale et ainsi de suite, mais en général, la troisième forme normale est plus que suffisante.

• Première forme normale (1NF)
• Deuxième forme normale (2NF)
• Troisième forme normale (3NF)

Il existe de nombreux SGBDR populaires avec lesquels travailler. Ce didacticiel donne un bref aperçu de certains des SGBDR les plus populaires. Cela vous aiderait à comparer leurs fonctionnalités de base.

MySQL

MySQL est une base de données SQL open source, développée par une société suédoise - MySQL AB. MySQL est prononcé comme «mon ess-que-ell», contrairement à SQL, prononcé «suite».

MySQL prend en charge de nombreuses plates-formes différentes, notamment Microsoft Windows, les principales distributions Linux, UNIX et Mac OS X.

MySQL a des versions gratuites et payantes, en fonction de son utilisation (non commerciale / commerciale) et de ses fonctionnalités. MySQL est livré avec un serveur de base de données SQL très rapide, multi-thread, multi-utilisateurs et robuste.

L'histoire

• Développement de MySQL par Michael Widenius & David Axmark à partir de 1994.

• Première version interne le 23 ^rd mai 1995.

• Windows version a été publiée le 8 ^e Janvier 1998 pour Windows 95 et NT.

• Version 3.23: bêta de juin 2000, sortie de production janvier 2001.

• Version 4.0: bêta d'août 2002, sortie de production mars 2003 (syndicats).

• Version 4.1: bêta de juin 2004, sortie de production octobre 2004.

• Version 5.0: bêta de mars 2005, sortie de production octobre 2005.

• Sun Microsystems a acquis MySQL AB le 26 ^e Février de 2008.

• Version 5.1: version de production 27 ^e Novembre de 2008.

traits

• Haute performance.
• La haute disponibilité.
• Évolutivité et flexibilité Exécutez n'importe quoi.
• Support transactionnel robuste.
• Forces du Web et de l'entrepôt de données.
• Protection des données renforcée.
• Développement d'applications complet.
• Facilité de gestion.
• Liberté Open Source et assistance 24/7.
• Coût total de possession le plus bas.

MS SQL Server

MS SQL Server est un système de gestion de base de données relationnelle développé par Microsoft Inc. Ses principaux langages de requête sont:

• T-SQL
• ANSI SQL

L'histoire

• 1987 - Sybase lance SQL Server pour UNIX.

• 1988 - Microsoft, Sybase et Aston-Tate transfèrent SQL Server vers OS / 2.

• 1989 - Microsoft, Sybase et Aston-Tate publient SQL Server 1.0 pour OS / 2.

• 1990 - SQL Server 1.1 est publié avec la prise en charge des clients Windows 3.0.

• Aston - Tate abandonne le développement de SQL Server.

• 2000 - Microsoft publie SQL Server 2000.

• 2001 - Microsoft publie XML pour SQL Server Web Release 1 (téléchargement).

• 2002 - Microsoft publie SQLXML 2.0 (renommé à partir de XML pour SQL Server).

• 2002 - Microsoft publie SQLXML 3.0.

• 2005 - Microsoft publie SQL Server 2005 le 7 novembre 2005.

traits

• Haute performance
• La haute disponibilité
• Mise en miroir de bases de données
• Instantanés de la base de données
• Intégration CLR
• Courtier de services
• Déclencheurs DDL
• Fonctions de classement
• Niveaux d'isolement basés sur la version de ligne
• Intégration XML
• TRY...CATCH
• Courrier de base de données

ORACLE

Il s'agit d'un très grand système de gestion de base de données multi-utilisateurs. Oracle est un système de gestion de base de données relationnelle développé par «Oracle Corporation».

Oracle s'efforce de gérer efficacement ses ressources, une base de données d'informations parmi les multiples clients demandant et envoyant des données sur le réseau.

C'est un excellent choix de serveur de base de données pour l'informatique client / serveur. Oracle prend en charge tous les principaux systèmes d'exploitation pour les clients et les serveurs, notamment MSDOS, NetWare, UnixWare, OS / 2 et la plupart des versions UNIX.

L'histoire

Oracle a commencé en 1977 et célébrait ses 32 merveilleuses années dans l'industrie (de 1977 à 2009).

• 1977 - Larry Ellison, Bob Miner et Ed Oates ont fondé des laboratoires de développement de logiciels pour entreprendre des travaux de développement.

• 1979 - La version 2.0 d'Oracle est sortie et devient la première base de données relationnelle commerciale et la première base de données SQL. La société a changé son nom en Relational Software Inc. (RSI).

• 1981 - RSI a commencé à développer des outils pour Oracle.

• 1982 - RSI a été renommé Oracle Corporation.

• 1983 - Oracle a publié la version 3.0, réécrite en langage C et fonctionnant sur plusieurs plates-formes.

• 1984 - La version 4.0 d'Oracle est sortie. Il contenait des fonctionnalités telles que le contrôle de la concurrence - cohérence de lecture multi-version, etc.

• 1985 - La version 4.0 d'Oracle est sortie. Il contenait des fonctionnalités telles que le contrôle de la concurrence - cohérence de lecture multi-version, etc.

• 2007 - Oracle a publié Oracle11g. La nouvelle version se concentre sur un meilleur partitionnement, une migration facile, etc.

traits

• Concurrency
• Lire la cohérence
• Mécanismes de verrouillage
• Base de données de mise au repos
• Portability
• Base de données autogérée
• SQL*Plus
• ASM
• Scheduler
• Gestionnaire de ressources
• Entreposage de données
• Vues matérialisées
• Index bitmap
• Compression de table
• Exécution parallèle
• SQL analytique
• Exploration de données
• Partitioning

ACCÈS MS

C'est l'un des produits Microsoft les plus populaires. Microsoft Access est un logiciel de gestion de base de données d'entrée de gamme. La base de données MS Access est non seulement peu coûteuse, mais également une base de données puissante pour les projets à petite échelle.

MS Access utilise le moteur de base de données Jet, qui utilise un dialecte de langage SQL spécifique (parfois appelé Jet SQL).

MS Access est fourni avec l'édition professionnelle du package MS Office. MS Access possède une interface graphique intuitive facile à utiliser.

• 1992 - La version 1.0 d'Access est sortie.

• 1993 - Access 1.1 est publié pour améliorer la compatibilité avec l'inclusion du langage de programmation Access Basic.

• La transition la plus importante a été d'Access 97 à Access 2000.

• 2007 - Access 2007, un nouveau format de base de données a été introduit ACCDB qui prend en charge des types de données complexes tels que les champs à valeurs multiples et les pièces jointes.

traits

• Les utilisateurs peuvent créer des tables, des requêtes, des formulaires et des rapports et les connecter avec des macros.

• Possibilité d'importer et d'exporter les données vers de nombreux formats dont Excel, Outlook, ASCII, dBase, Paradox, FoxPro, SQL Server, Oracle, ODBC, etc.

• Il existe également le format Jet Database (MDB ou ACCDB dans Access 2007), qui peut contenir l'application et les données dans un seul fichier. Cela rend très pratique la distribution de l'ensemble de l'application à un autre utilisateur, qui peut l'exécuter dans des environnements déconnectés.

• Microsoft Access propose des requêtes paramétrées. Ces requêtes et tables Access peuvent être référencées à partir d'autres programmes tels que VB6 et .NET via DAO ou ADO.

• Les éditions de bureau de Microsoft SQL Server peuvent être utilisées avec Access comme alternative au moteur de base de données Jet.

• Microsoft Access est une base de données basée sur un serveur de fichiers. Contrairement aux systèmes de gestion de base de données relationnelle client-serveur (SGBDR), Microsoft Access n'implémente pas de déclencheurs de base de données, de procédures stockées ou de journalisation des transactions.

SQL - Syntaxe

SQL est suivi d'un ensemble unique de règles et de directives appelées Syntaxe. Ce didacticiel vous donne un démarrage rapide avec SQL en répertoriant toutes les syntaxes SQL de base.

Toutes les instructions SQL commencent par l'un des mots-clés tels que SELECT, INSERT, UPDATE, DELETE, ALTER, DROP, CREATE, USE, SHOW et toutes les instructions se terminent par un point-virgule (;).

Le point le plus important à noter ici est que SQL est insensible à la casse, ce qui signifie que SELECT et select ont la même signification dans les instructions SQL. Alors que MySQL fait la différence dans les noms de table. Donc, si vous travaillez avec MySQL, vous devez donner les noms de table tels qu'ils existent dans la base de données.

Diverses syntaxes en SQL

Tous les exemples donnés dans ce tutoriel ont été testés avec un serveur MySQL.

Instruction SQL SELECT

SELECT column1, column2....columnN
FROM   table_name;

Clause SQL DISTINCT

SELECT DISTINCT column1, column2....columnN
FROM   table_name;

Clause SQL WHERE

SELECT column1, column2....columnN
FROM   table_name
WHERE  CONDITION;

Clause SQL AND / OR

SELECT column1, column2....columnN
FROM   table_name
WHERE  CONDITION-1 {AND|OR} CONDITION-2;

Clause SQL IN

SELECT column1, column2....columnN
FROM   table_name
WHERE  column_name IN (val-1, val-2,...val-N);

Clause SQL BETWEEN

SELECT column1, column2....columnN
FROM   table_name
WHERE  column_name BETWEEN val-1 AND val-2;

Clause SQL LIKE

SELECT column1, column2....columnN
FROM   table_name
WHERE  column_name LIKE { PATTERN };

Clause SQL ORDER BY

SELECT column1, column2....columnN
FROM   table_name
WHERE  CONDITION
ORDER BY column_name {ASC|DESC};

Clause SQL GROUP BY

SELECT SUM(column_name)
FROM   table_name
WHERE  CONDITION
GROUP BY column_name;

Clause SQL COUNT

SELECT COUNT(column_name)
FROM   table_name
WHERE  CONDITION;

Clause SQL HAVING

SELECT SUM(column_name)
FROM   table_name
WHERE  CONDITION
GROUP BY column_name
HAVING (arithematic function condition);

Instruction SQL CREATE TABLE

CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
PRIMARY KEY( one or more columns )
);

Instruction SQL DROP TABLE

DROP TABLE table_name;

Instruction SQL CREATE INDEX

CREATE UNIQUE INDEX index_name
ON table_name ( column1, column2,...columnN);

Instruction SQL DROP INDEX

ALTER TABLE table_name
DROP INDEX index_name;

Instruction SQL DESC

DESC table_name;

Instruction SQL TRUNCATE TABLE

TRUNCATE TABLE table_name;

Instruction SQL ALTER TABLE

ALTER TABLE table_name {ADD|DROP|MODIFY} column_name {data_ype};

Instruction SQL ALTER TABLE (Renommer)

ALTER TABLE table_name RENAME TO new_table_name;

Instruction SQL INSERT INTO

INSERT INTO table_name( column1, column2....columnN)
VALUES ( value1, value2....valueN);

Instruction SQL UPDATE

UPDATE table_name
SET column1 = value1, column2 = value2....columnN=valueN
[ WHERE  CONDITION ];

Instruction SQL DELETE

DELETE FROM table_name
WHERE  {CONDITION};

Instruction SQL CREATE DATABASE

CREATE DATABASE database_name;

Instruction SQL DROP DATABASE

DROP DATABASE database_name;

Instruction SQL USE

USE database_name;

Instruction SQL COMMIT

COMMIT;

Instruction SQL ROLLBACK

ROLLBACK;

SQL - Types de données

Le type de données SQL est un attribut qui spécifie le type de données de tout objet. Chaque colonne, variable et expression a un type de données associé dans SQL. Vous pouvez utiliser ces types de données lors de la création de vos tables. Vous pouvez choisir un type de données pour une colonne de table en fonction de vos besoins.

SQL Server propose six catégories de types de données pour votre utilisation qui sont répertoriées ci-dessous -

Types de données numériques exacts

TYPE DE DONNÉES	DE	À
bigint	-9 223 372 036 854 775 808	9 223 372 036 854 775 807
int	-2 147 483 648	2 147 483 647
smallint	-32 768	32 767
minuscule	0	255
bit	0	1
décimal	-10 ^ 38 +1	10 ^ 38-1
numérique	-10 ^ 38 +1	10 ^ 38-1
argent	-922 337 203 685 477,5808	+922 337 203 685 477 5807
petit argent	-214 748,3648	+214 748,3647

Types de données numériques approximatifs

TYPE DE DONNÉES	DE	À
flotte	-1,79E + 308	1,79E + 308
réel	-3,40E + 38	3,40E + 38

Types de données de date et d'heure

TYPE DE DONNÉES	DE	À
datetime	1 janv.1753	31 déc.9999
smalldatetime	1 janv.1900	6 juin 2079
Date	Stocke une date comme le 30 juin 1991
temps	Enregistre une heure de la journée comme 12h30

Note - Ici, datetime a une précision de 3,33 millisecondes alors que smalldatetime a une précision de 1 minute.

Types de données de chaînes de caractères

N ° Sr.	TYPE DE DONNÉES et description
1	char Longueur maximale de 8 000 caractères (caractères non Unicode de longueur fixe)
2	varchar Maximum de 8 000 caractères (données non Unicode de longueur variable).
3	varchar(max) Longueur maximale de 2E + 31 caractères, données non Unicode de longueur variable (SQL Server 2005 uniquement).
4	text Données non Unicode de longueur variable d'une longueur maximale de 2 147 483 647 caractères.

Types de données de chaînes de caractères Unicode

N ° Sr.	TYPE DE DONNÉES et description
1	nchar Longueur maximale de 4000 caractères (Unicode de longueur fixe)
2	nvarchar Longueur maximale de 4000 caractères (longueur variable Unicode)
3	nvarchar(max) Longueur maximale de 2E + 31 caractères (SQL Server 2005 uniquement) (longueur variable Unicode)
4	ntext Longueur maximale de 1 073 741 823 caractères. (Unicode de longueur variable)

Types de données binaires

N ° Sr.	TYPE DE DONNÉES et description
1	binary Longueur maximale de 8 000 octets (données binaires de longueur fixe)
2	varbinary Longueur maximale de 8 000 octets (données binaires de longueur variable)
3	varbinary(max) Longueur maximale de 2E + 31 octets (SQL Server 2005 uniquement). (Données binaires de longueur variable)
4	image Longueur maximale de 2 147 483 647 octets. (Données binaires de longueur variable)

Types de données divers

N ° Sr.	TYPE DE DONNÉES et description
1	sql_variant Stocke les valeurs de divers types de données pris en charge par SQL Server, à l'exception du texte, du ntext et de l'horodatage.
2	timestamp Stocke un numéro unique à l'échelle de la base de données qui est mis à jour chaque fois qu'une ligne est mise à jour
3	uniqueidentifier Stocke un identifiant global unique (GUID)
4	xml Stocke les données XML. Vous pouvez stocker des instances xml dans une colonne ou une variable (SQL Server 2005 uniquement).
5	cursor Référence à un objet curseur
6	table Stocke un jeu de résultats pour un traitement ultérieur

SQL - Opérateurs

Qu'est-ce qu'un opérateur en SQL?

Un opérateur est un mot réservé ou un caractère utilisé principalement dans la clause WHERE d'une instruction SQL pour effectuer des opérations, telles que des comparaisons et des opérations arithmétiques. Ces opérateurs sont utilisés pour spécifier des conditions dans une instruction SQL et pour servir de conjonctions pour plusieurs conditions dans une instruction.

• Opérateurs arithmétiques
• Opérateurs de comparaison
• Opérateurs logiques
• Opérateurs utilisés pour annuler les conditions

Opérateurs arithmétiques SQL

Présumer 'variable a' détient 10 et 'variable b' détient 20, alors -

Afficher des exemples

Opérateur	La description	Exemple
+ (Ajout)	Ajoute des valeurs de chaque côté de l'opérateur.	a + b donnera 30
- (Soustraction)	Soustrait l'opérande de droite de l'opérande de gauche.	a - b donnera -10
* (Multiplication)	Multiplie les valeurs de chaque côté de l'opérateur.	a * b donnera 200
/ (Division)	Divise l'opérande de gauche par l'opérande de droite.	b / a donnera 2
% (Module)	Divise l'opérande de gauche par l'opérande de droite et renvoie le reste.	b% a donnera 0

Opérateurs de comparaison SQL

Présumer 'variable a' détient 10 et 'variable b' détient 20, alors -

Afficher des exemples

Opérateur	La description	Exemple
=	Vérifie si les valeurs de deux opérandes sont égales ou non, si oui, la condition devient vraie.	(a = b) n'est pas vrai.
! =	Vérifie si les valeurs de deux opérandes sont égales ou non, si les valeurs ne sont pas égales, la condition devient vraie.	(a! = b) est vrai.
<>	Vérifie si les valeurs de deux opérandes sont égales ou non, si les valeurs ne sont pas égales, la condition devient vraie.	(a <> b) est vrai.
>	Vérifie si la valeur de l'opérande gauche est supérieure à la valeur de l'opérande droit, si oui, la condition devient vraie.	(a> b) n'est pas vrai.
<	Vérifie si la valeur de l'opérande gauche est inférieure à la valeur de l'opérande droit, si oui, la condition devient vraie.	(a <b) est vrai.
> =	Vérifie si la valeur de l'opérande gauche est supérieure ou égale à la valeur de l'opérande droit, si oui, la condition devient vraie.	(a> = b) n'est pas vrai.
<=	Vérifie si la valeur de l'opérande gauche est inférieure ou égale à la valeur de l'opérande droit, si oui, la condition devient vraie.	(a <= b) est vrai.
! <	Vérifie si la valeur de l'opérande gauche n'est pas inférieure à la valeur de l'opérande droit, si oui, la condition devient vraie.	(a! <b) est faux.
!>	Vérifie si la valeur de l'opérande gauche n'est pas supérieure à la valeur de l'opérande droit, si oui, la condition devient vraie.	(a!> b) est vrai.

Opérateurs logiques SQL

Voici une liste de tous les opérateurs logiques disponibles en SQL.

Afficher des exemples

N ° Sr.	Opérateur et description
1	ALL L'opérateur ALL est utilisé pour comparer une valeur à toutes les valeurs d'un autre jeu de valeurs.
2	AND L'opérateur AND permet l'existence de plusieurs conditions dans la clause WHERE d'une instruction SQL.
3	ANY L'opérateur ANY est utilisé pour comparer une valeur à toute valeur applicable dans la liste selon la condition.
4	BETWEEN L'opérateur BETWEEN est utilisé pour rechercher des valeurs qui se trouvent dans un ensemble de valeurs, étant donné la valeur minimale et la valeur maximale.
5	EXISTS L'opérateur EXISTS est utilisé pour rechercher la présence d'une ligne dans une table spécifiée qui répond à un certain critère.
6	IN L'opérateur IN est utilisé pour comparer une valeur à une liste de valeurs littérales qui ont été spécifiées.
sept	LIKE L'opérateur LIKE est utilisé pour comparer une valeur à des valeurs similaires à l'aide d'opérateurs génériques.
8	NOT L'opérateur NOT inverse la signification de l'opérateur logique avec lequel il est utilisé. Par exemple: PAS EXISTANT, PAS ENTRE, PAS IN, etc.This is a negate operator.
9	OR L'opérateur OR est utilisé pour combiner plusieurs conditions dans la clause WHERE d'une instruction SQL.
dix	IS NULL L'opérateur NULL est utilisé pour comparer une valeur avec une valeur NULL.
11	UNIQUE L'opérateur UNIQUE recherche chaque ligne d'une table spécifiée pour l'unicité (pas de doublons).

SQL - Expressions

Une expression est une combinaison d'une ou plusieurs valeurs, opérateurs et fonctions SQL qui s'évaluent à une valeur. Ces expressions SQL sont comme des formules et elles sont écrites en langage de requête. Vous pouvez également les utiliser pour interroger la base de données sur un ensemble spécifique de données.

Syntaxe

Considérez la syntaxe de base de l'instruction SELECT comme suit -

SELECT column1, column2, columnN 
FROM table_name 
WHERE [CONDITION|EXPRESSION];

Il existe différents types d'expressions SQL, qui sont mentionnés ci-dessous -

• Boolean
• Numeric
• Date

Examinons maintenant chacun de ces éléments en détail.

Expressions booléennes

Les expressions booléennes SQL récupèrent les données en fonction de la correspondance d'une seule valeur. Voici la syntaxe -

SELECT column1, column2, columnN 
FROM table_name 
WHERE SINGLE VALUE MATCHING EXPRESSION;

Considérez la table CUSTOMERS ayant les enregistrements suivants -

SQL> SELECT * FROM CUSTOMERS;
+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+
7 rows in set (0.00 sec)

Le tableau suivant est un exemple simple montrant l'utilisation de diverses expressions booléennes SQL -

SQL> SELECT * FROM CUSTOMERS WHERE SALARY = 10000;
+----+-------+-----+---------+----------+
| ID | NAME  | AGE | ADDRESS | SALARY   |
+----+-------+-----+---------+----------+
|  7 | Muffy |  24 | Indore  | 10000.00 |
+----+-------+-----+---------+----------+
1 row in set (0.00 sec)

Expression numérique

Ces expressions sont utilisées pour effectuer toute opération mathématique dans n'importe quelle requête. Voici la syntaxe -

SELECT numerical_expression as  OPERATION_NAME
[FROM table_name
WHERE CONDITION] ;

Ici, l'expression_numérique est utilisée pour une expression mathématique ou toute formule. Voici un exemple simple montrant l'utilisation d'expressions numériques SQL -

SQL> SELECT (15 + 6) AS ADDITION
+----------+
| ADDITION |
+----------+
|       21 |
+----------+
1 row in set (0.00 sec)

Il existe plusieurs fonctions intégrées telles que avg (), sum (), count (), etc., pour effectuer ce que l'on appelle les calculs de données agrégées sur une table ou une colonne de table spécifique.

SQL> SELECT COUNT(*) AS "RECORDS" FROM CUSTOMERS; 
+---------+
| RECORDS |
+---------+
|       7 |
+---------+
1 row in set (0.00 sec)

Expressions de date

Les expressions de date renvoient les valeurs de date et d'heure système actuelles -

SQL>  SELECT CURRENT_TIMESTAMP;
+---------------------+
| Current_Timestamp   |
+---------------------+
| 2009-11-12 06:40:23 |
+---------------------+
1 row in set (0.00 sec)

Une autre expression de date est comme indiqué ci-dessous -

SQL>  SELECT  GETDATE();;
+-------------------------+
| GETDATE                 |
+-------------------------+
| 2009-10-22 12:07:18.140 |
+-------------------------+
1 row in set (0.00 sec)

SQL - CREATE Base de données

Le SQL CREATE DATABASE l'instruction est utilisée pour créer une nouvelle base de données SQL.

Syntaxe

La syntaxe de base de cette instruction CREATE DATABASE est la suivante -

CREATE DATABASE DatabaseName;

Le nom de la base de données doit toujours être unique dans le SGBDR.

Exemple

Si vous souhaitez créer une nouvelle base de données <testDB>, l'instruction CREATE DATABASE serait comme indiqué ci-dessous -

SQL> CREATE DATABASE testDB;

Assurez-vous que vous disposez du privilège d'administrateur avant de créer une base de données. Une fois qu'une base de données est créée, vous pouvez la vérifier dans la liste des bases de données comme suit -

SQL> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| AMROOD             |
| TUTORIALSPOINT     |
| mysql              |
| orig               |
| test               |
| testDB             |
+--------------------+
7 rows in set (0.00 sec)

SQL - Base de données DROP ou DELETE

Le SQL DROP DATABASE L'instruction est utilisée pour supprimer une base de données existante dans un schéma SQL.

Syntaxe

La syntaxe de base de l'instruction DROP DATABASE est la suivante -

DROP DATABASE DatabaseName;

Le nom de la base de données doit toujours être unique dans le SGBDR.

Exemple

Si vous souhaitez supprimer une base de données existante <testDB>, alors l'instruction DROP DATABASE serait comme indiqué ci-dessous -

SQL> DROP DATABASE testDB;

NOTE - Soyez prudent avant d'utiliser cette opération car la suppression d'une base de données existante entraînerait la perte d'informations complètes stockées dans la base de données.

Assurez-vous que vous disposez du privilège d'administrateur avant de supprimer une base de données. Une fois qu'une base de données est supprimée, vous pouvez la vérifier dans la liste des bases de données comme indiqué ci-dessous -

SQL> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| AMROOD             |
| TUTORIALSPOINT     |
| mysql              |
| orig               |
| test               |
+--------------------+
6 rows in set (0.00 sec)

SQL - Base de données SELECT, instruction USE

Lorsque vous avez plusieurs bases de données dans votre schéma SQL, avant de commencer votre opération, vous devez sélectionner une base de données dans laquelle toutes les opérations seront effectuées.

Le SQL USE est utilisée pour sélectionner une base de données existante dans le schéma SQL.

Syntaxe

La syntaxe de base de l'instruction USE est la suivante:

USE DatabaseName;

Le nom de la base de données doit toujours être unique dans le SGBDR.

Exemple

Vous pouvez vérifier les bases de données disponibles comme indiqué ci-dessous -

SQL> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| AMROOD             |
| TUTORIALSPOINT     |
| mysql              |
| orig               |
| test               |
+--------------------+
6 rows in set (0.00 sec)

Maintenant, si vous souhaitez travailler avec la base de données AMROOD, vous pouvez exécuter la commande SQL suivante et commencer à travailler avec la base de données AMROOD.

SQL> USE AMROOD;

SQL - Table CREATE

La création d'une table de base implique de nommer la table et de définir ses colonnes et le type de données de chaque colonne.

Le SQL CREATE TABLE instruction est utilisée pour créer une nouvelle table.

Syntaxe

La syntaxe de base de l'instruction CREATE TABLE est la suivante -

CREATE TABLE table_name(
   column1 datatype,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
   PRIMARY KEY( one or more columns )
);

CREATE TABLE est le mot-clé indiquant au système de base de données ce que vous voulez faire. Dans ce cas, vous souhaitez créer une nouvelle table. Le nom ou l'identificateur unique de la table suit l'instruction CREATE TABLE.

Ensuite, entre parenthèses vient la liste définissant chaque colonne du tableau et de quel type de données il s'agit. La syntaxe devient plus claire avec l'exemple suivant.

Une copie d'une table existante peut être créée à l'aide d'une combinaison de l'instruction CREATE TABLE et de l'instruction SELECT. Vous pouvez vérifier les détails complets dans Créer une table à l'aide d'une autre table.

Exemple

Le bloc de code suivant est un exemple, qui crée une table CUSTOMERS avec un ID comme clé primaire et NOT NULL sont les contraintes montrant que ces champs ne peuvent pas être NULL lors de la création d'enregistrements dans cette table -

SQL> CREATE TABLE CUSTOMERS(
   ID   INT              NOT NULL,
   NAME VARCHAR (20)     NOT NULL,
   AGE  INT              NOT NULL,
   ADDRESS  CHAR (25) ,
   SALARY   DECIMAL (18, 2),       
   PRIMARY KEY (ID)
);

Vous pouvez vérifier si votre table a été créée avec succès en regardant le message affiché par le serveur SQL, sinon vous pouvez utiliser le DESC commande comme suit -

SQL> DESC CUSTOMERS;
+---------+---------------+------+-----+---------+-------+
| Field   | Type          | Null | Key | Default | Extra |
+---------+---------------+------+-----+---------+-------+
| ID      | int(11)       | NO   | PRI |         |       |
| NAME    | varchar(20)   | NO   |     |         |       |
| AGE     | int(11)       | NO   |     |         |       |
| ADDRESS | char(25)      | YES  |     | NULL    |       |
| SALARY  | decimal(18,2) | YES  |     | NULL    |       |
+---------+---------------+------+-----+---------+-------+
5 rows in set (0.00 sec)

Maintenant, vous avez la table CUSTOMERS disponible dans votre base de données que vous pouvez utiliser pour stocker les informations requises relatives aux clients.

SQL - Table DROP ou DELETE

Le SQL DROP TABLE L'instruction est utilisée pour supprimer une définition de table et toutes les données, index, déclencheurs, contraintes et spécifications d'autorisation pour cette table.

NOTE - Vous devez être très prudent lorsque vous utilisez cette commande car une fois qu'une table est supprimée, toutes les informations disponibles dans cette table seront également perdues à jamais.

Syntaxe

La syntaxe de base de cette instruction DROP TABLE est la suivante -

DROP TABLE table_name;

Exemple

Vérifions d'abord la table CUSTOMERS, puis nous la supprimerons de la base de données comme indiqué ci-dessous -

SQL> DESC CUSTOMERS;
+---------+---------------+------+-----+---------+-------+
| Field   | Type          | Null | Key | Default | Extra |
+---------+---------------+------+-----+---------+-------+
| ID      | int(11)       | NO   | PRI |         |       |
| NAME    | varchar(20)   | NO   |     |         |       |
| AGE     | int(11)       | NO   |     |         |       |
| ADDRESS | char(25)      | YES  |     | NULL    |       |
| SALARY  | decimal(18,2) | YES  |     | NULL    |       |
+---------+---------------+------+-----+---------+-------+
5 rows in set (0.00 sec)

Cela signifie que la table CUSTOMERS est disponible dans la base de données, alors supprimons-la comme indiqué ci-dessous.

SQL> DROP TABLE CUSTOMERS;
Query OK, 0 rows affected (0.01 sec)

Maintenant, si vous essayez la commande DESC, vous obtiendrez l'erreur suivante -

SQL> DESC CUSTOMERS;
ERROR 1146 (42S02): Table 'TEST.CUSTOMERS' doesn't exist

Ici, TEST est le nom de la base de données que nous utilisons pour nos exemples.

SQL - Requête INSERT

Le SQL INSERT INTO L'instruction est utilisée pour ajouter de nouvelles lignes de données à une table dans la base de données.

Syntaxe

Il existe deux syntaxes de base de l'instruction INSERT INTO qui sont illustrées ci-dessous.

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)  
VALUES (value1, value2, value3,...valueN);

Ici, colonne1, colonne2, colonne3, ... colonneN sont les noms des colonnes du tableau dans lesquelles vous souhaitez insérer les données.

Vous n'aurez peut-être pas besoin de spécifier le nom de la ou des colonnes dans la requête SQL si vous ajoutez des valeurs pour toutes les colonnes de la table. Mais assurez-vous que l'ordre des valeurs est dans le même ordre que les colonnes du tableau.

le SQL INSERT INTO la syntaxe sera la suivante -

INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);

Exemple

Les instructions suivantes créeraient six enregistrements dans la table CUSTOMERS.

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Ramesh', 32, 'Ahmedabad', 2000.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (2, 'Khilan', 25, 'Delhi', 1500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (3, 'kaushik', 23, 'Kota', 2000.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (4, 'Chaitali', 25, 'Mumbai', 6500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (5, 'Hardik', 27, 'Bhopal', 8500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (6, 'Komal', 22, 'MP', 4500.00 );

Vous pouvez créer un enregistrement dans la table CUSTOMERS en utilisant la deuxième syntaxe comme indiqué ci-dessous.

INSERT INTO CUSTOMERS 
VALUES (7, 'Muffy', 24, 'Indore', 10000.00 );

Toutes les instructions ci-dessus produiraient les enregistrements suivants dans la table CUSTOMERS comme indiqué ci-dessous.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Remplir une table à l'aide d'une autre table

Vous pouvez remplir les données dans une table via l'instruction select sur une autre table; à condition que l'autre table ait un ensemble de champs, qui sont nécessaires pour remplir la première table.

Voici la syntaxe -

INSERT INTO first_table_name [(column1, column2, ... columnN)] 
   SELECT column1, column2, ...columnN 
   FROM second_table_name
   [WHERE condition];

SQL - Requête SELECT

Le SQL SELECTL'instruction est utilisée pour récupérer les données d'une table de base de données qui retourne ces données sous la forme d'une table de résultats. Ces tables de résultats sont appelées ensembles de résultats.

Syntaxe

La syntaxe de base de l'instruction SELECT est la suivante -

SELECT column1, column2, columnN FROM table_name;

Ici, colonne1, colonne2 ... sont les champs d'une table dont vous voulez récupérer les valeurs. Si vous souhaitez récupérer tous les champs disponibles dans le champ, vous pouvez utiliser la syntaxe suivante.

SELECT * FROM table_name;

Exemple

Considérez la table CUSTOMERS ayant les enregistrements suivants -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Le code suivant est un exemple qui récupère les champs ID, Nom et Salaire des clients disponibles dans la table CUSTOMERS.

SQL> SELECT ID, NAME, SALARY FROM CUSTOMERS;

Cela produirait le résultat suivant -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  1 | Ramesh   |  2000.00 |
|  2 | Khilan   |  1500.00 |
|  3 | kaushik  |  2000.00 |
|  4 | Chaitali |  6500.00 |
|  5 | Hardik   |  8500.00 |
|  6 | Komal    |  4500.00 |
|  7 | Muffy    | 10000.00 |
+----+----------+----------+

Si vous souhaitez récupérer tous les champs de la table CUSTOMERS, vous devez utiliser la requête suivante.

SQL> SELECT * FROM CUSTOMERS;

Cela produirait le résultat comme indiqué ci-dessous.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

SQL - Clause WHERE

Le SQL WHERELa clause est utilisée pour spécifier une condition lors de l'extraction des données à partir d'une seule table ou en les joignant à plusieurs tables. Si la condition donnée est satisfaite, alors seulement elle renvoie une valeur spécifique de la table. Vous devez utiliser la clause WHERE pour filtrer les enregistrements et récupérer uniquement les enregistrements nécessaires.

La clause WHERE n'est pas seulement utilisée dans l'instruction SELECT, mais elle est également utilisée dans l'instruction UPDATE, DELETE, etc., que nous examinerons dans les chapitres suivants.

Syntaxe

La syntaxe de base de l'instruction SELECT avec la clause WHERE est la suivante.

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition]

Vous pouvez spécifier une condition en utilisant la comparaison ou des opérateurs logiques comme>, <, =,LIKE, NOT, etc. Les exemples suivants clarifieraient ce concept.

Exemple

Considérez la table CUSTOMERS ayant les enregistrements suivants -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Le code suivant est un exemple qui récupère les champs ID, Nom et Salaire de la table CUSTOMERS, où le salaire est supérieur à 2000 -

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE SALARY > 2000;

Cela produirait le résultat suivant -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  4 | Chaitali |  6500.00 |
|  5 | Hardik   |  8500.00 |
|  6 | Komal    |  4500.00 |
|  7 | Muffy    | 10000.00 |
+----+----------+----------+

La requête suivante est un exemple qui extrait les champs ID, Nom et Salaire de la table CUSTOMERS pour un client avec le nom Hardik.

Ici, il est important de noter que toutes les chaînes doivent être placées entre guillemets simples (''). Tandis que les valeurs numériques doivent être données sans guillemets, comme dans l'exemple ci-dessus.

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE NAME = 'Hardik';

Cela produirait le résultat suivant -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  5 | Hardik   |  8500.00 |
+----+----------+----------+

SQL - Opérateurs conjonctifs AND et OR

Le SQL AND & ORLes opérateurs sont utilisés pour combiner plusieurs conditions pour restreindre les données dans une instruction SQL. Ces deux opérateurs sont appelés les opérateurs conjonctifs.

Ces opérateurs permettent de faire plusieurs comparaisons avec différents opérateurs dans la même instruction SQL.

L'opérateur AND

le AND L'opérateur autorise l'existence de plusieurs conditions dans la clause WHERE d'une instruction SQL.

Syntaxe

La syntaxe de base de l'opérateur AND avec une clause WHERE est la suivante -

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition1] AND [condition2]...AND [conditionN];

Vous pouvez combiner N nombre de conditions à l'aide de l'opérateur AND. Pour qu'une action soit entreprise par l'instruction SQL, qu'il s'agisse d'une transaction ou d'une requête, toutes les conditions séparées par AND doivent être TRUE.

Exemple

Considérez la table CUSTOMERS ayant les enregistrements suivants -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Voici un exemple qui récupère les champs ID, Nom et Salaire de la table CUSTOMERS, où le salaire est supérieur à 2000 et l'âge est inférieur à 25 ans -

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE SALARY > 2000 AND age < 25;

Cela produirait le résultat suivant -

+----+-------+----------+
| ID | NAME  | SALARY   |
+----+-------+----------+
|  6 | Komal |  4500.00 |
|  7 | Muffy | 10000.00 |
+----+-------+----------+

L'opérateur OR

L'opérateur OR est utilisé pour combiner plusieurs conditions dans la clause WHERE d'une instruction SQL.

Syntaxe

La syntaxe de base de l'opérateur OR avec une clause WHERE est la suivante -

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition1] OR [condition2]...OR [conditionN]

Vous pouvez combiner N nombre de conditions à l'aide de l'opérateur OR. Pour qu'une action soit entreprise par l'instruction SQL, qu'il s'agisse d'une transaction ou d'une requête, le seul UNE des conditions séparées par OR doit être VRAI.

Exemple

Considérez la table CUSTOMERS ayant les enregistrements suivants -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Le bloc de code suivant contient une requête qui récupère les champs ID, Nom et Salaire de la table CUSTOMERS, où le salaire est supérieur à 2000 OU l'âge est inférieur à 25 ans.

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE SALARY > 2000 OR age < 25;

Cela produirait le résultat suivant -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  3 | kaushik  |  2000.00 |
|  4 | Chaitali |  6500.00 |
|  5 | Hardik   |  8500.00 |
|  6 | Komal    |  4500.00 |
|  7 | Muffy    | 10000.00 |
+----+----------+----------+

SQL - Requête UPDATE

Le SQL UPDATELa requête est utilisée pour modifier les enregistrements existants dans une table. Vous pouvez utiliser la clause WHERE avec la requête UPDATE pour mettre à jour les lignes sélectionnées, sinon toutes les lignes seraient affectées.

Syntaxe

La syntaxe de base de la requête UPDATE avec une clause WHERE est la suivante -

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

Vous pouvez combiner N nombre de conditions à l'aide des opérateurs AND ou OR.

Exemple

Considérez la table CUSTOMERS ayant les enregistrements suivants -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

La requête suivante mettra à jour l'ADRESSE d'un client dont le numéro d'identification est 6 dans le tableau.

SQL> UPDATE CUSTOMERS
SET ADDRESS = 'Pune'
WHERE ID = 6;

Désormais, la table CUSTOMERS contiendrait les enregistrements suivants -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | Pune      |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Si vous souhaitez modifier toutes les valeurs de colonne ADDRESS et SALARY dans la table CUSTOMERS, vous n'avez pas besoin d'utiliser la clause WHERE car la requête UPDATE serait suffisante comme indiqué dans le bloc de code suivant.

SQL> UPDATE CUSTOMERS
SET ADDRESS = 'Pune', SALARY = 1000.00;

Désormais, la table CUSTOMERS contiendrait les enregistrements suivants -

+----+----------+-----+---------+---------+
| ID | NAME     | AGE | ADDRESS | SALARY  |
+----+----------+-----+---------+---------+
|  1 | Ramesh   |  32 | Pune    | 1000.00 |
|  2 | Khilan   |  25 | Pune    | 1000.00 |
|  3 | kaushik  |  23 | Pune    | 1000.00 |
|  4 | Chaitali |  25 | Pune    | 1000.00 |
|  5 | Hardik   |  27 | Pune    | 1000.00 |
|  6 | Komal    |  22 | Pune    | 1000.00 |
|  7 | Muffy    |  24 | Pune    | 1000.00 |
+----+----------+-----+---------+---------+

SQL - Requête DELETE

La requête SQL DELETE est utilisée pour supprimer les enregistrements existants d'une table.

Vous pouvez utiliser la clause WHERE avec une requête DELETE pour supprimer les lignes sélectionnées, sinon tous les enregistrements seraient supprimés.

Syntaxe

La syntaxe de base de la requête DELETE avec la clause WHERE est la suivante -

DELETE FROM table_name
WHERE [condition];

Vous pouvez combiner N nombre de conditions à l'aide des opérateurs AND ou OR.

Exemple

Considérez la table CUSTOMERS ayant les enregistrements suivants -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Le code suivant a une requête, qui supprimera un client, dont l'ID est 6.

SQL> DELETE FROM CUSTOMERS
WHERE ID = 6;

Désormais, la table CUSTOMERS contiendra les enregistrements suivants.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Si vous souhaitez SUPPRIMER tous les enregistrements de la table CUSTOMERS, vous n'avez pas besoin d'utiliser la clause WHERE et la requête DELETE serait la suivante -

SQL> DELETE FROM CUSTOMERS;

Désormais, la table CUSTOMERS ne contiendrait aucun enregistrement.

SQL - Clause LIKE

Le SQL LIKELa clause est utilisée pour comparer une valeur à des valeurs similaires à l'aide d'opérateurs génériques. Deux caractères génériques sont utilisés conjointement avec l'opérateur LIKE.

• Le signe de pourcentage (%)
• Le trait de soulignement (_)

Le signe de pourcentage représente zéro, un ou plusieurs caractères. Le trait de soulignement représente un seul nombre ou caractère. Ces symboles peuvent être utilisés dans des combinaisons.

Syntaxe

La syntaxe de base de% et _ est la suivante -

SELECT FROM table_name
WHERE column LIKE 'XXXX%'

or 

SELECT FROM table_name
WHERE column LIKE '%XXXX%'

or

SELECT FROM table_name
WHERE column LIKE 'XXXX_'

or

SELECT FROM table_name
WHERE column LIKE '_XXXX'

or

SELECT FROM table_name
WHERE column LIKE '_XXXX_'

Vous pouvez combiner N nombre de conditions à l'aide des opérateurs AND ou OR. Ici, XXXX peut être n'importe quelle valeur numérique ou chaîne.

Exemple

Le tableau suivant contient quelques exemples montrant la partie WHERE ayant une clause LIKE différente avec les opérateurs '%' et '_' -

N ° Sr.	Déclaration et description
1	WHERE SALARY LIKE '200%' Recherche toutes les valeurs commençant par 200.
2	WHERE SALARY LIKE '%200%' Recherche toutes les valeurs qui ont 200 dans n'importe quelle position.
3	WHERE SALARY LIKE '_00%' Recherche toutes les valeurs qui ont 00 dans les deuxième et troisième positions.
4	WHERE SALARY LIKE '2_%_%' Recherche toutes les valeurs commençant par 2 et comportant au moins 3 caractères.
5	WHERE SALARY LIKE '%2' Recherche toutes les valeurs qui se terminent par 2.
6	WHERE SALARY LIKE '_2%3' Recherche toutes les valeurs qui ont un 2 en deuxième position et se terminent par un 3.
sept	WHERE SALARY LIKE '2___3' Recherche toutes les valeurs d'un nombre à cinq chiffres commençant par 2 et se terminant par 3.

Prenons un exemple réel, considérons la table CUSTOMERS contenant les enregistrements comme indiqué ci-dessous.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Voici un exemple, qui afficherait tous les enregistrements de la table CUSTOMERS, où le SALAIRE commence par 200.

SQL> SELECT * FROM CUSTOMERS
WHERE SALARY LIKE '200%';

Cela produirait le résultat suivant -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
+----+----------+-----+-----------+----------+

SQL - Clause TOP, LIMIT ou ROWNUM

Le SQL TOP La clause est utilisée pour extraire un nombre TOP N ou X pourcent d'enregistrements d'une table.

Note- Toutes les bases de données ne prennent pas en charge la clause TOP. Par exemple, MySQL prend en charge leLIMIT clause pour récupérer un nombre limité d'enregistrements pendant qu'Oracle utilise ROWNUM commande pour récupérer un nombre limité d'enregistrements.

Syntaxe

La syntaxe de base de la clause TOP avec une instruction SELECT serait la suivante.

SELECT TOP number|percent column_name(s)
FROM table_name
WHERE [condition]

Exemple

Considérez la table CUSTOMERS ayant les enregistrements suivants -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

La requête suivante est un exemple sur le serveur SQL, qui extrait les 3 premiers enregistrements de la table CUSTOMERS.

SQL> SELECT TOP 3 * FROM CUSTOMERS;

Cela produirait le résultat suivant -

+----+---------+-----+-----------+---------+
| ID | NAME    | AGE | ADDRESS   | SALARY  |
+----+---------+-----+-----------+---------+
|  1 | Ramesh  |  32 | Ahmedabad | 2000.00 |
|  2 | Khilan  |  25 | Delhi     | 1500.00 |
|  3 | kaushik |  23 | Kota      | 2000.00 |
+----+---------+-----+-----------+---------+

Si vous utilisez un serveur MySQL, voici un exemple équivalent -

SQL> SELECT * FROM CUSTOMERS
LIMIT 3;

Cela produirait le résultat suivant -

+----+---------+-----+-----------+---------+
| ID | NAME    | AGE | ADDRESS   | SALARY  |
+----+---------+-----+-----------+---------+
|  1 | Ramesh  |  32 | Ahmedabad | 2000.00 |
|  2 | Khilan  |  25 | Delhi     | 1500.00 |
|  3 | kaushik |  23 | Kota      | 2000.00 |
+----+---------+-----+-----------+---------+

Si vous utilisez un serveur Oracle, le bloc de code suivant a un exemple équivalent.

SQL> SELECT * FROM CUSTOMERS
WHERE ROWNUM <= 3;

Cela produirait le résultat suivant -

+----+---------+-----+-----------+---------+
| ID | NAME    | AGE | ADDRESS   | SALARY  |
+----+---------+-----+-----------+---------+
|  1 | Ramesh  |  32 | Ahmedabad | 2000.00 |
|  2 | Khilan  |  25 | Delhi     | 1500.00 |
|  3 | kaushik |  23 | Kota      | 2000.00 |
+----+---------+-----+-----------+---------+

SQL - Clause ORDER BY

Le SQL ORDER BYLa clause est utilisée pour trier les données par ordre croissant ou décroissant, en fonction d'une ou plusieurs colonnes. Certaines bases de données trient les résultats de la requête dans un ordre croissant par défaut.

Syntaxe

La syntaxe de base de la clause ORDER BY est la suivante -

SELECT column-list 
FROM table_name 
[WHERE condition] 
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

Vous pouvez utiliser plusieurs colonnes dans la clause ORDER BY. Assurez-vous que la colonne que vous utilisez pour trier cette colonne doit être dans la liste des colonnes.

Exemple

Considérez la table CUSTOMERS ayant les enregistrements suivants -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Le bloc de code suivant a un exemple, qui trierait le résultat dans un ordre croissant par le NOM et le SALAIRE -

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME, SALARY;

Cela produirait le résultat suivant -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

Le bloc de code suivant a un exemple, qui trierait le résultat dans l'ordre décroissant par NOM.

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME DESC;

Cela produirait le résultat suivant -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
+----+----------+-----+-----------+----------+

SQL - Grouper par

Le SQL GROUP BYLa clause est utilisée en collaboration avec l'instruction SELECT pour organiser des données identiques en groupes. Cette clause GROUP BY suit la clause WHERE dans une instruction SELECT et précède la clause ORDER BY.

Syntaxe

La syntaxe de base d'une clause GROUP BY est indiquée dans le bloc de code suivant. La clause GROUP BY doit suivre les conditions de la clause WHERE et doit précéder la clause ORDER BY si elle est utilisée.

SELECT column1, column2
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2
ORDER BY column1, column2

Exemple

Considérez que la table CUSTOMERS contient les enregistrements suivants -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Si vous souhaitez connaître le montant total du salaire de chaque client, la requête GROUP BY serait la suivante.

SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS
   GROUP BY NAME;

Cela produirait le résultat suivant -

+----------+-------------+
| NAME     | SUM(SALARY) |
+----------+-------------+
| Chaitali |     6500.00 |
| Hardik   |     8500.00 |
| kaushik  |     2000.00 |
| Khilan   |     1500.00 |
| Komal    |     4500.00 |
| Muffy    |    10000.00 |
| Ramesh   |     2000.00 |
+----------+-------------+

Maintenant, regardons une table où la table CUSTOMERS a les enregistrements suivants avec des noms en double -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Ramesh   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | kaushik  |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Maintenant, si vous voulez connaître le montant total du salaire de chaque client, la requête GROUP BY serait la suivante -

SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS
   GROUP BY NAME;

Cela produirait le résultat suivant -

+---------+-------------+
| NAME    | SUM(SALARY) |
+---------+-------------+
| Hardik  |     8500.00 |
| kaushik |     8500.00 |
| Komal   |     4500.00 |
| Muffy   |    10000.00 |
| Ramesh  |     3500.00 |
+---------+-------------+

SQL - Mot-clé distinct

Le SQL DISTINCT Le mot-clé est utilisé conjointement avec l'instruction SELECT pour éliminer tous les enregistrements en double et récupérer uniquement les enregistrements uniques.

Il peut y avoir une situation où vous avez plusieurs enregistrements en double dans une table. Lors de la récupération de ces enregistrements, il est plus judicieux de récupérer uniquement ces enregistrements uniques au lieu de récupérer les enregistrements en double.

Syntaxe

La syntaxe de base du mot clé DISTINCT pour éliminer les enregistrements en double est la suivante -

SELECT DISTINCT column1, column2,.....columnN 
FROM table_name
WHERE [condition]

Exemple

Considérez la table CUSTOMERS ayant les enregistrements suivants -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Tout d'abord, voyons comment la requête SELECT suivante renvoie les enregistrements de salaire en double.

SQL> SELECT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Cela produirait le résultat suivant, où le salaire (2000) vient deux fois, ce qui est un enregistrement en double de la table d'origine.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

Maintenant, utilisons le mot clé DISTINCT avec la requête SELECT ci-dessus, puis voyons le résultat.

SQL> SELECT DISTINCT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Cela produirait le résultat suivant où nous n'avons aucune entrée en double.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

SQL - TRIER les résultats

Le SQL ORDER BYLa clause est utilisée pour trier les données par ordre croissant ou décroissant, en fonction d'une ou plusieurs colonnes. Certaines bases de données trient les résultats de la requête dans un ordre croissant par défaut.

Syntaxe

La syntaxe de base de la clause ORDER BY qui serait utilisée pour trier le résultat dans un ordre croissant ou décroissant est la suivante -

SELECT column-list 
FROM table_name 
[WHERE condition] 
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

Vous pouvez utiliser plusieurs colonnes dans la clause ORDER BY. Assurez-vous que quelle que soit la colonne que vous utilisez pour trier, cette colonne doit être dans la liste des colonnes.

Exemple

Considérez la table CUSTOMERS ayant les enregistrements suivants -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Voici un exemple qui trierait le résultat dans un ordre croissant par NOM et SALAIRE.

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME, SALARY;

Cela produirait le résultat suivant -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

Le bloc de code suivant a un exemple, qui trierait le résultat dans un ordre décroissant par NOM.

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME DESC;

Cela produirait le résultat suivant -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
+----+----------+-----+-----------+----------+

Pour récupérer les lignes avec leur propre ordre préféré, la requête SELECT utilisée serait la suivante -

SQL> SELECT * FROM CUSTOMERS
   ORDER BY (CASE ADDRESS
   WHEN 'DELHI' 	 THEN 1
   WHEN 'BHOPAL' 	 THEN 2
   WHEN 'KOTA' 	 THEN 3
   WHEN 'AHMEDABAD' THEN 4
   WHEN 'MP' 	THEN 5
   ELSE 100 END) ASC, ADDRESS DESC;

Cela produirait le résultat suivant -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

Cela triera les clients par ADRESSE dans votre ownoOrderde préférence d'abord et dans un ordre naturel pour les adresses restantes. De plus, les adresses restantes seront triées dans l'ordre alphabétique inverse.

SQL - Contraintes

Les contraintes sont les règles appliquées aux colonnes de données d'une table. Ceux-ci sont utilisés pour limiter le type de données qui peuvent entrer dans une table. Cela garantit l'exactitude et la fiabilité des données de la base de données.

Les contraintes peuvent être au niveau de la colonne ou au niveau de la table. Les contraintes au niveau de la colonne ne sont appliquées qu'à une seule colonne, tandis que les contraintes au niveau de la table sont appliquées à l'ensemble du tableau.

Voici quelques-unes des contraintes les plus couramment utilisées disponibles dans SQL. Ces contraintes ont déjà été discutées dans le chapitre SQL - SGBDR Concepts , mais il vaut la peine de les réviser à ce stade.

• NOT NULL Contrainte - Garantit qu'une colonne ne peut pas avoir la valeur NULL.

• Contrainte DEFAULT - Fournit une valeur par défaut pour une colonne lorsqu'aucune n'est spécifiée.

• Contrainte UNIQUE - Garantit que toutes les valeurs d'une colonne sont différentes.

• Clé PRIMAIRE - Identifie de manière unique chaque ligne / enregistrement dans une table de base de données.

• FOREIGN Key - Identifie de manière unique une ligne / un enregistrement dans n'importe quelle table de base de données donnée.

• Contrainte CHECK - La contrainte CHECK garantit que toutes les valeurs d'une colonne remplissent certaines conditions.

• INDEX - Utilisé pour créer et récupérer très rapidement des données de la base de données.

Les contraintes peuvent être spécifiées lorsqu'une table est créée avec l'instruction CREATE TABLE ou vous pouvez utiliser l'instruction ALTER TABLE pour créer des contraintes même après la création de la table.

Suppression des contraintes

Toute contrainte que vous avez définie peut être supprimée à l'aide de la commande ALTER TABLE avec l'option DROP CONSTRAINT.

Par exemple, pour supprimer la contrainte de clé primaire dans la table EMPLOYEES, vous pouvez utiliser la commande suivante.

ALTER TABLE EMPLOYEES DROP CONSTRAINT EMPLOYEES_PK;

Certaines implémentations peuvent fournir des raccourcis pour supprimer certaines contraintes. Par exemple, pour supprimer la contrainte de clé primaire pour une table dans Oracle, vous pouvez utiliser la commande suivante.

ALTER TABLE EMPLOYEES DROP PRIMARY KEY;

Certaines implémentations vous permettent de désactiver les contraintes. Au lieu de supprimer définitivement une contrainte de la base de données, vous souhaiterez peut-être désactiver temporairement la contrainte, puis l'activer ultérieurement.

Contraintes d'intégrité

Des contraintes d'intégrité sont utilisées pour garantir l'exactitude et la cohérence des données dans une base de données relationnelle. L'intégrité des données est gérée dans une base de données relationnelle à travers le concept d'intégrité référentielle.

Il existe de nombreux types de contraintes d'intégrité qui jouent un rôle dans Referential Integrity (RI). Ces contraintes incluent la clé primaire, la clé étrangère, les contraintes uniques et d'autres contraintes mentionnées ci-dessus.

SQL - Utilisation des jointures

Le SQL JoinsLa clause est utilisée pour combiner des enregistrements de deux ou plusieurs tables dans une base de données. Un JOIN est un moyen de combiner des champs de deux tables en utilisant des valeurs communes à chacune.

Considérez les deux tableaux suivants -

Table 1 - Table CLIENTS

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - Table des COMMANDES

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Maintenant, joignons ces deux tables dans notre instruction SELECT comme indiqué ci-dessous.

SQL> SELECT ID, NAME, AGE, AMOUNT
   FROM CUSTOMERS, ORDERS
   WHERE  CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Cela produirait le résultat suivant.

+----+----------+-----+--------+
| ID | NAME     | AGE | AMOUNT |
+----+----------+-----+--------+
|  3 | kaushik  |  23 |   3000 |
|  3 | kaushik  |  23 |   1500 |
|  2 | Khilan   |  25 |   1560 |
|  4 | Chaitali |  25 |   2060 |
+----+----------+-----+--------+

Ici, il est à noter que la jointure est effectuée dans la clause WHERE. Plusieurs opérateurs peuvent être utilisés pour joindre des tables, tels que =, <,>, <>, <=,> =,! =, BETWEEN, LIKE et NOT; ils peuvent tous être utilisés pour joindre des tables. Cependant, l'opérateur le plus courant est le symbole égal à.

Il existe différents types de jointures disponibles dans SQL -

• INNER JOIN - renvoie des lignes lorsqu'il y a une correspondance dans les deux tables.

• LEFT JOIN - renvoie toutes les lignes de la table de gauche, même s'il n'y a pas de correspondance dans la table de droite.

• RIGHT JOIN - renvoie toutes les lignes de la table de droite, même s'il n'y a pas de correspondance dans la table de gauche.

• FULL JOIN - retourne des lignes lorsqu'il y a une correspondance dans l'une des tables.

• SELF JOIN - est utilisé pour joindre une table à elle-même comme si la table était deux tables, renommant temporairement au moins une table dans l'instruction SQL.

• CARTESIAN JOIN - renvoie le produit cartésien des ensembles d'enregistrements des deux tables jointes ou plus.

Examinons maintenant chacune de ces jointures en détail.

SQL - CLAUSE UNIONS

La clause / l'opérateur SQL UNION est utilisé pour combiner les résultats de deux ou plusieurs instructions SELECT sans renvoyer de lignes dupliquées.

Pour utiliser cette clause UNION, chaque instruction SELECT doit avoir

• Le même nombre de colonnes sélectionnées
• Le même nombre d'expressions de colonne
• Le même type de données et
• Les avoir dans le même ordre

Mais ils n'ont pas besoin d'être de la même longueur.

Syntaxe

La syntaxe de base d'un UNION la clause est la suivante -

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

Ici, la condition donnée peut être n'importe quelle expression donnée en fonction de vos besoins.

Exemple

Considérez les deux tableaux suivants.

Table 1 - Le tableau CLIENTS est le suivant.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - Le tableau des COMMANDES est le suivant.

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Maintenant, joignons ces deux tables dans notre instruction SELECT comme suit -

SQL> SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   LEFT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
UNION
   SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   RIGHT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Cela produirait le résultat suivant -

+------+----------+--------+---------------------+
| ID   | NAME     | AMOUNT | DATE                |
+------+----------+--------+---------------------+
|    1 | Ramesh   |   NULL | NULL                |
|    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
|    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
|    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
|    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
|    5 | Hardik   |   NULL | NULL                |
|    6 | Komal    |   NULL | NULL                |
|    7 | Muffy    |   NULL | NULL                |
+------+----------+--------+---------------------+

La clause UNION ALL

L'opérateur UNION ALL est utilisé pour combiner les résultats de deux instructions SELECT comprenant des lignes dupliquées.

Les mêmes règles qui s'appliquent à la clause UNION s'appliqueront à l'opérateur UNION ALL.

Syntaxe

La syntaxe de base du UNION ALL est comme suit.

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION ALL

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

Ici, la condition donnée peut être n'importe quelle expression donnée en fonction de vos besoins.

Exemple

Considérez les deux tableaux suivants,

Table 1 - Le tableau CLIENTS est le suivant.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - Le tableau ORDERS est le suivant.

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Maintenant, joignons ces deux tables dans notre instruction SELECT comme suit -

SQL> SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   LEFT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
UNION ALL
   SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   RIGHT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Cela produirait le résultat suivant -

+------+----------+--------+---------------------+
| ID   | NAME     | AMOUNT | DATE                |
+------+----------+--------+---------------------+
|    1 | Ramesh   |   NULL | NULL                |
|    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
|    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
|    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
|    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
|    5 | Hardik   |   NULL | NULL                |
|    6 | Komal    |   NULL | NULL                |
|    7 | Muffy    |   NULL | NULL                |
|    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
|    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
|    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
|    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+

Il existe deux autres clauses (c'est-à-dire des opérateurs), qui sont comme la clause UNION.

• Clause SQL INTERSECT - Ceci est utilisé pour combiner deux instructions SELECT, mais renvoie uniquement les lignes de la première instruction SELECT qui sont identiques à une ligne de la deuxième instruction SELECT.

• Clause SQL EXCEPT - Cela combine deux instructions SELECT et renvoie les lignes de la première instruction SELECT qui ne sont pas renvoyées par la seconde instruction SELECT.

SQL - Valeurs NULL

Le SQL NULLest le terme utilisé pour représenter une valeur manquante. Une valeur NULL dans une table est une valeur dans un champ qui semble vide.

Un champ avec une valeur NULL est un champ sans valeur. Il est très important de comprendre qu'une valeur NULL est différente d'une valeur zéro ou d'un champ qui contient des espaces.

Syntaxe

La syntaxe de base de NULL lors de la création d'une table.

SQL> CREATE TABLE CUSTOMERS(
   ID   INT              NOT NULL,
   NAME VARCHAR (20)     NOT NULL,
   AGE  INT              NOT NULL,
   ADDRESS  CHAR (25) ,
   SALARY   DECIMAL (18, 2),       
   PRIMARY KEY (ID)
);

Ici, NOT NULLsignifie que la colonne doit toujours accepter une valeur explicite du type de données donné. Il y a deux colonnes où nous n'avons pas utilisé NOT NULL, ce qui signifie que ces colonnes pourraient être NULL.

Un champ avec une valeur NULL est celui qui a été laissé vide lors de la création de l'enregistrement.

Exemple

La valeur NULL peut entraîner des problèmes lors de la sélection de données. Cependant, parce que lorsque vous comparez une valeur inconnue à une autre valeur, le résultat est toujours inconnu et n'est pas inclus dans les résultats. Vous devez utiliser leIS NULL ou IS NOT NULL opérateurs pour vérifier une valeur NULL.

Considérez la table CUSTOMERS suivante contenant les enregistrements comme indiqué ci-dessous.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |          |
|  7 | Muffy    |  24 | Indore    |          |
+----+----------+-----+-----------+----------+

Maintenant, voici l'utilisation du IS NOT NULLopérateur.

SQL> SELECT  ID, NAME, AGE, ADDRESS, SALARY
   FROM CUSTOMERS
   WHERE SALARY IS NOT NULL;

Cela produirait le résultat suivant -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
+----+----------+-----+-----------+----------+

Maintenant, voici l'utilisation du IS NULL opérateur.

SQL> SELECT  ID, NAME, AGE, ADDRESS, SALARY
   FROM CUSTOMERS
   WHERE SALARY IS NULL;

Cela produirait le résultat suivant -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  6 | Komal    |  22 | MP        |          |
|  7 | Muffy    |  24 | Indore    |          |
+----+----------+-----+-----------+----------+

SQL - Syntaxe d'alias

Vous pouvez renommer temporairement une table ou une colonne en donnant un autre nom appelé Alias. L'utilisation d'alias de table consiste à renommer une table dans une instruction SQL spécifique. Le changement de nom est une modification temporaire et le nom réel de la table ne change pas dans la base de données. Les alias de colonne sont utilisés pour renommer les colonnes d'une table dans le but d'une requête SQL particulière.

Syntaxe

La syntaxe de base d'un table alias est le suivant.

SELECT column1, column2....
FROM table_name AS alias_name
WHERE [condition];

La syntaxe de base d'un column alias est le suivant.

SELECT column_name AS alias_name
FROM table_name
WHERE [condition];

Exemple

Considérez les deux tableaux suivants.

Table 1 - Le tableau CLIENTS est le suivant.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - Le tableau des COMMANDES est le suivant.

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Maintenant, le bloc de code suivant montre l'utilisation d'un table alias.

SQL> SELECT C.ID, C.NAME, C.AGE, O.AMOUNT 
   FROM CUSTOMERS AS C, ORDERS AS O
   WHERE  C.ID = O.CUSTOMER_ID;

Cela produirait le résultat suivant.

+----+----------+-----+--------+
| ID | NAME     | AGE | AMOUNT |
+----+----------+-----+--------+
|  3 | kaushik  |  23 |   3000 |
|  3 | kaushik  |  23 |   1500 |
|  2 | Khilan   |  25 |   1560 |
|  4 | Chaitali |  25 |   2060 |
+----+----------+-----+--------+

Voici l'utilisation d'un column alias.

SQL> SELECT  ID AS CUSTOMER_ID, NAME AS CUSTOMER_NAME
   FROM CUSTOMERS
   WHERE SALARY IS NOT NULL;

Cela produirait le résultat suivant.

+-------------+---------------+
| CUSTOMER_ID | CUSTOMER_NAME |
+-------------+---------------+
|           1 | Ramesh        |
|           2 | Khilan        |
|           3 | kaushik       |
|           4 | Chaitali      |
|           5 | Hardik        |
|           6 | Komal         |
|           7 | Muffy         |
+-------------+---------------+

SQL - Index

Les index sont special lookup tablesque le moteur de recherche de base de données peut utiliser pour accélérer la récupération des données. En termes simples, un index est un pointeur vers des données dans une table. Un index dans une base de données est très similaire à un index au dos d'un livre.

Par exemple, si vous souhaitez référencer toutes les pages d'un livre qui traite d'un certain sujet, vous vous référez d'abord à l'index, qui répertorie toutes les rubriques par ordre alphabétique et sont ensuite référencées à un ou plusieurs numéros de page spécifiques.

Un index permet d'accélérer SELECT requêtes et WHERE clauses, mais cela ralentit la saisie des données, avec le UPDATE et le INSERTdéclarations. Les index peuvent être créés ou supprimés sans effet sur les données.

La création d'un index implique la CREATE INDEX , qui vous permet de nommer l'index, de spécifier la table et la ou les colonnes à indexer, et d'indiquer si l'index est dans un ordre croissant ou décroissant.

Les index peuvent également être uniques, comme le UNIQUE contrainte, en ce que l'index empêche les entrées en double dans la colonne ou la combinaison de colonnes sur laquelle se trouve un index.

La commande CREATE INDEX

La syntaxe de base d'un CREATE INDEX est comme suit.

CREATE INDEX index_name ON table_name;

Index à une seule colonne

Un index à une seule colonne est créé sur la base d'une seule colonne de table. La syntaxe de base est la suivante.

CREATE INDEX index_name
ON table_name (column_name);

Index uniques

Les index uniques sont utilisés non seulement pour les performances, mais également pour l'intégrité des données. Un index unique ne permet pas d'insérer des valeurs en double dans la table. La syntaxe de base est la suivante.

CREATE UNIQUE INDEX index_name
on table_name (column_name);

Index composites

Un index composite est un index sur deux ou plusieurs colonnes d'une table. Sa syntaxe de base est la suivante.

CREATE INDEX index_name
on table_name (column1, column2);

Que vous souhaitiez créer un index à une seule colonne ou un index composite, prenez en compte la ou les colonnes que vous pouvez utiliser très fréquemment dans la clause WHERE d'une requête comme conditions de filtre.

Si une seule colonne est utilisée, un index à une seule colonne doit être le choix. Si deux colonnes ou plus sont fréquemment utilisées dans la clause WHERE comme filtres, l'index composite serait le meilleur choix.

Index implicites

Les index implicites sont des index qui sont automatiquement créés par le serveur de base de données lors de la création d'un objet. Les index sont automatiquement créés pour les contraintes de clé primaire et les contraintes uniques.

La commande DROP INDEX

Un index peut être supprimé à l'aide de SQL DROPcommander. Des précautions doivent être prises lors de la suppression d'un index car les performances peuvent ralentir ou s'améliorer.

La syntaxe de base est la suivante -

DROP INDEX index_name;

Vous pouvez consulter le chapitre sur les contraintes INDEX pour voir quelques exemples réels sur les index.

Quand faut-il éviter les index?

Bien que les index soient destinés à améliorer les performances d'une base de données, il y a des moments où ils doivent être évités.

Les directives suivantes indiquent quand l'utilisation d'un index doit être reconsidérée.

• Les index ne doivent pas être utilisés sur de petites tables.

• Tables qui ont des mises à jour par lots fréquentes et importantes ou des opérations d'insertion.

• Les index ne doivent pas être utilisés sur des colonnes contenant un nombre élevé de valeurs NULL.

• Les colonnes fréquemment manipulées ne doivent pas être indexées.

SQL - Commande ALTER TABLE

Le SQL ALTER TABLELa commande est utilisée pour ajouter, supprimer ou modifier des colonnes dans une table existante. Vous devez également utiliser la commande ALTER TABLE pour ajouter et supprimer diverses contraintes sur une table existante.

Syntaxe

La syntaxe de base d'une commande ALTER TABLE pour ajouter un New Column dans une table existante est la suivante.

ALTER TABLE table_name ADD column_name datatype;

La syntaxe de base d'une commande ALTER TABLE pour DROP COLUMN dans une table existante est la suivante.

ALTER TABLE table_name DROP COLUMN column_name;

La syntaxe de base d'une commande ALTER TABLE pour modifier le DATA TYPE d'une colonne dans un tableau est comme suit.

ALTER TABLE table_name MODIFY COLUMN column_name datatype;

La syntaxe de base d'une commande ALTER TABLE pour ajouter un NOT NULL La contrainte à une colonne dans une table est la suivante.

ALTER TABLE table_name MODIFY column_name datatype NOT NULL;

La syntaxe de base d'ALTER TABLE pour ADD UNIQUE CONSTRAINT à une table est comme suit.

ALTER TABLE table_name 
ADD CONSTRAINT MyUniqueConstraint UNIQUE(column1, column2...);

La syntaxe de base d'une commande ALTER TABLE pour ADD CHECK CONSTRAINT à une table est comme suit.

ALTER TABLE table_name 
ADD CONSTRAINT MyUniqueConstraint CHECK (CONDITION);

La syntaxe de base d'une commande ALTER TABLE pour ADD PRIMARY KEY la contrainte à une table est la suivante.

ALTER TABLE table_name 
ADD CONSTRAINT MyPrimaryKey PRIMARY KEY (column1, column2...);

La syntaxe de base d'une commande ALTER TABLE pour DROP CONSTRAINT à partir d'une table est comme suit.

ALTER TABLE table_name 
DROP CONSTRAINT MyUniqueConstraint;

Si vous utilisez MySQL, le code est le suivant -

ALTER TABLE table_name 
DROP INDEX MyUniqueConstraint;

La syntaxe de base d'une commande ALTER TABLE pour DROP PRIMARY KEY la contrainte d'une table est la suivante.

ALTER TABLE table_name 
DROP CONSTRAINT MyPrimaryKey;

Si vous utilisez MySQL, le code est le suivant -

ALTER TABLE table_name 
DROP PRIMARY KEY;

Exemple

Considérez la table CUSTOMERS ayant les enregistrements suivants -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Voici l'exemple pour AJOUTER un New Column à une table existante -

ALTER TABLE CUSTOMERS ADD SEX char(1);

Désormais, la table CUSTOMERS est modifiée et les éléments suivants sont générés par l'instruction SELECT.

+----+---------+-----+-----------+----------+------+
| ID | NAME    | AGE | ADDRESS   | SALARY   | SEX  |
+----+---------+-----+-----------+----------+------+
|  1 | Ramesh  |  32 | Ahmedabad |  2000.00 | NULL |
|  2 | Ramesh  |  25 | Delhi     |  1500.00 | NULL |
|  3 | kaushik |  23 | Kota      |  2000.00 | NULL |
|  4 | kaushik |  25 | Mumbai    |  6500.00 | NULL |
|  5 | Hardik  |  27 | Bhopal    |  8500.00 | NULL |
|  6 | Komal   |  22 | MP        |  4500.00 | NULL |
|  7 | Muffy   |  24 | Indore    | 10000.00 | NULL |
+----+---------+-----+-----------+----------+------+

Voici l'exemple pour supprimer la colonne de sexe de la table existante.

ALTER TABLE CUSTOMERS DROP SEX;

Maintenant, la table CUSTOMERS est modifiée et ce qui suit serait la sortie de l'instruction SELECT.

+----+---------+-----+-----------+----------+
| ID | NAME    | AGE | ADDRESS   | SALARY   |
+----+---------+-----+-----------+----------+
|  1 | Ramesh  |  32 | Ahmedabad |  2000.00 |
|  2 | Ramesh  |  25 | Delhi     |  1500.00 |
|  3 | kaushik |  23 | Kota      |  2000.00 |
|  4 | kaushik |  25 | Mumbai    |  6500.00 |
|  5 | Hardik  |  27 | Bhopal    |  8500.00 |
|  6 | Komal   |  22 | MP        |  4500.00 |
|  7 | Muffy   |  24 | Indore    | 10000.00 |
+----+---------+-----+-----------+----------+

SQL - Commande TRUNCATE TABLE

Le SQL TRUNCATE TABLE La commande est utilisée pour supprimer des données complètes d'une table existante.

Vous pouvez également utiliser la commande DROP TABLE pour supprimer la table complète, mais cela supprimerait la structure de table complète de la base de données et vous devrez recréer cette table une fois de plus si vous souhaitez stocker des données.

Syntaxe

La syntaxe de base d'un TRUNCATE TABLE La commande est la suivante.

TRUNCATE TABLE  table_name;

Exemple

Considérez une table CUSTOMERS contenant les enregistrements suivants -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Voici l'exemple d'une commande Tronquer.

SQL > TRUNCATE TABLE CUSTOMERS;

Maintenant, la table CUSTOMERS est tronquée et la sortie de l'instruction SELECT sera comme indiqué dans le bloc de code ci-dessous -

SQL> SELECT * FROM CUSTOMERS;
Empty set (0.00 sec)

SQL - Utilisation des vues

Une vue n'est rien de plus qu'une instruction SQL stockée dans la base de données avec un nom associé. Une vue est en fait une composition d'une table sous la forme d'une requête SQL prédéfinie.

Une vue peut contenir toutes les lignes d'une table ou sélectionner des lignes dans une table. Une vue peut être créée à partir d'une ou de plusieurs tables qui dépendent de la requête SQL écrite pour créer une vue.

Les vues, qui sont un type de tables virtuelles, permettent aux utilisateurs d'effectuer les opérations suivantes:

• Structurez les données d'une manière que les utilisateurs ou les classes d'utilisateurs trouvent naturelle ou intuitive.

• Restreignez l'accès aux données de manière à ce qu'un utilisateur puisse voir et (parfois) modifier exactement ce dont il a besoin et pas plus.

• Résumez les données de diverses tables qui peuvent être utilisées pour générer des rapports.

Créer des vues

Les vues de base de données sont créées à l'aide de CREATE VIEWdéclaration. Les vues peuvent être créées à partir d'une seule table, de plusieurs tables ou d'une autre vue.

Pour créer une vue, un utilisateur doit disposer du privilège système approprié en fonction de l'implémentation spécifique.

Les bases CREATE VIEW la syntaxe est la suivante -

CREATE VIEW view_name AS
SELECT column1, column2.....
FROM table_name
WHERE [condition];

Vous pouvez inclure plusieurs tables dans votre instruction SELECT de la même manière que vous les utilisez dans une requête SQL SELECT normale.

Exemple

Considérez la table CUSTOMERS ayant les enregistrements suivants -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Voici un exemple pour créer une vue à partir de la table CUSTOMERS. Cette vue serait utilisée pour avoir le nom et l'âge du client de la table CUSTOMERS.

SQL > CREATE VIEW CUSTOMERS_VIEW AS
SELECT name, age
FROM  CUSTOMERS;

Vous pouvez maintenant interroger CUSTOMERS_VIEW de la même manière que vous interrogez une table réelle. Voici un exemple pour le même.

SQL > SELECT * FROM CUSTOMERS_VIEW;

Cela produirait le résultat suivant.

+----------+-----+
| name     | age |
+----------+-----+
| Ramesh   |  32 |
| Khilan   |  25 |
| kaushik  |  23 |
| Chaitali |  25 |
| Hardik   |  27 |
| Komal    |  22 |
| Muffy    |  24 |
+----------+-----+

L'OPTION AVEC CHECK

L'OPTION WITH CHECK est une option d'instruction CREATE VIEW. L'objectif de l'option WITH CHECK OPTION est de garantir que toutes les mises à jour et les insertions satisfont aux conditions de la définition de vue.

S'ils ne satisfont pas aux conditions, UPDATE ou INSERT renvoie une erreur.

Le bloc de code suivant présente un exemple de création de la même vue CUSTOMERS_VIEW avec l'option WITH CHECK OPTION.

CREATE VIEW CUSTOMERS_VIEW AS
SELECT name, age
FROM  CUSTOMERS
WHERE age IS NOT NULL
WITH CHECK OPTION;

L'OPTION WITH CHECK dans ce cas doit refuser l'entrée de toute valeur NULL dans la colonne AGE de la vue, car la vue est définie par des données qui n'ont pas de valeur NULL dans la colonne AGE.

Mettre à jour une vue

Une vue peut être mise à jour sous certaines conditions qui sont données ci-dessous -

• La clause SELECT ne peut pas contenir le mot clé DISTINCT.

• La clause SELECT ne peut pas contenir de fonctions récapitulatives.

• La clause SELECT ne peut pas contenir de fonctions d'ensemble.

• La clause SELECT ne peut pas contenir d'opérateurs d'ensemble.

• La clause SELECT ne peut pas contenir de clause ORDER BY.

• La clause FROM ne peut pas contenir plusieurs tables.

• La clause WHERE ne peut pas contenir de sous-requêtes.

• La requête ne peut pas contenir GROUP BY ou HAVING.

• Les colonnes calculées peuvent ne pas être mises à jour.

• Toutes les colonnes NOT NULL de la table de base doivent être incluses dans la vue pour que la requête INSERT fonctionne.

Ainsi, si une vue satisfait toutes les règles mentionnées ci-dessus, vous pouvez la mettre à jour. Le bloc de code suivant a un exemple pour mettre à jour l'âge de Ramesh.

SQL > UPDATE CUSTOMERS_VIEW
   SET AGE = 35
   WHERE name = 'Ramesh';

Cela mettrait finalement à jour la table de base CLIENTS et la même chose se refléterait dans la vue elle-même. Maintenant, essayez d'interroger la table de base et l'instruction SELECT produirait le résultat suivant.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Insertion de lignes dans une vue

Des lignes de données peuvent être insérées dans une vue. Les mêmes règles qui s'appliquent à la commande UPDATE s'appliquent également à la commande INSERT.

Ici, nous ne pouvons pas insérer de lignes dans CUSTOMERS_VIEW car nous n'avons pas inclus toutes les colonnes NOT NULL dans cette vue, sinon vous pouvez insérer des lignes dans une vue de la même manière que vous les insérez dans un tableau.

Suppression de lignes dans une vue

Des lignes de données peuvent être supprimées d'une vue. Les mêmes règles qui s'appliquent aux commandes UPDATE et INSERT s'appliquent à la commande DELETE.

Voici un exemple pour supprimer un enregistrement ayant AGE = 22.

SQL > DELETE FROM CUSTOMERS_VIEW
   WHERE age = 22;

Cela supprimerait finalement une ligne de la table de base CUSTOMERS et la même chose se refléterait dans la vue elle-même. Maintenant, essayez d'interroger la table de base et l'instruction SELECT produirait le résultat suivant.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Suppression de vues

De toute évidence, là où vous avez une vue, vous avez besoin d'un moyen de supprimer la vue si elle n'est plus nécessaire. La syntaxe est très simple et est donnée ci-dessous -

DROP VIEW view_name;

Voici un exemple pour supprimer CUSTOMERS_VIEW de la table CUSTOMERS.

DROP VIEW CUSTOMERS_VIEW;

SQL - Clause

le HAVING Clause vous permet de spécifier des conditions qui filtrent les résultats du groupe qui apparaissent dans les résultats.

La clause WHERE place des conditions sur les colonnes sélectionnées, tandis que la clause HAVING place des conditions sur les groupes créés par la clause GROUP BY.

Syntaxe

Le bloc de code suivant montre la position de la clause HAVING dans une requête.

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

La clause HAVING doit suivre la clause GROUP BY dans une requête et doit également précéder la clause ORDER BY si elle est utilisée. Le bloc de code suivant a la syntaxe de l'instruction SELECT, y compris la clause HAVING -

SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2

Exemple

Considérez la table CUSTOMERS ayant les enregistrements suivants.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Voici un exemple, qui afficherait un enregistrement pour un nombre d'âge similaire qui serait supérieur ou égal à 2.

SQL > SELECT ID, NAME, AGE, ADDRESS, SALARY
FROM CUSTOMERS
GROUP BY age
HAVING COUNT(age) >= 2;

Cela produirait le résultat suivant -

+----+--------+-----+---------+---------+
| ID | NAME   | AGE | ADDRESS | SALARY  |
+----+--------+-----+---------+---------+
|  2 | Khilan |  25 | Delhi   | 1500.00 |
+----+--------+-----+---------+---------+

SQL - Transactions

Une transaction est une unité de travail effectuée sur une base de données. Les transactions sont des unités ou des séquences de travail accomplies dans un ordre logique, que ce soit de manière manuelle par un utilisateur ou automatiquement par une sorte de programme de base de données.

Une transaction est la propagation d'une ou plusieurs modifications dans la base de données. Par exemple, si vous créez un enregistrement, mettez à jour un enregistrement ou supprimez un enregistrement de la table, vous effectuez une transaction sur cette table. Il est important de contrôler ces transactions pour garantir l'intégrité des données et gérer les erreurs de base de données.

En pratique, vous regrouperez de nombreuses requêtes SQL dans un groupe et vous les exécuterez toutes ensemble dans le cadre d'une transaction.

Propriétés des transactions

Les transactions ont les quatre propriétés standard suivantes, généralement désignées par l'acronyme ACID.

• Atomicity- s'assure que toutes les opérations au sein de l'unité de travail sont menées à bien. Sinon, la transaction est abandonnée au point d'échec et toutes les opérations précédentes sont restaurées à leur état antérieur.

• Consistency - garantit que la base de données change correctement d'état après une transaction validée avec succès.

• Isolation - permet aux transactions de fonctionner indépendamment et de manière transparente les unes des autres.

• Durability - garantit que le résultat ou l'effet d'une transaction validée persiste en cas de défaillance du système.

Contrôle des transactions

Les commandes suivantes sont utilisées pour contrôler les transactions.

• COMMIT - pour enregistrer les modifications.

• ROLLBACK - pour annuler les modifications.

• SAVEPOINT - crée des points au sein des groupes de transactions dans lesquels ROLLBACK.

• SET TRANSACTION - Place un nom sur une transaction.

Commandes de contrôle transactionnel

Les commandes de contrôle transactionnel ne sont utilisées qu'avec le DML Commandstels que - INSERT, UPDATE et DELETE uniquement. Ils ne peuvent pas être utilisés lors de la création ou de la suppression de tables car ces opérations sont automatiquement validées dans la base de données.

La commande COMMIT

La commande COMMIT est la commande transactionnelle utilisée pour enregistrer les modifications invoquées par une transaction dans la base de données.

La commande COMMIT est la commande transactionnelle utilisée pour enregistrer les modifications invoquées par une transaction dans la base de données. La commande COMMIT enregistre toutes les transactions dans la base de données depuis la dernière commande COMMIT ou ROLLBACK.

La syntaxe de la commande COMMIT est la suivante.

COMMIT;

Example

Considérez la table CUSTOMERS ayant les enregistrements suivants -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Voici un exemple qui supprimerait ces enregistrements de la table qui ont age = 25, puis COMMIT les modifications dans la base de données.

SQL> DELETE FROM CUSTOMERS
   WHERE AGE = 25;
SQL> COMMIT;

Ainsi, deux lignes de la table seraient supprimées et l'instruction SELECT produirait le résultat suivant.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

La commande ROLLBACK

La commande ROLLBACK est la commande transactionnelle utilisée pour annuler des transactions qui n'ont pas déjà été enregistrées dans la base de données. Cette commande ne peut être utilisée que pour annuler des transactions depuis la dernière commande COMMIT ou ROLLBACK a été émise.

La syntaxe d'une commande ROLLBACK est la suivante -

ROLLBACK;

Example

Considérez la table CUSTOMERS ayant les enregistrements suivants -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Voici un exemple, qui supprimerait ces enregistrements de la table qui ont l'âge = 25, puis ROLLBACK les modifications dans la base de données.

SQL> DELETE FROM CUSTOMERS
   WHERE AGE = 25;
SQL> ROLLBACK;

Ainsi, l'opération de suppression n'aurait pas d'impact sur la table et l'instruction SELECT produirait le résultat suivant.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

La commande SAVEPOINT

Un SAVEPOINT est un point dans une transaction où vous pouvez restaurer la transaction à un certain point sans annuler la transaction entière.

La syntaxe d'une commande SAVEPOINT est la suivante.

SAVEPOINT SAVEPOINT_NAME;

Cette commande sert uniquement à la création d'un SAVEPOINT parmi toutes les instructions transactionnelles. La commande ROLLBACK est utilisée pour annuler un groupe de transactions.

La syntaxe pour revenir à un SAVEPOINT est la suivante.

ROLLBACK TO SAVEPOINT_NAME;

Voici un exemple où vous prévoyez de supprimer les trois enregistrements différents de la table CUSTOMERS. Vous souhaitez créer un SAVEPOINT avant chaque suppression, afin de pouvoir ROLLBACK vers n'importe quel SAVEPOINT à tout moment pour ramener les données appropriées à leur état d'origine.

Example

Considérez la table CUSTOMERS ayant les enregistrements suivants.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Le bloc de code suivant contient la série d'opérations.

SQL> SAVEPOINT SP1;
Savepoint created.
SQL> DELETE FROM CUSTOMERS WHERE ID=1;
1 row deleted.
SQL> SAVEPOINT SP2;
Savepoint created.
SQL> DELETE FROM CUSTOMERS WHERE ID=2;
1 row deleted.
SQL> SAVEPOINT SP3;
Savepoint created.
SQL> DELETE FROM CUSTOMERS WHERE ID=3;
1 row deleted.

Maintenant que les trois suppressions ont eu lieu, supposons que vous avez changé d'avis et décidé de ROLLBACK vers le SAVEPOINT que vous avez identifié comme SP2. Étant donné que SP2 a été créé après la première suppression, les deux dernières suppressions sont annulées -

SQL> ROLLBACK TO SP2;
Rollback complete.

Notez que seule la première suppression a eu lieu depuis que vous êtes revenu au SP2.

SQL> SELECT * FROM CUSTOMERS;
+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+
6 rows selected.

La commande RELEASE SAVEPOINT

La commande RELEASE SAVEPOINT est utilisée pour supprimer un SAVEPOINT que vous avez créé.

La syntaxe d'une commande RELEASE SAVEPOINT est la suivante.

RELEASE SAVEPOINT SAVEPOINT_NAME;

Une fois qu'un SAVEPOINT a été libéré, vous ne pouvez plus utiliser la commande ROLLBACK pour annuler les transactions effectuées depuis le dernier SAVEPOINT.

La commande SET TRANSACTION

La commande SET TRANSACTION peut être utilisée pour lancer une transaction de base de données. Cette commande permet de spécifier les caractéristiques de la transaction qui suit. Par exemple, vous pouvez spécifier une transaction en lecture seule ou en lecture-écriture.

La syntaxe d'une commande SET TRANSACTION est la suivante.

SET TRANSACTION [ READ WRITE | READ ONLY ];

SQL - Opérateurs génériques

Nous avons déjà discuté de l'opérateur SQL LIKE, qui est utilisé pour comparer une valeur à des valeurs similaires à l'aide des opérateurs génériques.

SQL prend en charge deux opérateurs génériques en conjonction avec l'opérateur LIKE qui sont expliqués en détail dans le tableau suivant.

N ° Sr.	Caractère générique et description
1	The percent sign (%) Correspond à un ou plusieurs caractères. Note - MS Access utilise le caractère générique astérisque (*) au lieu du caractère générique signe pourcentage (%).
2	The underscore (_) Correspond à un caractère. Note - MS Access utilise un point d'interrogation (?) Au lieu du trait de soulignement (_) pour correspondre à n'importe quel caractère.

Le signe de pourcentage représente zéro, un ou plusieurs caractères. Le trait de soulignement représente un seul nombre ou un caractère. Ces symboles peuvent être utilisés dans des combinaisons.

Syntaxe

La syntaxe de base des opérateurs '%' et '_' est la suivante.

SELECT * FROM table_name
WHERE column LIKE 'XXXX%'

or 

SELECT * FROM table_name
WHERE column LIKE '%XXXX%'

or

SELECT * FROM table_name
WHERE column LIKE 'XXXX_'

or

SELECT * FROM table_name
WHERE column LIKE '_XXXX'

or

SELECT * FROM table_name
WHERE column LIKE '_XXXX_'

Vous pouvez combiner N nombre de conditions à l'aide des opérateurs AND ou OR. Ici, XXXX peut être n'importe quelle valeur numérique ou chaîne.

Exemple

Le tableau suivant contient un certain nombre d'exemples montrant la partie WHERE ayant différentes clauses LIKE avec les opérateurs '%' et '_'.

N ° Sr.	Déclaration et description
1	WHERE SALARY LIKE '200%' Recherche toutes les valeurs commençant par 200.
2	WHERE SALARY LIKE '%200%' Recherche toutes les valeurs qui ont 200 dans n'importe quelle position.
3	WHERE SALARY LIKE '_00%' Recherche toutes les valeurs qui ont 00 dans les deuxième et troisième positions.
4	WHERE SALARY LIKE '2_%_%' Recherche toutes les valeurs commençant par 2 et comportant au moins 3 caractères.
5	WHERE SALARY LIKE '%2' Recherche toutes les valeurs qui se terminent par 2.
6	WHERE SALARY LIKE '_2%3' Recherche toutes les valeurs qui ont un 2 en deuxième position et se terminent par un 3.
sept	WHERE SALARY LIKE '2___3' Recherche toutes les valeurs d'un nombre à cinq chiffres commençant par 2 et se terminant par 3.

Prenons un exemple réel, considérons la table CUSTOMERS ayant les enregistrements suivants.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Le bloc de code suivant est un exemple, qui afficherait tous les enregistrements de la table CUSTOMERS où le SALAIRE commence par 200.

SQL> SELECT * FROM CUSTOMERS
WHERE SALARY LIKE '200%';

Cela produirait le résultat suivant.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
+----+----------+-----+-----------+----------+

SQL - Fonctions de date

Le tableau suivant répertorie toutes les fonctions importantes liées à la date et à l'heure disponibles via SQL. Il existe diverses autres fonctions prises en charge par votre SGBDR. La liste donnée est basée sur le SGBDR MySQL.

N ° Sr.	Description de la fonction
1	AJOUTER () Ajoute des dates
2	AJOUTER DU TEMPS() Ajoute du temps
3	CONVERT_TZ () Convertit d'un fuseau horaire à un autre
4	CURDATE () Renvoie la date actuelle
5	CURRENT_DATE (), CURRENT_DATE Synonymes de CURDATE ()
6	CURRENT_TIME (), CURRENT_TIME Synonymes de CURTIME ()
sept	CURRENT_TIMESTAMP (), CURRENT_TIMESTAMP Synonymes de NOW ()
8	CURTIME () Renvoie l'heure actuelle
9	DATE_ADD () Ajoute deux dates
dix	FORMAT DE DATE() Formate la date comme spécifié
11	DATE_SUB () Soustrait deux dates
12	DATE() Extrait la partie date d'une expression de date ou d'heure
13	DATEDIFF () Soustrait deux dates
14	JOURNÉE() Synonyme de DAYOFMONTH ()
15	DAYNAME () Renvoie le nom du jour de la semaine
16	JOUR DU MOIS() Renvoie le jour du mois (1-31)
17	JOUR DE LA SEMAINE() Renvoie l'index du jour de la semaine de l'argument
18	DAYOFYEAR () Renvoie le jour de l'année (1-366)
19	EXTRAIT Extrait une partie d'une date
20	FROM_DAYS () Convertit un numéro de jour en date
21	FROM_UNIXTIME () Formate la date sous forme d'horodatage UNIX
22	HEURE() Extrait l'heure
23	DERNIER JOUR Renvoie le dernier jour du mois pour l'argument
24	LOCALTIME (), LOCALTIME Synonyme de NOW ()
25	LOCALTIMESTAMP, LOCALTIMESTAMP () Synonyme de NOW ()
26	MAKEDATE () Crée une date à partir de l'année et du jour de l'année
27	PRENDRE LE TEMPS PRENDRE LE TEMPS()
28	MICROSECONDE() Renvoie les microsecondes de l'argument
29	MINUTE() Renvoie la minute de l'argument
30	MOIS() Renvoie le mois à partir de la date passée
31	MONTHNAME () Renvoie le nom du mois
32	MAINTENANT() Renvoie la date et l'heure actuelles
33	PERIOD_ADD () Ajoute une période à un an-mois
34	PERIOD_DIFF () Renvoie le nombre de mois entre les périodes
35	TRIMESTRE() Renvoie le trimestre à partir d'un argument de date
36	SEC_TO_TIME () Convertit les secondes au format «HH: MM: SS»
37	SECONDE() Renvoie le deuxième (0-59)
38	STR_TO_DATE () Convertit une chaîne en date
39	SUBDATE () Lorsqu'il est invoqué avec trois arguments, un synonyme de DATE_SUB ()
40	SOUS-TEMPS () Soustrait les temps
41	SYSDATE () Renvoie l'heure à laquelle la fonction s'exécute
42	FORMAT DE L'HEURE() Formats en fonction du temps
43	TIME_TO_SEC () Renvoie l'argument converti en secondes
44	TEMPS() Extrait la partie temporelle de l'expression passée
45	TIMEDIFF () Soustrait le temps
46	HORAIRE () Avec un seul argument, cette fonction renvoie la date ou l'expression datetime. Avec deux arguments, la somme des arguments
47	TIMESTAMPADD () Ajoute un intervalle à une expression datetime
48	TIMESTAMPDIFF () Soustrait un intervalle d'une expression datetime
49	TO_DAYS () Renvoie l'argument de date converti en jours
50	UNIX_TIMESTAMP () Renvoie un horodatage UNIX
51	UTC_DATE () Renvoie la date UTC actuelle
52	UTC_TIME () Renvoie l'heure UTC actuelle
53	UTC_TIMESTAMP () Renvoie la date et l'heure UTC actuelles
54	LA SEMAINE() Renvoie le numéro de la semaine
55	JOUR DE LA SEMAINE() Renvoie l'index des jours de la semaine
56	SEMAINE D'ANNÉE () Renvoie la semaine calendaire de la date (1-53)
57	AN() Renvoie l'année
58	SEMAINE D'ANNÉE () Renvoie l'année et la semaine

ADDDATE (date, INTERVAL unité expr), ADDDATE (expr, jours)

Lorsqu'il est appelé avec la forme INTERVAL du deuxième argument, ADDDATE () est un synonyme de DATE_ADD (). La fonction associée SUBDATE () est un synonyme de DATE_SUB (). Pour plus d'informations sur l'argument d'unité INTERVAL, consultez la discussion sur DATE_ADD ().

mysql> SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| DATE_ADD('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| ADDDATE('1998-01-02', INTERVAL 31 DAY)                  |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Lorsqu'il est invoqué avec la forme jours du deuxième argument, MySQL le traite comme un nombre entier de jours à ajouter à expr.

mysql> SELECT ADDDATE('1998-01-02', 31);
+---------------------------------------------------------+
| DATE_ADD('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

ADDTIME (expr1, expr2)

ADDTIME () ajoute expr2 à expr1 et renvoie le résultat. L'expr1 est une expression d'heure ou de date / heure, tandis que l'expr2 est une expression d'heure.

mysql> SELECT ADDTIME('1997-12-31 23:59:59.999999','1 1:1:1.000002');
+---------------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59.999999','1 1:1:1.000002') |
+---------------------------------------------------------+
| 1998-01-02 01:01:01.000001                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CONVERT_TZ (dt, from_tz, vers_tz)

Cela convertit une valeur datetime dt du fuseau horaire donné par from_tz au fuseau horaire donné par to_tz et renvoie la valeur résultante. Cette fonction renvoie NULL si les arguments ne sont pas valides.

mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET');
+---------------------------------------------------------+
| CONVERT_TZ('2004-01-01 12:00:00','GMT','MET')           |
+---------------------------------------------------------+
| 2004-01-01 13:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00');
+---------------------------------------------------------+
| CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00')     |
+---------------------------------------------------------+
| 2004-01-01 22:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURDATE ()

Renvoie la date actuelle sous forme de valeur au format «AAAA-MM-JJ» ou AAAAMMJJ, selon que la fonction est utilisée dans une chaîne ou dans un contexte numérique.

mysql> SELECT CURDATE();
+---------------------------------------------------------+
| CURDATE()                                               |
+---------------------------------------------------------+
| 1997-12-15                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CURDATE() + 0;
+---------------------------------------------------------+
| CURDATE() + 0                                           |
+---------------------------------------------------------+
| 19971215                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURRENT_DATE et CURRENT_DATE ()

CURRENT_DATE et CURRENT_DATE () sont des synonymes de CURDATE ()

CURTIME ()

Renvoie l'heure actuelle sous forme de valeur au format «HH: MM: SS» ou HHMMSS, selon que la fonction est utilisée dans une chaîne ou dans un contexte numérique. La valeur est exprimée dans le fuseau horaire actuel.

mysql> SELECT CURTIME();
+---------------------------------------------------------+
| CURTIME()                                               |
+---------------------------------------------------------+
| 23:50:26                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CURTIME() + 0;
+---------------------------------------------------------+
| CURTIME() + 0                                           |
+---------------------------------------------------------+
| 235026                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURRENT_TIME et CURRENT_TIME ()

CURRENT_TIME et CURRENT_TIME () sont des synonymes de CURTIME ().

CURRENT_TIMESTAMP et CURRENT_TIMESTAMP ()

CURRENT_TIMESTAMP et CURRENT_TIMESTAMP () sont des synonymes de NOW ().

DATE (expr)

Extrait la partie date de la date ou de l'expression datetime expr.

mysql> SELECT DATE('2003-12-31 01:02:03');
+---------------------------------------------------------+
| DATE('2003-12-31 01:02:03')                             |
+---------------------------------------------------------+
|  2003-12-31                                             |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATEDIFF (expr1, expr2)

DATEDIFF () renvoie expr1. expr2 exprimé sous forme de valeur en jours d'une date à l'autre. Les expressions expr1 et expr2 sont toutes deux des expressions de date ou de date et d'heure. Seules les parties de date des valeurs sont utilisées dans le calcul.

mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30');
+---------------------------------------------------------+
| DATEDIFF('1997-12-31 23:59:59','1997-12-30')            |
+---------------------------------------------------------+
| 1                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_ADD (date, unité expr INTERVAL), DATE_SUB (date, unité expr INTERVAL)

Ces fonctions exécutent l'arithmétique des dates. ledateest une valeur DATETIME ou DATE spécifiant la date de début. leexprest une expression spécifiant la valeur d'intervalle à ajouter ou à soustraire à la date de début. L'expr est une chaîne; il peut commencer par un «-» pour les intervalles négatifs.

UNE unit est un mot-clé indiquant les unités dans lesquelles l'expression doit être interprétée.

le INTERVAL Le mot clé et le spécificateur d'unité ne sont pas sensibles à la casse.

Le tableau suivant montre la forme attendue de l'argument expr pour chaque valeur d'unité.

valeur unitaire	Expected exprFormat
MICROSECONDE	MICROSECONDES
SECONDE	SECONDES
MINUTE	MINUTES
HEURE	HEURES
JOURNÉE	JOURNÉES
LA SEMAINE	SEMAINES
MOIS	MOIS
TRIMESTRE	QUARTIERS
AN	ANS
SECOND_MICROSECOND	'SECOND.MICROSECONDS'
MINUTE_MICROSECOND	'MINUTES.MICROSECONDS'
MINUTE_SECOND	'MINUTES: SECONDES'
HOUR_MICROSECOND	'HEURES.MICROSECONDES'
HOUR_SECOND	'HEURES: MINUTES: SECONDES'
HOUR_MINUTE	'HEURES: MINUTES'
DAY_MICROSECOND	'JOURS.MICROSECONDES'
DAY_SECOND	'JOURS HOURS: MINUTES: SECONDES'
DAY_MINUTE	'JOURS HOURS: MINUTES'
DAY_HOUR	'JOURS HEURES'
ANNÉE MOIS	'ANNÉES-MOIS'

Les valeurs QUARTER et WEEKsont disponibles à partir de MySQL 5.0.0. version.

mysql> SELECT DATE_ADD('1997-12-31 23:59:59', 
   -> INTERVAL '1:1' MINUTE_SECOND);
+---------------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59', INTERVAL...             |
+---------------------------------------------------------+
| 1998-01-01 00:01:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 HOUR);
+---------------------------------------------------------+
| DATE_ADD('1999-01-01', INTERVAL 1 HOUR)                 |
+---------------------------------------------------------+
| 1999-01-01 01:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_FORMAT (date, format)

Cette commande met en forme la valeur de date selon la chaîne de format.

Les spécificateurs suivants peuvent être utilisés dans la chaîne de format. Le caractère «%» est requis avant les caractères de spécification de format.

N ° Sr.	Spécificateur et description
1	%a Nom abrégé du jour de la semaine (dim..sam)
2	%b Nom abrégé du mois (janvier à décembre)
3	%c Mois, numérique (0..12)
4	%D Jour du mois avec suffixe anglais (0e, 1er, 2e, 3e,.)
5	%d Jour du mois, numérique (00..31)
6	%e Jour du mois, numérique (0..31)
sept	%f Microsecondes (000000..999999)
8	%H Heure (00..23)
9	%h Heure (01..12)
dix	%I Heure (01..12)
11	%i Minutes, numériques (00..59)
12	%j Jour de l'année (001..366)
13	%k Heure (0..23)
14	%l Heure (1..12)
15	%M Nom du mois (janvier..décembre)
16	%m Mois, numérique (00..12)
17	%p AM ou PM
18	%r Heure, 12 heures (hh: mm: ss suivi de AM ou PM)
19	%S Secondes (00..59)
20	%s Secondes (00..59)
21	%T Heure, 24 heures (hh: mm: ss)
22	%U Semaine (00..53), où dimanche est le premier jour de la semaine
23	%u Semaine (00..53), où le lundi est le premier jour de la semaine
24	%V Semaine (01..53), où dimanche est le premier jour de la semaine; utilisé avec% X
25	%v Semaine (01..53), où lundi est le premier jour de la semaine; utilisé avec% x
26	%W Nom du jour de la semaine (dimanche..samedi)
27	%w Jour de la semaine (0 = dimanche..6 = samedi)
28	%X Année de la semaine où dimanche est le premier jour de la semaine, numérique, quatre chiffres; utilisé avec% V
29	%x Année pour la semaine, où lundi est le premier jour de la semaine, numérique, quatre chiffres; utilisé avec% v
30	%Y Année, numérique, quatre chiffres
31	%y Année, numérique (deux chiffres)
32	%% Un littéral.%. personnage
33	%x x, pour any.x. non listé ci-dessus

mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');
+---------------------------------------------------------+
| DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y')          |
+---------------------------------------------------------+
| Saturday October 1997                                   |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00'
   -> '%H %k %I %r %T %S %w');
+---------------------------------------------------------+
| DATE_FORMAT('1997-10-04 22:23:00.......                 |
+---------------------------------------------------------+
|  22 22 10 10:23:00 PM 22:23:00 00 6                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_SUB (date, unité expr INTERVAL)

Ceci est similaire à la fonction DATE_ADD ().

JOUR (date)

Le DAY () est un synonyme de la fonction DAYOFMONTH ().

DAYNAME (date)

Renvoie le nom du jour de la semaine pour la date.

mysql> SELECT DAYNAME('1998-02-05');
+---------------------------------------------------------+
| DAYNAME('1998-02-05')                                   |
+---------------------------------------------------------+
| Thursday                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFMONTH (date)

Renvoie le jour du mois pour la date, compris entre 0 et 31.

mysql> SELECT DAYOFMONTH('1998-02-03');
+---------------------------------------------------------+
| DAYOFMONTH('1998-02-03')                                |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFWEEK (date)

Renvoie l'index des jours de la semaine pour la date (1 = dimanche, 2 = lundi,., 7 = samedi). Ces valeurs d'index correspondent à la norme ODBC.

mysql> SELECT DAYOFWEEK('1998-02-03');
+---------------------------------------------------------+
|DAYOFWEEK('1998-02-03')                                  |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFYEAR (date)

Renvoie le jour de l'année pour la date, compris entre 1 et 366.

mysql> SELECT DAYOFYEAR('1998-02-03');
+---------------------------------------------------------+
| DAYOFYEAR('1998-02-03')                                 |
+---------------------------------------------------------+
| 34                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

EXTRAIT (unité DE date)

La fonction EXTRACT () utilise les mêmes types de spécificateurs d'unité que DATE_ADD () ou DATE_SUB (), mais extrait des parties de la date plutôt que d'effectuer une arithmétique de date.

mysql> SELECT EXTRACT(YEAR FROM '1999-07-02');
+---------------------------------------------------------+
| EXTRACT(YEAR FROM '1999-07-02')                         |
+---------------------------------------------------------+
| 1999                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03');
+---------------------------------------------------------+
| EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03')          |
+---------------------------------------------------------+
| 199907                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

FROM_DAYS (N)

Étant donné un numéro de jour N, renvoie une valeur DATE.

mysql> SELECT FROM_DAYS(729669);
+---------------------------------------------------------+
| FROM_DAYS(729669)                                       |
+---------------------------------------------------------+
| 1997-10-07                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Note- Utilisez FROM_DAYS () avec prudence sur les anciennes dates. Il n'est pas destiné à être utilisé avec des valeurs qui précèdent l'avènement du calendrier grégorien (1582).

FROM_UNIXTIME (unix_timestamp)

FROM_UNIXTIME (unix_timestamp, format)

Renvoie une représentation du unix_timestampargument en tant que valeur au format 'AAAA-MM-JJ HH: MM: SS ou AAAAMMJJHHMMSS, selon que la fonction est utilisée dans une chaîne ou dans un contexte numérique. La valeur est exprimée dans le fuseau horaire actuel. L'argument unix_timestamp est une valeur d'horodatage interne, qui est produite par leUNIX_TIMESTAMP() fonction.

Si le format est indiqué, le résultat est formaté selon la chaîne de format, qui est utilisée de la même manière que celle indiquée dans l'entrée pour le DATE_FORMAT() fonction.

mysql> SELECT FROM_UNIXTIME(875996580);
+---------------------------------------------------------+
| FROM_UNIXTIME(875996580)                                |
+---------------------------------------------------------+
| 1997-10-04 22:23:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

HEURE (heure)

Renvoie l'heure pour le temps. La plage de la valeur de retour est comprise entre 0 et 23 pour les valeurs d'heure. Cependant, la plage de valeurs TIME est en réalité beaucoup plus grande, donc HOUR peut renvoyer des valeurs supérieures à 23.

mysql> SELECT HOUR('10:05:03');
+---------------------------------------------------------+
| HOUR('10:05:03')                                        |
+---------------------------------------------------------+
| 10                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LAST_DAY (date)

Prend une valeur de date ou de date / heure et renvoie la valeur correspondante pour le dernier jour du mois. Renvoie NULL si l'argument n'est pas valide.

mysql> SELECT LAST_DAY('2003-02-05');
+---------------------------------------------------------+
| LAST_DAY('2003-02-05')                                  |
+---------------------------------------------------------+
| 2003-02-28                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LOCALTIME et LOCALTIME ()

LOCALTIME et LOCALTIME () sont des synonymes de NOW ().

LOCALTIMESTAMP et LOCALTIMESTAMP ()

LOCALTIMESTAMP et LOCALTIMESTAMP () sont des synonymes de NOW ().

MAKEDATE (année, jour de l'année)

Renvoie une date, des valeurs d'année et de jour de l'année données. La valeur dayofyear doit être supérieure à 0 ou le résultat sera NULL.

mysql> SELECT MAKEDATE(2001,31), MAKEDATE(2001,32);
+---------------------------------------------------------+
| MAKEDATE(2001,31), MAKEDATE(2001,32)                    |
+---------------------------------------------------------+
| '2001-01-31', '2001-02-01'                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MAKETIME (heure, minute, seconde)

Renvoie une valeur d'heure calculée à partir des arguments heure, minute et seconde.

mysql> SELECT MAKETIME(12,15,30);
+---------------------------------------------------------+
| MAKETIME(12,15,30)                                      |
+---------------------------------------------------------+
| '12:15:30'                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MICROSECOND (expr)

Renvoie les microsecondes de l'expression d'heure ou de date / heure (expr) sous la forme d'un nombre compris entre 0 et 999999.

mysql> SELECT MICROSECOND('12:00:00.123456');
+---------------------------------------------------------+
| MICROSECOND('12:00:00.123456')                          |
+---------------------------------------------------------+
| 123456                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MINUTE (temps)

Renvoie la minute pour le temps, entre 0 et 59.

mysql> SELECT MINUTE('98-02-03 10:05:03');
+---------------------------------------------------------+
| MINUTE('98-02-03 10:05:03')                             |
+---------------------------------------------------------+
| 5                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MOIS (date)

Renvoie le mois pour la date, compris entre 0 et 12.

mysql> SELECT MONTH('1998-02-03')
+---------------------------------------------------------+
| MONTH('1998-02-03')                                     |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MONTHNAME (date)

Renvoie le nom complet du mois pour une date.

mysql> SELECT MONTHNAME('1998-02-05');
+---------------------------------------------------------+
| MONTHNAME('1998-02-05')                                 |
+---------------------------------------------------------+
| February                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MAINTENANT()

Renvoie la date et l'heure actuelles sous forme de valeur au format «AAAA-MM-JJ HH: MM: SS» ou AAAAMMJJHHMMSS, selon que la fonction est utilisée dans un contexte de chaîne ou numérique. Cette valeur est exprimée dans le fuseau horaire actuel.

mysql> SELECT NOW();
+---------------------------------------------------------+
| NOW()                                                   |
+---------------------------------------------------------+
| 1997-12-15 23:50:26                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

PERIOD_ADD (P, N)

Ajoute N mois à une période P (au format YYMM ou YYYYMM). Renvoie une valeur au format AAAAMM. Notez que l'argument de période P n'est pas une valeur de date.

mysql> SELECT PERIOD_ADD(9801,2);
+---------------------------------------------------------+
| PERIOD_ADD(9801,2)                                      |
+---------------------------------------------------------+
| 199803                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

PERIODE_DIFF (P1, P2)

Renvoie le nombre de mois entre les périodes P1 et P2. Ces périodes P1 et P2 doivent être au format YYMM ou YYYYMM. Notez que les arguments de période P1 et P2 ne sont pas des valeurs de date.

mysql> SELECT PERIOD_DIFF(9802,199703);
+---------------------------------------------------------+
| PERIOD_DIFF(9802,199703)                                |
+---------------------------------------------------------+
| 11                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

QUARTIER (date)

Renvoie le trimestre de l'année pour la date, compris entre 1 et 4.

mysql> SELECT QUARTER('98-04-01');
+---------------------------------------------------------+
| QUARTER('98-04-01')                                     |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Deuxième fois)

Renvoie le second pour le temps, compris entre 0 et 59.

mysql> SELECT SECOND('10:05:03');
+---------------------------------------------------------+
| SECOND('10:05:03')                                      |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SEC_TO_TIME (secondes)

Renvoie l'argument secondes, converti en heures, minutes et secondes, sous la forme d'une valeur au format «HH: MM: SS» ou HHMMSS, selon que la fonction est utilisée dans un contexte de chaîne ou numérique.

mysql> SELECT SEC_TO_TIME(2378);
+---------------------------------------------------------+
| SEC_TO_TIME(2378)                                       |
+---------------------------------------------------------+
| 00:39:38                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

STR_TO_DATE (chaîne, format)

C'est l'inverse de la fonction DATE_FORMAT (). Il prend une chaîne str et un format de chaîne de format. La fonction STR_TO_DATE () renvoie une valeur DATETIME si la chaîne de format contient à la fois des parties de date et d'heure. Sinon, il renvoie une valeur DATE ou HEURE si la chaîne ne contient que des parties de date ou d'heure.

mysql> SELECT STR_TO_DATE('04/31/2004', '%m/%d/%Y');
+---------------------------------------------------------+
| STR_TO_DATE('04/31/2004', '%m/%d/%Y')                   |
+---------------------------------------------------------+
| 2004-04-31                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SUBDATE (date, unité expr INTERVAL) et SUBDATE (expr, jours)

Lorsqu'il est appelé avec la forme INTERVAL du deuxième argument, SUBDATE () est un synonyme de DATE_SUB (). Pour plus d'informations sur l'argument d'unité INTERVAL, consultez la discussion sur DATE_ADD ().

mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| DATE_SUB('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1997-12-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| SUBDATE('1998-01-02', INTERVAL 31 DAY)                  |
+---------------------------------------------------------+
| 1997-12-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SOUS-TEMPS (expr1, expr2)

La fonction SUBTIME () renvoie expr1. expr2 exprimé sous forme de valeur au même format que expr1. La valeur expr1 est une heure ou une expression datetime, tandis que la valeur expr2 est une expression temporelle.

mysql> SELECT SUBTIME('1997-12-31 23:59:59.999999',
   -> '1 1:1:1.000002');
+---------------------------------------------------------+
| SUBTIME('1997-12-31 23:59:59.999999'...                 |
+---------------------------------------------------------+
| 1997-12-30 22:58:58.999997                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SYSDATE ()

Renvoie la date et l'heure actuelles sous forme de valeur au format «AAAA-MM-JJ HH: MM: SS» ou AAAAMMJJHHMMSS, selon que la fonction est utilisée dans une chaîne ou dans un contexte numérique.

mysql> SELECT SYSDATE();
+---------------------------------------------------------+
| SYSDATE()                                               |
+---------------------------------------------------------+
| 2006-04-12 13:47:44                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TEMPS (expr)

Extrait la partie temps de l'expression time ou datetime expr et le renvoie sous forme de chaîne.

mysql> SELECT TIME('2003-12-31 01:02:03');
+---------------------------------------------------------+
| TIME('2003-12-31 01:02:03')                             |
+---------------------------------------------------------+
| 01:02:03                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMEDIFF (expr1, expr2)

La fonction TIMEDIFF () renvoie expr1. expr2 exprimée en valeur de temps. Ces valeurs expr1 et expr2 sont des expressions d'heure ou de date et d'heure, mais les deux doivent être du même type.

mysql> SELECT TIMEDIFF('1997-12-31 23:59:59.000001',
   -> '1997-12-30 01:01:01.000002');
+---------------------------------------------------------+
| TIMEDIFF('1997-12-31 23:59:59.000001'.....              |
+---------------------------------------------------------+
|  46:58:57.999999                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMP (expr), TIMESTAMP (expr1, expr2)

Avec un seul argument, cette fonction renvoie la date ou l'expression de date / heure expr sous la forme d'une valeur de date / heure. Avec deux arguments, il ajoute l'expression d'heure expr2 à l'expression de date ou d'heureexpr1 et renvoie le résultat sous forme de valeur datetime.

mysql> SELECT TIMESTAMP('2003-12-31');
+---------------------------------------------------------+
| TIMESTAMP('2003-12-31')                                 |
+---------------------------------------------------------+
| 2003-12-31 00:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMPADD (unité, intervalle, exp_dateheure)

Cette fonction ajoute l'intervalle d'expression entier à l'expression de date ou d'heure datetime_expr. L'unité de l'intervalle est donnée par l'argument unité, qui doit être l'une des valeurs suivantes -

• FRAC_SECOND
• SECOND, MINUTE
• HEURE, JOUR
• WEEK
• MONTH
• QUARTIER ou
• YEAR

La valeur unitaire peut être spécifiée à l'aide de l'un des mots-clés comme indiqué ou avec un préfixe SQL_TSI_.

Par exemple, DAY et SQL_TSI_DAY sont tous deux autorisés.

mysql> SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02');
+---------------------------------------------------------+
| TIMESTAMPADD(MINUTE,1,'2003-01-02')                     |
+---------------------------------------------------------+
| 2003-01-02 00:01:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMPDIFF (unité, datetime_expr1, datetime_expr2)

Renvoie la différence entière entre les expressions de date ou de date / heure datetime_expr1 et datetime_expr2. L'unité du résultat est donnée par l'argument unité. Les valeurs légales de l'unité sont les mêmes que celles répertoriées dans la description de la fonction TIMESTAMPADD ().

mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');
+---------------------------------------------------------+
| TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01')          |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIME_FORMAT (heure, format)

Cette fonction est utilisée comme la fonction DATE_FORMAT (), mais la chaîne de format peut contenir des spécificateurs de format uniquement pour les heures, les minutes et les secondes.

Si la valeur de temps contient une partie d'heure supérieure à 23, le%H et %k les spécificateurs de format d'heure produisent une valeur supérieure à la plage habituelle de 0 à 23. Les autres spécificateurs de format d'heure produisent la valeur d'heure modulo 12.

mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');
+---------------------------------------------------------+
| TIME_FORMAT('100:00:00', '%H %k %h %I %l')              |
+---------------------------------------------------------+
| 100 100 04 04 4                                         |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIME_TO_SEC (heure)

Renvoie l'argument de temps converti en secondes.

mysql> SELECT TIME_TO_SEC('22:23:00');
+---------------------------------------------------------+
| TIME_TO_SEC('22:23:00')                                 |
+---------------------------------------------------------+
| 80580                                                   |
+---------------------------------------------------------+
1 row in set (0.00 sec)

La date d'aujourd'hui)

Étant donné une date, renvoie un numéro de jour (le nombre de jours depuis l'année 0).

mysql> SELECT TO_DAYS(950501);
+---------------------------------------------------------+
| TO_DAYS(950501)                                         |
+---------------------------------------------------------+
| 728779                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UNIX_TIMESTAMP (), UNIX_TIMESTAMP (date)

Si elle est appelée sans argument, cette fonction renvoie un horodatage Unix (secondes depuis '1970-01-01 00:00:00' UTC) sous la forme d'un entier non signé. Si UNIX_TIMESTAMP () est appelé avec un argument de date, il renvoie la valeur de l'argument en secondes depuis '1970-01-01 00:00:00' UTC. date peut être une chaîne DATE, une chaîne DATETIME, un TIMESTAMP ou un nombre au format AAMMJJ ou AAAAMMJJ.

mysql> SELECT UNIX_TIMESTAMP();
+---------------------------------------------------------+
| UNIX_TIMESTAMP()                                        |
+---------------------------------------------------------+
| 882226357                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00');
+---------------------------------------------------------+
| UNIX_TIMESTAMP('1997-10-04 22:23:00')                   |
+---------------------------------------------------------+
| 875996580                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_DATE, UTC_DATE ()

Renvoie la date UTC actuelle sous forme de valeur au format «AAAA-MM-JJ» ou AAAAMMJJ, selon que la fonction est utilisée dans un contexte de chaîne ou numérique.

mysql> SELECT UTC_DATE(), UTC_DATE() + 0;
+---------------------------------------------------------+
| UTC_DATE(), UTC_DATE() + 0                              |
+---------------------------------------------------------+
| 2003-08-14, 20030814                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_TIME, UTC_TIME ()

Renvoie l'heure UTC actuelle sous forme de valeur au format «HH: MM: SS» ou HHMMSS, selon que la fonction est utilisée dans un contexte de chaîne ou numérique.

mysql> SELECT UTC_TIME(), UTC_TIME() + 0;
+---------------------------------------------------------+
| UTC_TIME(), UTC_TIME() + 0                              |
+---------------------------------------------------------+
| 18:07:53, 180753                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_TIMESTAMP, UTC_TIMESTAMP ()

Renvoie la date et l'heure UTC actuelles sous forme de valeur au format «AAAA-MM-JJ HH: MM: SS» ou au format AAAAMMJJHHMMSS, selon que la fonction est utilisée dans une chaîne ou dans un contexte numérique.

mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;
+---------------------------------------------------------+
| UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0                    |
+---------------------------------------------------------+
| 2003-08-14 18:08:04, 20030814180804                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SEMAINE (date [, mode])

Cette fonction renvoie le numéro de semaine pour la date. La forme à deux arguments de WEEK () vous permet de spécifier si la semaine commence un dimanche ou un lundi et si la valeur de retour doit être comprise entre 0 et 53 ou entre 1 et 53. Si l'argument mode est omis, la valeur de la variable système default_week_format est utilisée

Mode	Premier jour de la semaine	Intervalle	La semaine 1 est la première semaine.
0	dimanche	0-53	avec un dimanche cette année
1	Lundi	0-53	avec plus de 3 jours cette année
2	dimanche	1-53	avec un dimanche cette année
3	Lundi	1-53	avec plus de 3 jours cette année
4	dimanche	0-53	avec plus de 3 jours cette année
5	Lundi	0-53	avec un lundi cette année
6	dimanche	1-53	avec plus de 3 jours cette année
sept	Lundi	1-53	avec un lundi cette année

mysql> SELECT WEEK('1998-02-20');
+---------------------------------------------------------+
| WEEK('1998-02-20')                                      |
+---------------------------------------------------------+
| 7                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SEMAINE (date)

Renvoie l'index des jours de la semaine pour la date (0 = lundi, 1 = mardi,. 6 = dimanche).

mysql> SELECT WEEKDAY('1998-02-03 22:23:00');
+---------------------------------------------------------+
| WEEKDAY('1998-02-03 22:23:00')                          |
+---------------------------------------------------------+
| 1                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

WEEKOFYEAR (date)

Renvoie la semaine calendaire de la date sous la forme d'un nombre compris entre 1 et 53. WEEKOFYEAR () est une fonction de compatibilité équivalente à WEEK (date, 3).

mysql> SELECT WEEKOFYEAR('1998-02-20');
+---------------------------------------------------------+
| WEEKOFYEAR('1998-02-20')                                |
+---------------------------------------------------------+
| 8                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

ANNÉE (date)

Renvoie l'année pour la date, comprise entre 1 000 et 9 999, ou 0 pour le zéro. Date.

mysql> SELECT YEAR('98-02-03');
+---------------------------------------------------------+
| YEAR('98-02-03')                                        |
+---------------------------------------------------------+
| 1998                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SEMAINE ANNÉE (date), SEMAINE ANNÉE (date, mode)

Renvoie l'année et la semaine d'une date. L'argument mode fonctionne exactement comme l'argument mode de la fonction WEEK (). L'année dans le résultat peut être différente de l'année dans l'argument de date pour la première et la dernière semaine de l'année.

mysql> SELECT YEARWEEK('1987-01-01');
+---------------------------------------------------------+
| YEAR('98-02-03')YEARWEEK('1987-01-01')                  |
+---------------------------------------------------------+
| 198653                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Note - Le numéro de semaine est différent de ce que la fonction WEEK () renverrait (0) pour les arguments optionnels 0 ou 1, car WEEK () renvoie alors la semaine dans le contexte de l'année donnée.

SQL - Tables temporaires

Que sont les tables temporaires?

Il existe des SGBDR, qui prennent en charge les tables temporaires. Les tables temporaires sont une fonctionnalité intéressante qui vous permetstore and process intermediate results en utilisant les mêmes fonctionnalités de sélection, de mise à jour et de jointure que vous pouvez utiliser avec les tables SQL Server classiques.

Les tables temporaires peuvent être très utiles dans certains cas pour conserver des données temporaires. La chose la plus importante à savoir pour les tables temporaires est qu'elles seront supprimées à la fin de la session cliente en cours.

Les tables temporaires sont disponibles à partir de MySQL version 3.23. Si vous utilisez une version plus ancienne de MySQL que la 3.23, vous ne pouvez pas utiliser de tables temporaires, mais vous pouvez utiliserheap tables.

Comme indiqué précédemment, les tables temporaires ne dureront que tant que la session est active. Si vous exécutez le code dans un script PHP, la table temporaire sera détruite automatiquement lorsque le script aura fini de s'exécuter. Si vous êtes connecté au serveur de base de données MySQL via le programme client MySQL, la table temporaire existera jusqu'à ce que vous fermiez le client ou détruisiez manuellement la table.

Exemple

Voici un exemple vous montrant l'utilisation d'une table temporaire.

mysql> CREATE TEMPORARY TABLE SALESSUMMARY (
   -> product_name VARCHAR(50) NOT NULL
   -> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
   -> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   -> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO SALESSUMMARY
   -> (product_name, total_sales, avg_unit_price, total_units_sold)
   -> VALUES
   -> ('cucumber', 100.25, 90, 2);

mysql> SELECT * FROM SALESSUMMARY;
+--------------+-------------+----------------+------------------+
| product_name | total_sales | avg_unit_price | total_units_sold |
+--------------+-------------+----------------+------------------+
| cucumber     |      100.25 |          90.00 |                2 |
+--------------+-------------+----------------+------------------+
1 row in set (0.00 sec)

Lorsque vous émettez une commande SHOW TABLES, votre table temporaire ne sera pas répertoriée dans la liste. Désormais, si vous vous déconnectez de la session MySQL, puis émettez une commande SELECT, vous ne trouverez aucune donnée disponible dans la base de données. Même votre table temporaire n'existera pas.

Suppression de tables temporaires

Par défaut, toutes les tables temporaires sont supprimées par MySQL lorsque votre connexion à la base de données est interrompue. Si vous souhaitez les supprimer entre les deux, vous pouvez le faire en émettant unDROP TABLE commander.

Voici un exemple de suppression d'une table temporaire.

mysql> CREATE TEMPORARY TABLE SALESSUMMARY (
   -> product_name VARCHAR(50) NOT NULL
   -> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
   -> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   -> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO SALESSUMMARY
   -> (product_name, total_sales, avg_unit_price, total_units_sold)
   -> VALUES
   -> ('cucumber', 100.25, 90, 2);

mysql> SELECT * FROM SALESSUMMARY;
+--------------+-------------+----------------+------------------+
| product_name | total_sales | avg_unit_price | total_units_sold |
+--------------+-------------+----------------+------------------+
| cucumber     |      100.25 |          90.00 |                2 |
+--------------+-------------+----------------+------------------+
1 row in set (0.00 sec)
mysql> DROP TABLE SALESSUMMARY;
mysql>  SELECT * FROM SALESSUMMARY;
ERROR 1146: Table 'TUTORIALS.SALESSUMMARY' doesn't exist

SQL - Tables de clonage

Il peut arriver que vous ayez besoin d'une copie exacte d'une table et que les commandes CREATE TABLE ... ou SELECT ... ne correspondent pas à vos objectifs car la copie doit inclure les mêmes index, valeurs par défaut, etc.

Si vous utilisez un SGBDR MySQL, vous pouvez gérer cette situation en suivant les étapes ci-dessous -

• Utilisez la commande SHOW CREATE TABLE pour obtenir une instruction CREATE TABLE qui spécifie la structure, les index et tout de la table source.

• Modifiez l'instruction pour remplacer le nom de la table par celui de la table clone et exécutez l'instruction. De cette façon, vous aurez une table de clonage exacte.

• Si vous avez également besoin de copier le contenu de la table, émettez également une instruction INSERT INTO ou SELECT.

Exemple

Essayez l'exemple suivant pour créer une table de clonage pour TUTORIALS_TBL dont la structure est la suivante -

Step 1 - Obtenez la structure complète de la table.

SQL> SHOW CREATE TABLE TUTORIALS_TBL \G; 
*************************** 1. row *************************** 
      Table: TUTORIALS_TBL 
Create Table: CREATE TABLE 'TUTORIALS_TBL' ( 
  'tutorial_id' int(11) NOT NULL auto_increment, 
  'tutorial_title' varchar(100) NOT NULL default '', 
  'tutorial_author' varchar(40) NOT NULL default '', 
  'submission_date' date default NULL, 
  PRIMARY KEY  ('tutorial_id'), 
  UNIQUE KEY 'AUTHOR_INDEX' ('tutorial_author') 
) TYPE = MyISAM 
1 row in set (0.00 sec)

Step 2 - Renommez cette table et créez une autre table.

SQL> CREATE TABLE `CLONE_TBL` ( 
  -> 'tutorial_id' int(11) NOT NULL auto_increment, 
  -> 'tutorial_title' varchar(100) NOT NULL default '', 
  -> 'tutorial_author' varchar(40) NOT NULL default '', 
  -> 'submission_date' date default NULL, 
  -> PRIMARY KEY  (`tutorial_id'), 
  -> UNIQUE KEY 'AUTHOR_INDEX' ('tutorial_author') 
-> ) TYPE = MyISAM; 
Query OK, 0 rows affected (1.80 sec)

Step 3- Après avoir exécuté l'étape 2, vous clonerez une table dans votre base de données. Si vous souhaitez copier des données à partir d'une ancienne table, vous pouvez le faire à l'aide de l'instruction INSERT INTO ... SELECT.

SQL> INSERT INTO CLONE_TBL (tutorial_id, 
   ->                        tutorial_title, 
   ->                        tutorial_author, 
   ->                        submission_date) 
   -> SELECT tutorial_id,tutorial_title, 
   ->        tutorial_author,submission_date, 
   -> FROM TUTORIALS_TBL; 
Query OK, 3 rows affected (0.07 sec) 
Records: 3  Duplicates: 0  Warnings: 0

Enfin, vous aurez une table de clonage exacte comme vous le souhaitiez.

SQL - Sous-requêtes

Une sous-requête ou une requête interne ou une requête imbriquée est une requête dans une autre requête SQL et incorporée dans la clause WHERE.

Une sous-requête est utilisée pour renvoyer des données qui seront utilisées dans la requête principale comme condition pour restreindre davantage les données à récupérer.

Les sous-requêtes peuvent être utilisées avec les instructions SELECT, INSERT, UPDATE et DELETE avec les opérateurs comme =, <,>,> =, <=, IN, BETWEEN, etc.

Il y a quelques règles que les sous-requêtes doivent suivre -

• Les sous-requêtes doivent être placées entre parenthèses.

• Une sous-requête ne peut avoir qu'une seule colonne dans la clause SELECT, sauf si plusieurs colonnes se trouvent dans la requête principale pour que la sous-requête compare ses colonnes sélectionnées.

• Une commande ORDER BY ne peut pas être utilisée dans une sous-requête, bien que la requête principale puisse utiliser un ORDER BY. La commande GROUP BY peut être utilisée pour exécuter la même fonction que ORDER BY dans une sous-requête.

• Les sous-requêtes qui renvoient plus d'une ligne ne peuvent être utilisées qu'avec plusieurs opérateurs de valeur tels que l'opérateur IN.

• La liste SELECT ne peut pas inclure de références à des valeurs évaluées en BLOB, ARRAY, CLOB ou NCLOB.

• Une sous-requête ne peut pas être immédiatement incluse dans une fonction d'ensemble.

• L'opérateur BETWEEN ne peut pas être utilisé avec une sous-requête. Cependant, l'opérateur BETWEEN peut être utilisé dans la sous-requête.

Sous-requêtes avec l'instruction SELECT

Les sous-requêtes sont le plus souvent utilisées avec l'instruction SELECT. La syntaxe de base est la suivante -

SELECT column_name [, column_name ]
FROM   table1 [, table2 ]
WHERE  column_name OPERATOR
   (SELECT column_name [, column_name ]
   FROM table1 [, table2 ]
   [WHERE])

Exemple

Considérez la table CUSTOMERS ayant les enregistrements suivants -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Maintenant, vérifions la sous-requête suivante avec une instruction SELECT.

SQL> SELECT * 
   FROM CUSTOMERS 
   WHERE ID IN (SELECT ID 
         FROM CUSTOMERS 
         WHERE SALARY > 4500) ;

Cela produirait le résultat suivant.

+----+----------+-----+---------+----------+
| ID | NAME     | AGE | ADDRESS | SALARY   |
+----+----------+-----+---------+----------+
|  4 | Chaitali |  25 | Mumbai  |  6500.00 |
|  5 | Hardik   |  27 | Bhopal  |  8500.00 |
|  7 | Muffy    |  24 | Indore  | 10000.00 |
+----+----------+-----+---------+----------+

Sous-requêtes avec l'instruction INSERT

Les sous-requêtes peuvent également être utilisées avec des instructions INSERT. L'instruction INSERT utilise les données renvoyées par la sous-requête pour les insérer dans une autre table. Les données sélectionnées dans la sous-requête peuvent être modifiées avec l'une des fonctions de caractère, de date ou de nombre.

La syntaxe de base est la suivante.

INSERT INTO table_name [ (column1 [, column2 ]) ]
   SELECT [ *|column1 [, column2 ]
   FROM table1 [, table2 ]
   [ WHERE VALUE OPERATOR ]

Exemple

Considérons une table CUSTOMERS_BKP avec une structure similaire à la table CUSTOMERS. Maintenant, pour copier la table CUSTOMERS complète dans la table CUSTOMERS_BKP, vous pouvez utiliser la syntaxe suivante.

SQL> INSERT INTO CUSTOMERS_BKP
   SELECT * FROM CUSTOMERS 
   WHERE ID IN (SELECT ID 
   FROM CUSTOMERS) ;

Sous-requêtes avec l'instruction UPDATE

La sous-requête peut être utilisée conjointement avec l'instruction UPDATE. Une ou plusieurs colonnes d'une table peuvent être mises à jour lors de l'utilisation d'une sous-requête avec l'instruction UPDATE.

La syntaxe de base est la suivante.

UPDATE table
SET column_name = new_value
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
   FROM TABLE_NAME)
   [ WHERE) ]

Exemple

En supposant, nous avons la table CUSTOMERS_BKP disponible qui est une sauvegarde de la table CUSTOMERS. L'exemple suivant met à jour SALARY de 0,25 fois dans la table CUSTOMERS pour tous les clients dont l'ÂGE est supérieur ou égal à 27.

SQL> UPDATE CUSTOMERS
   SET SALARY = SALARY * 0.25
   WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP
      WHERE AGE >= 27 );

Cela aurait un impact sur deux lignes et finalement la table CUSTOMERS aurait les enregistrements suivants.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |   125.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  2125.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Sous-requêtes avec l'instruction DELETE

La sous-requête peut être utilisée conjointement avec l'instruction DELETE comme avec toutes les autres instructions mentionnées ci-dessus.

La syntaxe de base est la suivante.

DELETE FROM TABLE_NAME
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
   FROM TABLE_NAME)
   [ WHERE) ]

Exemple

En supposant que nous ayons une table CUSTOMERS_BKP disponible qui est une sauvegarde de la table CUSTOMERS. L'exemple suivant supprime les enregistrements de la table CUSTOMERS pour tous les clients dont l'âge est supérieur ou égal à 27.

SQL> DELETE FROM CUSTOMERS
   WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP
      WHERE AGE >= 27 );

Cela aurait un impact sur deux lignes et finalement la table CUSTOMERS aurait les enregistrements suivants.

+----+----------+-----+---------+----------+
| ID | NAME     | AGE | ADDRESS | SALARY   |
+----+----------+-----+---------+----------+
|  2 | Khilan   |  25 | Delhi   |  1500.00 |
|  3 | kaushik  |  23 | Kota    |  2000.00 |
|  4 | Chaitali |  25 | Mumbai  |  6500.00 |
|  6 | Komal    |  22 | MP      |  4500.00 |
|  7 | Muffy    |  24 | Indore  | 10000.00 |
+----+----------+-----+---------+----------+

SQL - Utilisation de séquences

Une séquence est un ensemble d'entiers 1, 2, 3, ... qui sont générés dans l'ordre à la demande. Les séquences sont fréquemment utilisées dans les bases de données, car de nombreuses applications exigent que chaque ligne d'une table contienne une valeur unique et les séquences permettent de les générer facilement.

Ce chapitre décrit comment utiliser des séquences dans MySQL.

Utilisation de la colonne AUTO_INCREMENT

La manière la plus simple dans MySQL d'utiliser des séquences est de définir une colonne comme AUTO_INCREMENT et de laisser le reste à MySQL pour s'en occuper.

Exemple

Essayez l'exemple suivant. Cela créera une table et après cela, il insérera quelques lignes dans cette table où il n'est pas nécessaire de donner un ID d'enregistrement car il est auto-incrémenté par MySQL.

mysql> CREATE TABLE INSECT
   -> (
   -> id INT UNSIGNED NOT NULL AUTO_INCREMENT,
   -> PRIMARY KEY (id),
   -> name VARCHAR(30) NOT NULL, # type of insect
   -> date DATE NOT NULL, # date collected
   -> origin VARCHAR(30) NOT NULL # where collected
);
Query OK, 0 rows affected (0.02 sec)
mysql> INSERT INTO INSECT (id,name,date,origin) VALUES
   -> (NULL,'housefly','2001-09-10','kitchen'),
   -> (NULL,'millipede','2001-09-10','driveway'),
   -> (NULL,'grasshopper','2001-09-10','front yard');
Query OK, 3 rows affected (0.02 sec)
Records: 3  Duplicates: 0  Warnings: 0
mysql> SELECT * FROM INSECT ORDER BY id;
+----+-------------+------------+------------+
| id | name        | date       | origin     |
+----+-------------+------------+------------+
|  1 | housefly    | 2001-09-10 | kitchen    |
|  2 | millipede   | 2001-09-10 | driveway   |
|  3 | grasshopper | 2001-09-10 | front yard |
+----+-------------+------------+------------+
3 rows in set (0.00 sec)

Obtenir les valeurs AUTO_INCREMENT

Le LAST_INSERT_ID () est une fonction SQL, vous pouvez donc l'utiliser à partir de n'importe quel client qui comprend comment émettre des instructions SQL. Sinon, les scripts PERL et PHP fournissent des fonctions exclusives pour récupérer la valeur auto-incrémentée du dernier enregistrement.

Exemple PERL

Utilisez le mysql_insertidattribut pour obtenir la valeur AUTO_INCREMENT générée par une requête. Cet attribut est accessible via un descripteur de base de données ou un descripteur d'instruction, selon la façon dont vous émettez la requête. L'exemple suivant le référence via le handle de base de données.

$dbh->do ("INSERT INTO INSECT (name,date,origin) VALUES('moth','2001-09-14','windowsill')"); my $seq = $dbh->{mysql_insertid};

Exemple PHP

Après avoir émis une requête qui génère une valeur AUTO_INCREMENT, récupérez la valeur en appelant le mysql_insert_id( ) fonction.

mysql_query ("INSERT INTO INSECT (name,date,origin)
VALUES('moth','2001-09-14','windowsill')", $conn_id);
$seq = mysql_insert_id ($conn_id);

Renuméroter une séquence existante

Il peut y avoir un cas où vous avez supprimé de nombreux enregistrements d'une table et que vous souhaitez réorganiser tous les enregistrements. Cela peut être fait en utilisant une astuce simple, mais vous devez faire très attention à le faire et vérifier si votre table a une jointure avec une autre table ou non.

Si vous déterminez que la remise en séquence d'une colonne AUTO_INCREMENT est inévitable, la façon de le faire est de supprimer la colonne de la table, puis de l'ajouter à nouveau.

L'exemple suivant montre comment renuméroter les valeurs d'id dans la table d'insectes à l'aide de cette technique.

mysql> ALTER TABLE INSECT DROP id;
mysql> ALTER TABLE insect
   -> ADD id INT UNSIGNED NOT NULL AUTO_INCREMENT FIRST,
   -> ADD PRIMARY KEY (id);

Démarrage d'une séquence à une valeur particulière

Par défaut, MySQL démarrera la séquence à partir de 1, mais vous pouvez également spécifier n'importe quel autre nombre au moment de la création de la table.

Le bloc de code suivant a un exemple où MySQL démarrera la séquence à partir de 100.

mysql> CREATE TABLE INSECT
   -> (
   -> id INT UNSIGNED NOT NULL AUTO_INCREMENT = 100,
   -> PRIMARY KEY (id),
   -> name VARCHAR(30) NOT NULL, # type of insect
   -> date DATE NOT NULL, # date collected
   -> origin VARCHAR(30) NOT NULL # where collected
);

Vous pouvez également créer la table, puis définir la valeur de séquence initiale avec ALTER TABLE.

mysql> ALTER TABLE t AUTO_INCREMENT = 100;

SQL - Gestion des doublons

Il peut y avoir une situation où vous avez plusieurs enregistrements en double dans une table. Lors de la récupération de tels enregistrements, il est plus judicieux de récupérer uniquement les enregistrements uniques au lieu de récupérer les enregistrements en double.

Le SQL DISTINCT Le mot clé, dont nous avons déjà parlé, est utilisé en conjonction avec l'instruction SELECT pour éliminer tous les enregistrements en double et en extrayant uniquement les enregistrements uniques.

Syntaxe

La syntaxe de base d'un mot clé DISTINCT pour éliminer les enregistrements en double est la suivante.

SELECT DISTINCT column1, column2,.....columnN 
FROM table_name
WHERE [condition]

Exemple

Considérez la table CUSTOMERS ayant les enregistrements suivants.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Voyons d'abord comment la requête SELECT suivante renvoie des enregistrements de salaire en double.

SQL> SELECT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Cela produirait le résultat suivant où le salaire de 2000 arrive deux fois, ce qui est un enregistrement en double de la table d'origine.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

Maintenant, utilisons le mot clé DISTINCT avec la requête SELECT ci-dessus et voyons le résultat.

SQL> SELECT DISTINCT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Cela produirait le résultat suivant où nous n'avons aucune entrée en double.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

SQL - Injection

Si vous prenez une entrée utilisateur via une page Web et l'insérez dans une base de données SQL, il est possible que vous vous soyez laissé ouvert à un problème de sécurité connu sous le nom de SQL Injection. Ce chapitre vous apprendra comment éviter que cela ne se produise et vous aidera à sécuriser vos scripts et instructions SQL dans vos scripts côté serveur comme un script PERL.

L'injection se produit généralement lorsque vous demandez à un utilisateur une entrée, comme son nom et au lieu d'un nom, il vous donne une instruction SQL que vous exécuterez sans le savoir sur votre base de données. Ne faites jamais confiance aux données fournies par l'utilisateur, ne traitez ces données qu'après validation; en règle générale, cela se fait parPattern Matching.

Dans l'exemple ci-dessous, le name est limité aux caractères alphanumériques plus le trait de soulignement et à une longueur comprise entre 8 et 20 caractères (modifiez ces règles si nécessaire).

if (preg_match("/^\w{8,20}$/", $_GET['username'], $matches)) { $result = mysql_query("SELECT * FROM CUSTOMERS 
      WHERE name = $matches[0]");
} else {
   echo "user name not accepted";
}

Pour démontrer le problème, considérez cet extrait -

// supposed input
$name = "Qadir'; DELETE FROM CUSTOMERS;";
mysql_query("SELECT * FROM CUSTOMSRS WHERE name='{$name}'");

L'appel de fonction est censé récupérer un enregistrement de la table CUSTOMERS où la colonne de nom correspond au nom spécifié par l'utilisateur. Dans des circonstances normales,$namene contiendrait que des caractères alphanumériques et peut-être des espaces, comme la chaîne ilia. Mais ici, en ajoutant une toute nouvelle requête à $ name, l'appel à la base de données tourne au désastre; la requête DELETE injectée supprime tous les enregistrements de la table CUSTOMERS.

Heureusement, si vous utilisez MySQL, le mysql_query()ne permet pas l'empilement de requêtes ou l'exécution de plusieurs requêtes SQL en un seul appel de fonction. Si vous essayez d'empiler des requêtes, l'appel échoue.

Cependant, d'autres extensions de base de données PHP, telles que SQLite et PostgreSQL exécutez avec plaisir des requêtes empilées, exécutant toutes les requêtes fournies dans une chaîne et créant un problème de sécurité sérieux.

Empêcher l'injection SQL

Vous pouvez gérer tous les caractères d'échappement intelligemment dans des langages de script comme PERL et PHP. L'extension MySQL pour PHP fournit la fonctionmysql_real_escape_string() pour échapper les caractères d'entrée spécifiques à MySQL.

if (get_magic_quotes_gpc()) {
   $name = stripslashes($name); } $name = mysql_real_escape_string($name); mysql_query("SELECT * FROM CUSTOMERS WHERE name='{$name}'");

Le LIKE Quandary

Pour résoudre le dilemme LIKE, un mécanisme d'échappement personnalisé doit convertir les caractères '%' et '_' fournis par l'utilisateur en littéraux. Utilisationaddcslashes(), une fonction qui vous permet de spécifier une plage de caractères à échapper.

$sub = addcslashes(mysql_real_escape_string("%str"), "%_"); // $sub == \%str\_
mysql_query("SELECT * FROM messages 
   WHERE subject LIKE '{$sub}%'");

SQL - Réglage de la base de données

Il faut du temps pour devenir un expert en base de données ou un administrateur de base de données expert. Tout cela vient avec une grande expérience dans diverses conceptions de bases de données et de bonnes formations.

Mais la liste suivante peut être utile pour que les débutants aient une bonne performance de base de données -

• Utilisez la conception de base de données 3BNF expliquée dans ce didacticiel dans le chapitre Concepts du SGBDR.

• Évitez les conversions de nombre en caractère, car les nombres et les caractères se comparent différemment et entraînent une dégradation des performances.

• Lorsque vous utilisez l'instruction SELECT, ne récupérez que les informations requises et évitez d'utiliser * dans vos requêtes SELECT car cela chargerait le système inutilement.

• Créez vos index avec soin sur toutes les tables où vous avez des opérations de recherche fréquentes. Évitez d'indexer sur les tables où vous avez moins d'opérations de recherche et plus d'opérations d'insertion et de mise à jour.

• Une analyse de table complète se produit lorsque les colonnes de la clause WHERE ne sont pas associées à un index. Vous pouvez éviter une analyse complète de la table en créant un index sur les colonnes utilisées comme conditions dans la clause WHERE d'une instruction SQL.

• Faites très attention aux opérateurs d'égalité avec des nombres réels et des valeurs de date / heure. Ces deux éléments peuvent présenter de petites différences qui ne sont pas évidentes à l'œil nu, mais qui rendent une correspondance exacte impossible, empêchant ainsi vos requêtes de retourner des lignes.

• Utilisez judicieusement la correspondance de motifs. LIKE COL% est une condition WHERE valide, réduisant le jeu renvoyé aux seuls enregistrements dont les données commencent par la chaîne COL. Cependant, COL% Y ne réduit pas davantage le jeu de résultats renvoyé car% Y ne peut pas être évalué efficacement. L'effort pour faire l'évaluation est trop important pour être pris en compte. Dans ce cas, le COL% est utilisé, mais le% Y est jeté. Pour la même raison, un caractère générique% COL en tête empêche efficacement l'utilisation de l'ensemble du filtre.

• Affinez vos requêtes SQL en examinant la structure des requêtes (et des sous-requêtes), la syntaxe SQL, pour découvrir si vous avez conçu vos tables pour prendre en charge une manipulation rapide des données et écrit la requête de manière optimale, permettant à votre SGBD de manipuler les données efficacement .

• Pour les requêtes exécutées régulièrement, essayez d'utiliser des procédures. Une procédure est un groupe potentiellement important d'instructions SQL. Les procédures sont compilées par le moteur de base de données puis exécutées. Contrairement à une instruction SQL, le moteur de base de données n'a pas besoin d'optimiser la procédure avant son exécution.

• Évitez d'utiliser l'opérateur logique OR dans une requête si possible. OR ralentit inévitablement presque toutes les requêtes sur une table de taille importante.

• Vous pouvez optimiser les chargements de données en masse en supprimant les index. Imaginez la table d'historique avec plusieurs milliers de lignes. Cette table d'historique est également susceptible d'avoir un ou plusieurs index. Lorsque vous pensez à un index, vous pensez normalement à un accès plus rapide aux tables, mais dans le cas de chargements par lots, vous pouvez bénéficier de la suppression du ou des index.

• Lors de l'exécution de transactions par lots, effectuez COMMIT après un bon nombre de création d'enregistrements au lieu de les créer après chaque création d'enregistrement.

• Prévoyez de défragmenter la base de données régulièrement, même si cela signifie développer une routine hebdomadaire.

Outils de réglage intégrés

Oracle dispose de nombreux outils pour gérer les performances des instructions SQL, mais parmi eux deux sont très populaires. Ces deux outils sont -

• Explain plan - L'outil identifie le chemin d'accès qui sera emprunté lors de l'exécution de l'instruction SQL.

• tkprof - mesure les performances en fonction du temps écoulé pendant chaque phase du traitement des instructions SQL.

Si vous souhaitez simplement mesurer le temps écoulé d'une requête dans Oracle, vous pouvez utiliser la commande SQL * Plus SET TIMING ON.

Consultez la documentation de votre SGBDR pour plus de détails sur les outils mentionnés ci-dessus et la défragmentation de la base de données.