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

Opérations CRUD SQL Server

En programmation de base de données, il existe quatre opérations fondamentales :créer , lire , mettre à jour , et supprimer – CRUD opérations. Ils constituent la première étape de la programmation de bases de données.

Le terme CRUD est apparu pour la première fois dans le livre de James Martin "Managing the Database Environment". Depuis lors, ce terme est devenu populaire. Dans cet article, nous allons explorer l'opération CRUD en termes de SQL Server car la syntaxe de l'opération peut différer des autres bases de données relationnelles et NoSQL.

Préparatifs

L'idée principale des bases de données relationnelles est de stocker des données dans des tables. Les données du tableau peuvent être lues, insérées, supprimées. De cette façon, les opérations CRUD manipulent les données de la table.

C C RÉATE Insérer une/des lignes dans un tableau
R R EAD Lire (sélectionner) une ou plusieurs lignes d'un tableau
U U PDATE Modifier la/les ligne(s) du tableau
D D SUPPRIMER Supprimer ligne(s) du tableau

Pour illustrer les opérations CRUD, nous avons besoin d'une table de données. Créons-en un. Il ne contiendra que trois colonnes. La première colonne stockera les noms de pays, la seconde stockera le continent de ces pays et la dernière colonne stockera la population de ces pays. Nous pouvons créer cette table à l'aide de l'instruction T-SQL et l'intituler TblCountry .

CREATE TABLE [dbo].[TblCountry]
(
	[CountryName]		VARCHAR(50), 
    [ContinentNames]	VARCHAR(50) NULL, 
    [CountryPopulation]		BIGINT NULL 
)

Passons maintenant en revue les opérations CRUD effectuées sur le TblCountry tableau.

C - CRÉER

Pour ajouter de nouvelles lignes à une table, nous utilisons la commande INSERT INTO commande. Dans cette commande, nous devons spécifier le nom de la table cible et lister les noms de colonnes entre parenthèses. La structure de l'instruction doit se terminer par VALUES :

INSERT INTO TblCountry  
(CountryName,ContinentNames,CountryPopulation) 
VALUES   ('Germany','Europe',8279000 )

Pour ajouter plusieurs lignes au tableau, nous pouvons utiliser le type suivant d'instruction INSERT :

INSERT INTO TblCountry  
(CountryName,ContinentNames,CountryPopulation) 
VALUES   
('Germany','Europe',8279000 ), 
('Japan','Asia',126800000 ),
('Moroco','Africa',35740000)

Notez que le INTO Le mot-clé est facultatif et vous n'avez pas besoin de l'utiliser dans les instructions d'insertion.

INSERT  TblCountry  
(CountryName,ContinentNames,CountryPopulation) 
VALUES   
('Germany','Europe',8279000 ), 
('Japan','Asia',126800000 ),
('Moroco','Africa',35740000)

Vous pouvez également utiliser le format suivant pour insérer plusieurs lignes dans le tableau :

INSERT INTO TblCountry
SELECT 'Germany','Europe',8279000 
UNION ALL
SELECT 'Japan','Asia',126800000 
UNION ALL
SELECT 'Moroco','Africa',35740000

Maintenant, nous allons copier les données directement de la table source vers la table de destination. Cette méthode est connue sous le nom de INSERT INTO … SELECT déclaration.

INSERT INTO … SELECT nécessite de faire correspondre les types de données des tables source et destination. Dans l'instruction INSERT INTO … SELECT suivante, nous allons insérer les données du SourceCountryTbl table dans le TblCountry tableau.

Dans un premier temps, nous insérons des données synthétiques dans le SourceCountryTbl table pour cette démonstration.

DROP TABLE IF EXISTS [SourceCountryTbl]
CREATE TABLE [dbo].[SourceCountryTbl]
(
	[SourceCountryName]		VARCHAR(50), 
    [SourceContinentNames]	VARCHAR(50) NULL, 
    [SourceCountryPopulation]		BIGINT NULL 
	
)


INSERT INTO [SourceCountryTbl] 
VALUES 
('Ukraine','Europe',44009214  ) ,
('UK','Europe',66573504) ,
('France','Europe',65233271)

