Fonctions logiques - GREATEST (Transact-SQL)
S’applique à :
SQL Server 2022 (16.x) Azure SQL DatabaseAzure SQL Managed InstanceAzure Synapse AnalyticsPoint de terminaison analytique SQL dans Microsoft FabricEntrepôt dans Microsoft Fabric
Cette fonction retourne la valeur maximale d’une liste d’une ou de plusieurs expressions.
Conventions de la syntaxe Transact-SQL
Syntaxe
GREATEST ( expression1 [ , ...expressionN ] )
Arguments
expression1, expressionN
Liste d’expressions séparées par des virgules d’un type de données comparable. La fonctionGREATESTrequiert au moins un argument et ne prend pas en charge plus de 254 arguments.
Chaque expression peut être une constante, une variable, un nom de colonne ou une fonction, et toute combinaison d’opérateurs arithmétiques, au niveau du bit et de chaîne. Les fonctions d’agrégation et les sous-requêtes scalaires sont autorisées.
Types de retour
Retourne le type de données ayant la priorité la plus élevée à partir de l'ensemble de types transmis à la fonction. Pour plus d’informations, consultez Priorités des types de données (Transact-SQL).
Si tous les arguments ont le même type de données et que le type est pris en charge pour la comparaison, GREATEST retourne ce type.
Sinon, la fonction convertit implicitement tous les arguments en type de données de la plus haute priorité avant la comparaison et utilise ce type comme type de retour.
Pour les types numériques, l’échelle du type de retour est identique à l’argument de la plus haute priorité, ou à l’échelle la plus grande si plusieurs arguments sont du type de données de la plus haute priorité.
Remarques
Toutes les expressions de la liste d’arguments doivent être d’un type de données comparable et qui peut être converti implicitement en type de données de l’argument ayant la plus haute priorité.
La conversion implicite de tous les arguments en type de données de la plus haute priorité a lieu avant la comparaison.
Si la conversion de type implicite entre les arguments n’est pas prise en charge, la fonction échoue et retourne une erreur.
Pour plus d’informations sur la conversion implicite et explicite, consultez Conversion de types de données (Moteur de base de données).
Si un ou plusieurs arguments ne sont pas NULL, les arguments NULL sont ignorés lors de la comparaison. Si tous les arguments sont NULL, GREATEST retourne NULL.
La comparaison des arguments de caractères respecte les règles de priorité de classement (Transact-SQL).
Les types suivants ne sont pas pris en charge pour la comparaison dans GREATEST : varchar(max), varbinary(max) ou nvarchar(max) dépassant 8 000 octets, cursor, geometry, geography, image, les types définis par l’utilisateur non ordonnés par octet, ntext, table, text et xml.
Les types de données varchar(max), varbinary(max) et nvarchar(max) sont pris en charge pour les arguments de 8 000 octets ou moins, et sont implicitement convertis en varchar(n), varbinary(n) et nvarchar(n), respectivement, avant la comparaison.
Par exemple, varchar (max) peut prendre en charge jusqu’à 8 000 caractères si vous utilisez un jeu de caractères d’encodage sur un octet, et nvarchar (max) peut prendre en charge jusqu’à 4 000 paires d’octets (en supposant l’encodage de caractères UTF-16).
Exemples
R. Retourner la valeur maximale à partir d’une liste de constantes
L’exemple suivant retourne la valeur maximale de la liste de constantes fournie.
L’échelle du type de retour est déterminée par l’échelle de l’argument avec le type de données de la plus haute priorité.
SELECT GREATEST('6.62', 3.1415, N'7') AS GreatestVal;
GO
Voici le jeu de résultats obtenu.
GreatestVal
--------
7.0000
(1 rows affected)
B. Retourner la valeur maximale à partir d’une liste de constantes de caractères
L’exemple suivant retourne la valeur maximale de la liste de constantes caractère fournie.
SELECT GREATEST('Glacier', N'Joshua Tree', 'Mount Rainier') AS GreatestString;
GO
Voici le jeu de résultats obtenu.
GreatestString
-------------
Mount Rainier
(1 rows affected)
C. Retourner la valeur maximale à partir d’une liste d’arguments de colonne
Cet exemple retourne la valeur maximale d’une liste d’arguments de colonne et ignore les valeurs NULL pendant la comparaison. Cet exemple utilise la base de données AdventureWorksLT, qui peut être rapidement installée comme exemple de base de données pour une nouvelle Azure SQL Database. Pour plus d’informations, consultez Exemples de bases de données AdventureWorks.
SELECT P.Name,
P.SellStartDate,
P.DiscontinuedDate,
PM.ModifiedDate AS ModelModifiedDate,
GREATEST(P.SellStartDate, P.DiscontinuedDate, PM.ModifiedDate) AS LatestDate
FROM SalesLT.Product AS P
INNER JOIN SalesLT.ProductModel AS PM
ON P.ProductModelID = PM.ProductModelID
WHERE GREATEST(P.SellStartDate, P.DiscontinuedDate, PM.ModifiedDate) >= '2007-01-01'
AND P.SellStartDate >= '2007-01-01'
AND P.Name LIKE 'Touring %'
ORDER BY P.Name;
Voici le jeu de résultats obtenu. LatestDate choisit la valeur de date la plus élevée des trois valeurs, en ignorant NULL.
Name SellStartDate DiscontinuedDate ModelModifiedDate LatestDate
-------------------- ----------------------- ------------------- ----------------------- -----------------------
Touring Pedal 2007-07-01 00:00:00.000 NULL 2009-05-16 16:34:29.027 2009-05-16 16:34:29.027
Touring Tire 2007-07-01 00:00:00.000 NULL 2007-06-01 00:00:00.000 2007-07-01 00:00:00.000
Touring Tire Tube 2007-07-01 00:00:00.000 NULL 2007-06-01 00:00:00.000 2007-07-01 00:00:00.000
(3 rows affected)
D. Utilisation de GREATEST avec des variables locales
Cet exemple utilise GREATEST pour déterminer la valeur maximale d’une liste de variables locales dans le prédicat d’une clause WHERE.
CREATE TABLE dbo.Studies (
VarX VARCHAR(10) NOT NULL,
Correlation DECIMAL(4, 3) NULL
);
INSERT INTO dbo.Studies
VALUES ('Var1', 0.2),
('Var2', 0.825),
('Var3', 0.61);
GO
DECLARE @PredictionA DECIMAL(2, 1) = 0.7;
DECLARE @PredictionB DECIMAL(3, 1) = 0.65;
SELECT VarX,
Correlation
FROM dbo.Studies
WHERE Correlation > GREATEST(@PredictionA, @PredictionB);
GO
Voici le jeu de résultats obtenu. Seules les valeurs supérieures à 0,7 sont affichées.
VarX Correlation
---------- -----------
Var2 .825
(1 rows affected)
E. Utilisation de GREATEST avec des colonnes, des constantes et des variables
Cet exemple utilise GREATEST pour déterminer la valeur maximale d’une liste mixte qui comprend des colonnes, des constantes et des variables.
CREATE TABLE dbo.Studies (
VarX VARCHAR(10) NOT NULL,
Correlation DECIMAL(4, 3) NULL
);
INSERT INTO dbo.Studies
VALUES ('Var1', 0.2),
('Var2', 0.825),
('Var3', 0.61);
GO
DECLARE @VarX DECIMAL(4, 3) = 0.59;
SELECT VarX,
Correlation,
GREATEST(Correlation, 0, @VarX) AS GreatestVar
FROM dbo.Studies;
GO
Voici le jeu de résultats obtenu.
VarX Correlation GreatestVar
---------- --------------------- ---------------------
Var1 0.200 0.590
Var2 0.825 0.825
Var3 0.610 0.610
(3 rows affected)
Étapes suivantes
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour