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

Passer la table de données en tant que paramètre aux procédures stockées

Les applications de base de données du monde réel doivent effectuer plusieurs requêtes du front-end à la base de données afin d'exécuter toutes sortes de fonctions.

Si une application est gourmande en données, comme celles utilisées dans les banques ou les aéroports, etc., le nombre de trajets de données peut être énorme. Chaque demande adressée à une base de données utilise de la bande passante et nécessite du temps pour s'exécuter. Sans les paramètres table, une application frontale doit effectuer plusieurs trajets de données afin de manipuler plusieurs lignes de données. Cependant, avec les paramètres de table, plusieurs lignes peuvent être insérées, mises à jour et supprimées d'une base de données à l'aide d'une seule commande paramétrée qui prend un paramètre de table.

Un paramètre table est un paramètre avec un type table. A l'aide de ce paramètre, vous pouvez envoyer plusieurs lignes de données à une procédure stockée ou à une commande SQL paramétrée sous la forme d'un tableau. Transact-SQL peut être utilisé pour accéder aux valeurs de colonne des paramètres de table.

Dans cet article, nous allons étudier comment passer une table de données à une procédure stockée. Cependant, avant cela, voyons comment les données tabulaires étaient transmises avant les paramètres table.

Passer des données sous forme tabulaire avant les paramètres de valeur de table

Les paramètres table ont été introduits dans SQL Server 2008. Auparavant, il existait des options limitées pour transmettre des données tabulaires aux procédures stockées. La plupart des développeurs ont utilisé l'une des méthodes suivantes :

  1. Les données dans plusieurs colonnes et lignes étaient représentées sous la forme d'une série de paramètres. Toutefois, le nombre maximal de paramètres pouvant être transmis à une procédure stockée SQL Server est de 2 100. Par conséquent, dans le cas d'une grande table, cette méthode ne pourrait pas être utilisée. En outre, un prétraitement est requis côté serveur afin de formater les paramètres individuels sous forme de tableau.
  2. Créez plusieurs instructions SQL pouvant affecter plusieurs lignes, telles que UPDATE. Les déclarations peuvent être envoyées au serveur individuellement ou sous forme groupée. Même s'ils sont envoyés sous forme de lot, les relevés sont exécutés individuellement sur le serveur.
  3. Une autre méthode consiste à utiliser des chaînes délimitées ou des documents XML pour regrouper les données de plusieurs lignes et colonnes, puis à transmettre ces valeurs textuelles à des instructions SQL paramétrées ou à des procédures stockées. L'inconvénient de cette approche était que vous deviez valider la structure des données afin de dissocier les valeurs.

Transmettre la table de données en tant que paramètre aux procédures stockées

Voyons maintenant comment les paramètres table peuvent être utilisés pour envoyer des données à une procédure stockée sans rencontrer aucun des problèmes abordés dans la section précédente. Les paramètres table permettent de transmettre plusieurs lignes de données à une procédure stockée par du code Transact-SQL ou à partir d'une application frontale. La taille maximale qu'un paramètre table peut avoir est égale à la taille maximale de la mémoire du serveur de base de données.

Dans cette section, nous utiliserons des paramètres de table avec une procédure stockée pour insérer plusieurs lignes dans une table de données.

La transmission de paramètres table à une procédure stockée est un processus en trois étapes :

  1. Créez un type de tableau défini par l'utilisateur qui correspond au tableau que vous souhaitez remplir.
  2. Transmettre la table définie par l'utilisateur à la procédure stockée en tant que paramètre
  3. Dans la procédure stockée, sélectionnez les données du paramètre transmis et insérez-les dans la table que vous souhaitez remplir.

Examinons un exemple de la manière dont nous pouvons transmettre une table de données à une procédure stockée à l'aide d'une fonction de table.

Tout d'abord, créez une table que nous voulons remplir. Exécutez le script suivant :

CREATE DATABASE ShowRoom


USE ShowRoom
Create Table Cars
(
    Id int primary key,
    Name nvarchar(50),
    company nvarchar(50)
)
Go

Dans le script ci-dessus, nous créons une base de données appelée ShowRoom avec une table, c'est-à-dire Cars. La table Cars comporte trois colonnes :Id, Name et company. Nous allons utiliser une procédure stockée pour remplir la table Cars.

Comme décrit précédemment, la première étape consiste à créer un type de table défini par l'utilisateur qui correspond à la table que vous souhaitez remplir. Exécutez le script suivant pour ce faire :

CREATE TYPE CarTableType AS TABLE
(
     Id int primary key,
    Name nvarchar(50),
    company nvarchar(50)
)
Go

Dans le script ci-dessus, nous créons la variable définie par l'utilisateur CarTableType du type Table. C'est la variable que nous allons passer à la procédure stockée. On peut voir que les colonnes de la variable CarTableType sont similaires à celles de la table Cars.

Créons maintenant une procédure stockée qui accepte la variable CarTableType comme paramètre. Dans la procédure stockée, nous sélectionnerons tous les enregistrements de cette variable et les insérerons dans la table Cars. Exécutez le script suivant pour créer une telle procédure stockée :

CREATE PROCEDURE spInsertCars
@CarType CarTableType READONLY
AS
BEGIN
    INSERT INTO Cars
    SELECT * FROM @CarType
END

Dans le script ci-dessus, nous créons la procédure stockée spInsertCars. Il est important de mentionner que vous devez spécifier le paramètre défini par l'utilisateur en tant que READONLY dans la procédure stockée, faute de quoi une erreur d'exécution se produira.

Vous pouvez voir que la procédure stockée spInsertCars accepte le paramètre CarTableType et l'affecte à la variable @CarType du type CarTableType.

La dernière étape consiste à créer une variable de la variable CarTableType, à la remplir avec des données factices et à la transmettre à la procédure stockée spInsertCars. Jetez un oeil au script suivant :

DECLARE @CarTableType CarTableType

INSERT INTO @CarTableType VALUES (1, 'Corrolla', 'Toyota')
INSERT INTO @CarTableType VALUES (2, 'Civic', 'Honda')
INSERT INTO @CarTableType VALUES (3, '6', 'Audi')
INSERT INTO @CarTableType VALUES (4, 'c100', 'Mercedez')
INSERT INTO @CarTableType VALUES (5, 'Mustang', 'Ford')

EXECUTE spInsertCars @CarTableType

Dans le script ci-dessus, nous déclarons d'abord la variable @CarTableType de type CarTableType. Nous insérons ensuite 5 enregistrements fictifs dans cette variable. Enfin, nous exécutons la procédure stockée spInsertCars et lui passons la variable @CarTableType en tant que paramètre.

Dans la procédure stockée, cinq enregistrements de la variable @CarTableType sont sélectionnés et insérés dans la table Cars. Maintenant, si vous sélectionnez tous les enregistrements de la table Cars, vous devriez voir les enregistrements nouvellement insérés. Exécutez le script suivant pour ce faire :

SELECT * FROM Cars

La sortie du script ci-dessus ressemble à ceci :

Il ressort de la sortie que tous les enregistrements de la variable @CarTableType ont été insérés dans la table Cars.