Nous allons maintenant exécuter l'instruction INSERT INTO … SELECT.

INSERT INTO TblCountry
SELECT * FROM SourceCountryTbl

L'instruction d'insertion ci-dessus a ajouté tous les SourceCountryTbl données au TblCountry table. Nous pouvons également ajouter le WHERE clause pour filtrer l'instruction select.

INSERT INTO TblCountry
SELECT * FROM SourceCountryTbl WHERE TargetCountryName='UK'

SQL Server nous permet d'utiliser des variables de table (objets qui aident à stocker des données de table temporaires dans la portée locale) avec les instructions INSERT INTO … SELECT. Dans la démonstration suivante, nous utiliserons la variable table comme table source :

  DECLARE @SourceVarTable AS TABLE
  ([TargetCountryName]		VARCHAR(50), 
    [TargetContinentNames]	VARCHAR(50) NULL, 
    [TargetCountryPopulation]		BIGINT NULL 
   )


    INSERT INTO @SourceVarTable 
     VALUES 
     ('Ukraine','Europe',44009214  ) ,
     ('UK','Europe',66573504) ,
     ('France','Europe',65233271)


INSERT INTO TblCountry
SELECT * FROM @SourceVarTable

Astuce :Microsoft a annoncé une fonctionnalité dans SQL Server 2016 qui est l'insertion parallèle . Cette fonctionnalité nous permet d'effectuer des opérations INSERT dans des threads parallèles.

Si vous ajoutez le TABLOCK indice à la fin de votre instruction d'insertion, SQL Server peut choisir un parallèle avec le plan d'exécution du traitement en fonction du degré maximal de parallélisme de votre serveur ou du seuil de coût pour les paramètres de parallélisme.

Le traitement d'insertion parallèle réduira également le temps d'exécution de l'instruction d'insertion. Cependant, le TABLOCK hint acquerra le verrou de la table insérée lors de l'opération d'insertion. Pour plus d'informations sur l'insertion parallèle, vous pouvez vous référer à Real World Parallel INSERT…SELECT.

Une autre instruction pratique est SELECT INTO. Cette méthode nous permet de copier les données d'une table dans une table nouvellement créée. Dans la déclaration suivante, NewCountryTable n'existait pas avant l'exécution de la requête. La requête crée la table et insère toutes les données du TblCountry tableau.

SELECT * INTO NewCountryTable 
FROM TblCountry

En même temps, nous pouvons créer une nouvelle table pour des colonnes particulières de la table source.

Dans certains cas, nous devons renvoyer et utiliser les valeurs insérées à partir de l'instruction INSERT. Depuis SQL Server 2005, l'instruction INSERT nous permet de récupérer les valeurs en question à partir de l'instruction INSERT.

Maintenant, nous allons supprimer et créer notre table de test et ajouter une nouvelle colonne d'identité. De plus, nous ajouterons une contrainte par défaut à cette colonne. Ainsi, si nous n'insérons aucune valeur explicite dans cette colonne, une nouvelle valeur sera automatiquement créée.

Dans l'exemple suivant, nous allons déclarer une table ayant une colonne et insérer la sortie du SeqID valeur de la colonne dans ce tableau à l'aide de la colonne OUTPUT :

DROP TABLE IF EXISTS TblCountry
CREATE TABLE [dbo].[TblCountry]
(
	[CountryName]		VARCHAR(50), 
    [ContinentNames]	VARCHAR(50) NULL, 
    [CountryPopulation]		BIGINT NULL ,
	SeqID uniqueidentifier  default(newid())
)	



DECLARE @OutputID AS TABLE(LogID uniqueidentifier) 
 
INSERT  TblCountry  
(CountryName,ContinentNames,CountryPopulation) 
OUTPUT INSERTED.SeqId INTO @OutputID
VALUES   
('Germany','Europe',8279000 )

SELECT * FROM @OutPutId

R - Lire

La Lire L'opération récupère les données d'une table et renvoie un jeu de résultats avec les enregistrements de la table. Si nous voulons récupérer des données de plusieurs tables, nous pouvons utiliser l'opérateur JOIN et créer une relation logique entre les tables.

L'instruction SELECT joue un seul rôle principal dans la lecture opération. Il repose sur trois éléments :

  • Colonne – on définit les colonnes dont on veut récupérer les données
  • Tableau – nous spécifier la table à partir de laquelle nous voulons obtenir des données
  • Filtrer – nous peut filtrer les données que nous voulons lire. Cette partie est facultative.

La forme la plus simple de l'instruction select est la suivante :

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

Maintenant, nous allons parcourir les exemples. Au début, nous avons besoin d'un exemple de tableau à lire. Créons-le :

DROP TABLE  IF EXISTS TblCountry
 GO
CREATE TABLE [dbo].[TblCountry]
(
	[CountryName]		VARCHAR(50), 
    [ContinentNames]	VARCHAR(50) NULL, 
    [CountryPopulation]		BIGINT NULL 
)

GO
INSERT INTO TblCountry  
(CountryName,ContinentNames,CountryPopulation) 
VALUES   
('Germany','Europe',8279000 ), 
('Japan','Asia',126800000 ),
('Moroco','Africa',35740000)

Lire toutes les colonnes du tableau

L'opérateur astérisque (*) est utilisé dans les instructions SELECT car il renvoie toutes les colonnes de la table :

SELECT * FROM TblCountry

Astuce :L'opérateur astérisque (*) peut influencer négativement les performances car il génère plus de trafic réseau et consomme plus de ressources. Ainsi, si vous n'avez pas besoin d'obtenir toutes les données de toutes les colonnes renvoyées, évitez d'utiliser l'astérisque (*) dans l'instruction SELECT.

Lecture de colonnes particulières du tableau

Nous pouvons également lire des colonnes particulières du tableau. Reprenons l'exemple qui renverra uniquement le CountryName et PaysPopulation colonnes :

SELECT CountryName,CountryPopulation FROM TblCountry

Utilisation d'alias dans les instructions SELECT

Dans les instructions SELECT, nous pouvons donner des noms temporaires à la table ou aux colonnes. Ces noms temporaires sont des alias. Réécrivons les deux requêtes précédentes avec des alias de table et de colonne.

Dans la requête suivante, le TblC alias spécifiera le nom de la table :

SELECT TblC.* FROM TblCountry TblC

Dans l'exemple suivant, nous fournirons des alias pour les noms de colonne. Nous allons changer CountryName vers CName , et PaysPopulation – à CPop .

SELECT TblC.CountryName AS [CName], CountryPopulation AS [CPop] FROM TblCountry TblC

Les objectifs de l'alias sont :

  • Rendre la requête plus lisible si les noms de table ou de colonne sont complexes.
  • Assurez-vous d'utiliser une requête pour la table plusieurs fois.
  • Simplifiez l'écriture de la requête si le nom de la table ou de la colonne est long.

Filtrer les instructions SELECT

Les instructions SELECT nous permettent de filtrer les ensembles de résultats via la clause WHERE. Par exemple, nous voulons filtrer l'instruction SELECT en fonction du CountryName colonne et renvoie uniquement les données de l'Allemagne dans le jeu de résultats. La requête suivante effectuera l'opération de lecture avec un filtre :

SELECT TblC.* FROM TblCountry TblC
WHERE TblC.CountryName='Germany'

Trier les résultats des instructions SELECT

La clause ORDER BY nous aide à trier le jeu de résultats de l'instruction SELECT en fonction de la ou des colonnes spécifiées. Nous pouvons effectuer un tri croissant ou décroissant à l'aide de la clause ORDER BY.

Nous allons trier le TblCountry tableau selon la population des pays par ordre croissant :

SELECT TblC.* FROM TblCountry TblC
ORDER BY TblC.CountryPopulation ASC

Astuce  :Vous pouvez utiliser l'index de colonne dans la clause ORDER BY, et les numéros d'index de colonne commencent par 1.

On peut aussi écrire la requête précédente. Le chiffre trois (3) indique la CountryPopulation colonne : 

SELECT TblC.* FROM TblCountry TblC
ORDER BY 3 ASC

U - Mise à jour

