Variables SQL : DECLARE, SET et utilisation pratique

Les variables SQL permettent de stocker temporairement une valeur pour la réutiliser dans une requête ou un script. Dès qu'on écrit des scripts complexes, des procédures ou des tests de données, elles deviennent indispensables. Pourtant, beaucoup de candidats en entretien data confondent leur syntaxe selon les SGBD, ou ignorent leur portée réelle. Cet article vous montre comment déclarer une variable avec DECLARE, lui affecter une valeur avec SET, et l'exploiter dans des cas concrets — y compris les pièges à éviter.

Pourquoi utiliser des variables dans un script SQL ?

Quand une requête répète plusieurs fois la même valeur — un seuil, une date, un identifiant — remplacer cette valeur par une variable améliore la maintenabilité. Si la valeur change, on la modifie en 1 seul endroit.

Les variables sont aussi utiles pour décomposer un calcul complexe. Plutôt que d'imbriquer 5 fonctions dans une seule expression, on peut stocker les résultats intermédiaires. C'est plus lisible et plus facile à déboguer.

Enfin, en contexte d'entretien, savoir utiliser des variables montre qu'on pense au-delà de la requête unique. Cela témoigne d'une vision de scripting et d'automatisation, compétence très recherchée chez un data analyst ou un data engineer.

DECLARE et SET : la syntaxe de base en T-SQL

SQL Server (T-SQL) est souvent le premier dialecte où l'on rencontre les variables. La déclaration commence par DECLARE, suivi du nom de la variable (préfixé par @) et de son type.

DECLARE @seuil_ca INT;
SET @seuil_ca = 10000;

SELECT client_id, total_ca
FROM commandes
WHERE total_ca > @seuil_ca;

La variable @seuil_ca est déclarée avec le type INT, puis initialisée à 10000. La requête finale l'utilise comme n'importe quelle valeur littérale. Si demain le seuil passe à 15000, on modifie uniquement la ligne SET.

On peut aussi initialiser directement dans DECLARE :

DECLARE @seuil_ca INT = 10000;

C'est plus concis et préférable quand la valeur est connue d'emblée.

Affecter une valeur via SELECT

SET affecte une valeur scalaire fixe. Mais si on veut affecter le résultat d'une requête, on utilise SELECT :

DECLARE @nb_clients INT;
SELECT @nb_clients = COUNT(*) FROM clients WHERE actif = 1;

PRINT 'Clients actifs : ' + CAST(@nb_clients AS VARCHAR);

Les variables en MySQL : une syntaxe différente

MySQL distingue deux types de variables : les variables locales (dans les procédures stockées) et les variables utilisateur (préfixées par @ sans DECLARE).

Variables utilisateur (session)

SET @seuil = 500;

SELECT produit_id, ventes
FROM stats_ventes
WHERE ventes > @seuil;

Ces variables persistent pour toute la session MySQL. Pas besoin de DECLARE. Elles sont pratiques pour des scripts rapides, mais attention : leur portée globale à la session peut créer des effets de bord si on ne les réinitialise pas.

Variables locales dans une procédure MySQL

À l'intérieur d'un bloc BEGIN...END, on utilise DECLARE comme en T-SQL, mais sans le préfixe @ :

DELIMITER $$
CREATE PROCEDURE calcul_bonus()
BEGIN
  DECLARE taux DECIMAL(5,2);
  SET taux = 0.10;
  
  UPDATE employes
  SET salaire = salaire * (1 + taux)
  WHERE anciennete > 5;
END$$
DELIMITER ;

La variable taux est locale au bloc BEGIN...END de la procédure. Elle disparaît dès la fin de l'exécution.

Variables en PL/pgSQL (PostgreSQL)

PostgreSQL utilise PL/pgSQL pour les blocs procéduraux. La syntaxe ressemble à celle de T-SQL mais avec quelques différences importantes.

DO $$
DECLARE
  v_seuil INTEGER := 1000;
  v_count INTEGER;
BEGIN
  SELECT COUNT(*) INTO v_count
  FROM commandes
  WHERE montant > v_seuil;
  
  RAISE NOTICE 'Commandes > % : %', v_seuil, v_count;
END;
$$;

Notez l'usage de := pour l'affectation (et non = ou SET), et INTO pour capturer le résultat d'un SELECT. La clause RAISE NOTICE sert à afficher des messages de debug — l'équivalent de PRINT en T-SQL.

Comparatif des syntaxes selon les SGBD