SQL - Fonctions numériques
Les fonctions numériques SQL sont principalement utilisées pour la manipulation numérique et / ou les calculs mathématiques. Le tableau suivant détaille les fonctions numériques -
| N ° Sr. | Description de la fonction |
|---|---|
| 1 | ABDOS() Renvoie la valeur absolue de l'expression numérique. |
| 2 | ACOS () Renvoie l'arc cosinus d'une expression numérique. Renvoie NULL si la valeur n'est pas comprise entre -1 et 1. |
| 3 | UN PÉCHÉ() Renvoie l'arc sinus d'une expression numérique. Renvoie NULL si la valeur n'est pas comprise entre -1 et 1 |
| 4 | UN BRONZAGE() Renvoie l'arc tangente de l'expression numérique. |
| 5 | ATAN2 () Renvoie l'arc tangente des deux variables qui lui sont passées. |
| 6 | BIT_AND () Renvoie le ET au niveau du bit de tous les bits de l'expression. |
| sept | BIT_COUNT () Renvoie la représentation sous forme de chaîne de la valeur binaire qui lui est transmise. |
| 8 | BIT_OR () Renvoie le OU au niveau du bit de tous les bits de l'expression transmise. |
| 9 | CEIL () Renvoie la plus petite valeur entière qui n'est pas inférieure à l'expression numérique transmise |
| dix | PLAFOND() Renvoie la plus petite valeur entière qui n'est pas inférieure à l'expression numérique transmise |
| 11 | CONV () Convertissez une expression numérique d'une base à une autre. |
| 12 | COS () Renvoie le cosinus de l'expression numérique transmise. L'expression numérique doit être exprimée en radians. |
| 13 | COT () Renvoie la cotangente de l'expression numérique passée. |
| 14 | DEGRÉS() Renvoie une expression numérique convertie de radians en degrés. |
| 15 | EXP () Renvoie la base du logarithme naturel (e) élevé à la puissance de l'expression numérique passée. |
| 16 | SOL() Renvoie la plus grande valeur entière qui n'est pas supérieure à l'expression numérique transmise. |
| 17 | FORMAT() Renvoie une expression numérique arrondie à un certain nombre de décimales. |
| 18 | PLUS GRAND () Renvoie la plus grande valeur des expressions d'entrée. |
| 19 | INTERVALLE() Prend plusieurs expressions exp1, exp2 et exp3 ainsi de suite .. et renvoie 0 si exp1 est inférieur à exp2, retourne 1 si exp1 est inférieur à exp3 et ainsi de suite. |
| 20 | MOINS() Renvoie l'entrée de valeur minimale lorsqu'elle en donne deux ou plus. |
| 21 | JOURNAL() Renvoie le logarithme naturel de l'expression numérique transmise. |
| 22 | LOG10 () Renvoie le logarithme en base 10 de l'expression numérique transmise. |
| 23 | MOD () Renvoie le reste d'une expression en plongeant par une autre expression. |
| 24 | OCT() Renvoie la représentation sous forme de chaîne de la valeur octale de l'expression numérique transmise. Renvoie NULL si la valeur passée est NULL. |
| 25 | PI() Renvoie la valeur de pi |
| 26 | POW () Renvoie la valeur d'une expression élevée à la puissance d'une autre expression |
| 27 | PUISSANCE() Renvoie la valeur d'une expression élevée à la puissance d'une autre expression |
| 28 | RADIENS () Renvoie la valeur de l'expression passée convertie de degrés en radians. |
| 29 | ROND() Renvoie une expression numérique arrondie à un entier. Peut être utilisé pour arrondir une expression à un certain nombre de points décimaux |
| 30 | PÉCHÉ() Renvoie le sinus de l'expression numérique exprimé en radians. |
| 31 | SQRT () Renvoie la racine carrée non négative de l'expression numérique. |
| 32 | STD () Renvoie l'écart type de l'expression numérique. |
| 33 | STDDEV () Renvoie l'écart type de l'expression numérique. |
| 34 | BRONZER() Renvoie la tangente de l'expression numérique exprimée en radians. |
| 35 | TRONQUER() Renvoie exp1 numérique tronqué à exp2 décimales. Si exp2 est 0, le résultat n'aura pas de point décimal. |
ABS (X)
La fonction ABS () renvoie la valeur absolue de X. Prenons l'exemple suivant -
SQL> SELECT ABS(2);
+---------------------------------------------------------+
| ABS(2) |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT ABS(-2);
+---------------------------------------------------------+
| ABS(2) |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
1 row in set (0.00 sec)ACOS (X)
Cette fonction renvoie l'arc cosinus de X. La valeur de X doit être comprise entre -1 et 1 ou NULL sera retourné. Prenons l'exemple suivant -
SQL> SELECT ACOS(1);
+---------------------------------------------------------+
| ACOS(1) |
+---------------------------------------------------------+
| 0.000000 |
+---------------------------------------------------------+
1 row in set (0.00 sec)ASIN (X)
La fonction ASIN () renvoie l'arc sinus de X. La valeur de X doit être comprise entre -1 et 1 ou NULL est renvoyé.
SQL> SELECT ASIN(1);
+---------------------------------------------------------+
| ASIN(1) |
+---------------------------------------------------------+
| 1.5707963267949 |
+---------------------------------------------------------+
1 row in set (0.00 sec)ATAN (X)
Cette fonction renvoie l'arc tangente de X.
SQL> SELECT ATAN(1);
+---------------------------------------------------------+
| ATAN(1) |
+---------------------------------------------------------+
| 0.78539816339745 |
+---------------------------------------------------------+
1 row in set (0.00 sec)ATAN2 (Y, X)
Cette fonction renvoie l'arc tangente des deux arguments: X et Y. Elle est similaire à l'arc tangente de Y / X, sauf que les signes des deux sont utilisés pour trouver le quadrant du résultat.
SQL> SELECT ATAN2(3,6);
+---------------------------------------------------------+
| ATAN2(3,6) |
+---------------------------------------------------------+
| 0.46364760900081 |
+---------------------------------------------------------+
1 row in set (0.00 sec)BIT_AND (expression)
La fonction BIT_AND renvoie le ET au niveau du bit de tous les bits de l'expression. Le principe de base est que si deux bits correspondants sont identiques, une opération ET au niveau du bit renverra 1, tandis que s'ils sont différents, une opération ET au niveau du bit retournera 0. La fonction elle-même renvoie une valeur entière de 64 bits. S'il n'y a pas de correspondance, alors il renverra 18446744073709551615. L'exemple suivant exécute la fonction BIT_AND sur la colonne PRICE groupée par le FABRICANT de la voiture -
SQL> SELECT
MAKER, BIT_AND(PRICE) BITS
FROM CARS GROUP BY MAKER
+---------------------------------------------------------+
|MAKER BITS |
+---------------------------------------------------------+
|CHRYSLER 512 |
|FORD 12488 |
|HONDA 2144 |
+---------------------------------------------------------+
1 row in set (0.00 sec)BIT_COUNT (valeur_numérique)
La fonction BIT_COUNT () renvoie le nombre de bits actifs dans numeric_value. L'exemple suivant illustre l'utilisation de la fonction BIT_COUNT () pour renvoyer le nombre de bits actifs pour une plage de nombres -
SQL> SELECT
BIT_COUNT(2) AS TWO,
BIT_COUNT(4) AS FOUR,
BIT_COUNT(7) AS SEVEN
+-----+------+-------+
| TWO | FOUR | SEVEN |
+-----+------+-------+
| 1 | 1 | 3 |
+-----+------+-------+
1 row in set (0.00 sec)BIT_OR (expression)
La fonction BIT_OR () renvoie le OU au niveau du bit de tous les bits de l'expression. La prémisse de base de la fonction OR au niveau du bit est qu'elle renvoie 0 si les bits correspondants correspondent et 1 si ce n'est pas le cas. La fonction renvoie un entier 64 bits, et s'il n'y a pas de lignes correspondantes, elle renvoie 0. L'exemple suivant exécute la fonction BIT_OR () sur la colonne PRICE de la table CARS, regroupée par le MAKER -
SQL> SELECT
MAKER, BIT_OR(PRICE) BITS
FROM CARS GROUP BY MAKER
+---------------------------------------------------------+
|MAKER BITS |
+---------------------------------------------------------+
|CHRYSLER 62293 |
|FORD 16127 |
|HONDA 32766 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CEIL (X)
PLAFOND (X)
Ces fonctions renvoient la plus petite valeur entière qui n'est pas inférieure à X. Prenons l'exemple suivant -
SQL> SELECT CEILING(3.46);
+---------------------------------------------------------+
| CEILING(3.46) |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT CEIL(-6.43);
+---------------------------------------------------------+
| CEIL(-6.43) |
+---------------------------------------------------------+
| -6 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CONV (N, from_base, to_base)
Le but de la fonction CONV () est de convertir des nombres entre différentes bases de nombres. La fonction renvoie une chaîne de la valeur N convertie de from_base à to_base. La valeur de base minimale est 2 et la valeur maximale est 36. Si l'un des arguments est NULL, la fonction renvoie NULL. Prenons l'exemple suivant, qui convertit le nombre 5 de la base 16 en base 2 -
SQL> SELECT CONV(5,16,2);
+---------------------------------------------------------+
| CONV(5,16,2) |
+---------------------------------------------------------+
| 101 |
+---------------------------------------------------------+
1 row in set (0.00 sec)COS (X)
Cette fonction renvoie le cosinus de X. La valeur de X est donnée en radians.
SQL>SELECT COS(90);
+---------------------------------------------------------+
| COS(90) |
+---------------------------------------------------------+
| -0.44807361612917 |
+---------------------------------------------------------+
1 row in set (0.00 sec)COT (X)
Cette fonction renvoie la cotangente de X. Prenons l'exemple suivant -
SQL>SELECT COT(1);
+---------------------------------------------------------+
| COT(1) |
+---------------------------------------------------------+
| 0.64209261593433 |
+---------------------------------------------------------+
1 row in set (0.00 sec)DEGRÉS (X)
Cette fonction renvoie la valeur de X convertie de radians en degrés.
SQL>SELECT DEGREES(PI());
+---------------------------------------------------------+
| DEGREES(PI()) |
+---------------------------------------------------------+
| 180.000000 |
+---------------------------------------------------------+
1 row in set (0.00 sec)EXP (X)
Cette fonction renvoie la valeur de e (la base du logarithme népérien) élevée à la puissance X.
SQL>SELECT EXP(3);
+---------------------------------------------------------+
| EXP(3) |
+---------------------------------------------------------+
| 20.085537 |
+---------------------------------------------------------+
1 row in set (0.00 sec)PLANCHER (X)
Cette fonction renvoie la plus grande valeur entière qui n'est pas supérieure à X.
SQL>SELECT FLOOR(7.55);
+---------------------------------------------------------+
| FLOOR(7.55) |
+---------------------------------------------------------+
| 7 |
+---------------------------------------------------------+
1 row in set (0.00 sec)FORMAT (X, D)
La fonction FORMAT () est utilisée pour mettre en forme le nombre X au format suivant: ###, ###, ###. ## tronqué à D décimales. L'exemple suivant montre l'utilisation et la sortie de la fonction FORMAT () -
SQL>SELECT FORMAT(423423234.65434453,2);
+---------------------------------------------------------+
| FORMAT(423423234.65434453,2) |
+---------------------------------------------------------+
| 423,423,234.65 |
+---------------------------------------------------------+
1 row in set (0.00 sec)PLUS GRAND (n1, n2, n3, ..........)
La fonction GREATEST () renvoie la plus grande valeur de l'ensemble des paramètres d'entrée (n1, n2, n3, et ainsi de suite). L'exemple suivant utilise la fonction GREATEST () pour renvoyer le plus grand nombre d'un ensemble de valeurs numériques -
SQL>SELECT GREATEST(3,5,1,8,33,99,34,55,67,43);
+---------------------------------------------------------+
| GREATEST(3,5,1,8,33,99,34,55,67,43) |
+---------------------------------------------------------+
| 99 |
+---------------------------------------------------------+
1 row in set (0.00 sec)INTERVALLE (N, N1, N2, N3, ..........)
La fonction INTERVAL () compare la valeur de N à la liste de valeurs (N1, N2, N3, etc.). La fonction renvoie 0 si N <N1, 1 si N <N2, 2 si N <N3, et ainsi de suite. Il renverra .1 si N est NULL. La liste de valeurs doit être sous la forme N1 <N2 <N3 pour fonctionner correctement. Le code suivant est un exemple simple du fonctionnement de la fonction INTERVAL () -
SQL>SELECT INTERVAL(6,1,2,3,4,5,6,7,8,9,10);
+---------------------------------------------------------+
| INTERVAL(6,1,2,3,4,5,6,7,8,9,10) |
+---------------------------------------------------------+
| 6 |
+---------------------------------------------------------+
1 row in set (0.00 sec)INTERVALLE (N, N1, N2, N3, ..........)
La fonction INTERVAL () compare la valeur de N à la liste de valeurs (N1, N2, N3, etc.). La fonction renvoie 0 si N <N1, 1 si N <N2, 2 si N <N3, et ainsi de suite. Il renverra .1 si N est NULL. La liste de valeurs doit être sous la forme N1 <N2 <N3 pour fonctionner correctement. Le code suivant est un exemple simple du fonctionnement de la fonction INTERVAL () -
SQL>SELECT INTERVAL(6,1,2,3,4,5,6,7,8,9,10);
+---------------------------------------------------------+
| INTERVAL(6,1,2,3,4,5,6,7,8,9,10) |
+---------------------------------------------------------+
| 6 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Rappelez-vous que 6 est l'index de base zéro dans la liste de valeurs de la première valeur qui était supérieure à N. Dans notre cas, 7 était la valeur incriminée et se trouve dans le sixième emplacement d'index.
MOINS (N1, N2, N3, N4, ......)
La fonction LEAST () est l'opposé de la fonction GREATEST (). Son objectif est de retourner l'élément le moins valorisé de la liste de valeurs (N1, N2, N3, etc.). L'exemple suivant montre l'utilisation et la sortie appropriées de la fonction LEAST () -
SQL>SELECT LEAST(3,5,1,8,33,99,34,55,67,43);
+---------------------------------------------------------+
| LEAST(3,5,1,8,33,99,34,55,67,43) |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)JOURNAL (X)
JOURNAL (B, X)
La version à argument unique de la fonction renverra le logarithme naturel de X. Si elle est appelée avec deux arguments, elle renvoie le logarithme de X pour une base arbitraire B. Prenons l'exemple suivant -
SQL>SELECT LOG(45);
+---------------------------------------------------------+
| LOG(45) |
+---------------------------------------------------------+
| 3.806662 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL>SELECT LOG(2,65536);
+---------------------------------------------------------+
| LOG(2,65536) |
+---------------------------------------------------------+
| 16.000000 |
+---------------------------------------------------------+
1 row in set (0.00 sec)LOG10 (X)
Cette fonction renvoie le logarithme en base 10 de X.
SQL>SELECT LOG10(100);
+---------------------------------------------------------+
| LOG10(100) |
+---------------------------------------------------------+
| 2.000000 |
+---------------------------------------------------------+
1 row in set (0.00 sec)MOD (N, M)
Cette fonction renvoie le reste de N divisé par M. Prenons l'exemple suivant -
SQL>SELECT MOD(29,3);
+---------------------------------------------------------+
| MOD(29,3) |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
1 row in set (0.00 sec)OCT (N)
La fonction OCT () renvoie la représentation sous forme de chaîne du nombre octal N. Cela équivaut à utiliser CONV (N, 10,8).
SQL>SELECT OCT(12);
+---------------------------------------------------------+
| OCT(12) |
+---------------------------------------------------------+
| 14 |
+---------------------------------------------------------+
1 row in set (0.00 sec)PI()
Cette fonction renvoie simplement la valeur de pi. SQL stocke en interne la valeur double précision complète de pi.
SQL>SELECT PI();
+---------------------------------------------------------+
| PI() |
+---------------------------------------------------------+
| 3.141593 |
+---------------------------------------------------------+
1 row in set (0.00 sec)POW (X, Y)
PUISSANCE (X, Y)
Ces deux fonctions renvoient la valeur de X élevée à la puissance Y.
SQL> SELECT POWER(3,3);
+---------------------------------------------------------+
| POWER(3,3) |
+---------------------------------------------------------+
| 27 |
+---------------------------------------------------------+
1 row in set (0.00 sec)RADIENS (X)
Cette fonction renvoie la valeur de X, convertie de degrés en radians.
SQL>SELECT RADIANS(90);
+---------------------------------------------------------+
| RADIANS(90) |
+---------------------------------------------------------+
|1.570796 |
+---------------------------------------------------------+
1 row in set (0.00 sec)ROND (X)
ROND (X, D)
Cette fonction renvoie X arrondi à l'entier le plus proche. Si un deuxième argument, D, est fourni, la fonction renvoie X arrondi à D décimales. D doit être positif ou tous les chiffres à droite du point décimal seront supprimés. Prenons l'exemple suivant -
SQL>SELECT ROUND(5.693893);
+---------------------------------------------------------+
| ROUND(5.693893) |
+---------------------------------------------------------+
| 6 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL>SELECT ROUND(5.693893,2);
+---------------------------------------------------------+
| ROUND(5.693893,2) |
+---------------------------------------------------------+
| 5.69 |
+---------------------------------------------------------+
1 row in set (0.00 sec)SIGNE (X)
Cette fonction renvoie le signe de X (négatif, zéro ou positif) sous la forme -1, 0 ou 1.
SQL>SELECT SIGN(-4.65);
+---------------------------------------------------------+
| SIGN(-4.65) |
+---------------------------------------------------------+
| -1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL>SELECT SIGN(0);
+---------------------------------------------------------+
| SIGN(0) |
+---------------------------------------------------------+
| 0 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL>SELECT SIGN(4.65);
+---------------------------------------------------------+
| SIGN(4.65) |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)SIN (X)
Cette fonction renvoie le sinus de X. Prenons l'exemple suivant -
SQL>SELECT SIN(90);
+---------------------------------------------------------+
| SIN(90) |
+---------------------------------------------------------+
| 0.893997 |
+---------------------------------------------------------+
1 row in set (0.00 sec)SQRT (X)
Cette fonction renvoie la racine carrée non négative de X. Prenons l'exemple suivant -
SQL>SELECT SQRT(49);
+---------------------------------------------------------+
| SQRT(49) |
+---------------------------------------------------------+
| 7 |
+---------------------------------------------------------+
1 row in set (0.00 sec)STD (expression)
STDDEV (expression)
La fonction STD () est utilisée pour renvoyer l'écart type de l'expression. Cela équivaut à prendre la racine carrée de la VARIANCE () de l'expression. L'exemple suivant calcule l'écart type de la colonne PRICE dans notre table CARS -
SQL>SELECT STD(PRICE) STD_DEVIATION FROM CARS;
+---------------------------------------------------------+
| STD_DEVIATION |
+---------------------------------------------------------+
| 7650.2146 |
+---------------------------------------------------------+
1 row in set (0.00 sec)TAN (X)
Cette fonction renvoie la tangente de l'argument X, qui est exprimée en radians.
SQL>SELECT TAN(45);
+---------------------------------------------------------+
| TAN(45) |
+---------------------------------------------------------+
| 1.619775 |
+---------------------------------------------------------+
1 row in set (0.00 sec)TRONCATE (X, D)
Cette fonction est utilisée pour renvoyer la valeur de X tronquée au nombre D de décimales. Si D est 0, la virgule décimale est supprimée. Si D est négatif, alors le nombre D de valeurs dans la partie entière de la valeur est tronqué. Prenons l'exemple suivant -
SQL>SELECT TRUNCATE(7.536432,2);
+---------------------------------------------------------+
| TRUNCATE(7.536432,2) |
+---------------------------------------------------------+
| 7.53 |
+---------------------------------------------------------+
1 row in set (0.00 sec)