L'instruction UPDATE modifie les données existantes dans la table. Cette instruction doit inclure la clause SET afin que nous puissions définir la colonne cible pour modifier les données.

La requête suivante modifiera toutes les lignes de CounrtyPopulation valeur de la colonne à 1.

UPDATE TblCountry SET CountryPopulation=1
GO
SELECT TblC.* FROM TblCountry TblC

Dans les instructions UPDATE, nous pouvons utiliser la clause WHERE pour modifier une ou plusieurs lignes particulières dans la table.

Changeons le Japon rangée de CountryPopulation à 245000 :

UPDATE TblCountry SET CountryPopulation=245000
WHERE CountryName = 'Japan'
GO
SELECT TblC.* FROM TblCountry TblC

L'instruction UPDATE est une union des instructions delete et insert. Ainsi, nous pouvons renvoyer les valeurs insérées et supprimées via la clause OUTPUT.

Prenons un exemple :

UPDATE TblCountry SET CountryPopulation=22
OUTPUT inserted.CountryPopulation AS [Insertedvalue],
deleted.CountryPopulation AS [Deletedvalue]
WHERE CountryName = 'Germany'

Comme vous pouvez le voir, nous avons modifié la CountryPopulation valeur de 1 à 22. Ensuite, nous pouvons trouver les valeurs insérées et supprimées. De plus, nous pouvons insérer ces valeurs dans une variable de table (un type de variable spécial qui peut être utilisé comme table).

Nous allons insérer les valeurs insérées et supprimées dans la variable de table :

DECLARE @LogTable TABLE(InsertValLog INT , DelValLog INT) 


UPDATE TblCountry SET CountryPopulation=45
OUTPUT inserted.CountryPopulation ,
deleted.CountryPopulation INTO @LogTable
WHERE CountryName = 'Germany'


SELECT * FROM @LogTable

@@ROWCOUNT est une variable système qui renvoie le nombre de lignes affectées dans la dernière instruction. Ainsi, nous pouvons utiliser cette variable pour exposer certaines lignes modifiées dans l'instruction de mise à jour.

Dans l'exemple suivant, la requête de mise à jour modifiera 3 lignes et la variable système @@ROWCOUNT renverra 3.

UPDATE TblCountry SET CountryPopulation=1
SELECT @@ROWCOUNT AS [AffectedRowNumber]

D - Supprimer

L'instruction Delete supprime les lignes existantes de la table.

Voyons d'abord comment utiliser la clause WHERE dans les instructions DELETE. La plupart du temps, nous voulons filtrer les lignes supprimées.

L'exemple ci-dessous illustre comment supprimer une ligne particulière :

SELECT TblC.* FROM TblCountry TblC
DELETE FROM TblCountry WHERE CountryName='Japan'
SELECT TblC.* FROM TblCountry TblC

Cependant, avec l'instruction DELETE, nous pouvons supprimer tous les enregistrements de la table. Cependant, l'instruction DELETE est très basique et nous n'utilisons pas la condition WHERE.

SELECT TblC.* FROM TblCountry TblC
DELETE FROM TblCountry
SELECT TblC.* FROM TblCountry TblC

Pourtant, dans certaines circonstances de la conception de la base de données, l'instruction DELETE ne supprime pas la ou les lignes si elle viole les clés étrangères ou d'autres contraintes.

Par exemple, dans AdventureWorks base de données, nous ne pouvons pas supprimer les lignes de la ProductCategory table car ProductCategoryID est spécifié comme clé étrangère dans cette table.

Essayons de supprimer une ligne de la ProductCategory table - sans aucun doute, nous serons confrontés à l'erreur suivante :

DELETE FROM [Production].[ProductCategory]
WHERE ProductCategoryID=1

Conclusion

Ainsi, nous avons exploré les opérations CRUD en SQL. Les instructions INSERT, SELECT, UPDATE et DELETE sont les fonctions de base de la base de données SQL et vous devez les maîtriser si vous souhaitez apprendre la programmation de base de données SQL. La théorie CRUD pourrait être un bon point de départ, et beaucoup de pratique vous aidera à devenir un expert.