SQL - Funzioni numeriche

Le funzioni numeriche SQL vengono utilizzate principalmente per la manipolazione numerica e / o i calcoli matematici. La tabella seguente descrive in dettaglio le funzioni numeriche:

Sr.No. Descrizione della funzione
1 ADDOMINALI()

Restituisce il valore assoluto dell'espressione numerica.

2 ACOS ()

Restituisce l'arcoseno dell'espressione numerica. Restituisce NULL se il valore non è compreso tra -1 e 1.

3 COME IN()

Restituisce l'arcoseno dell'espressione numerica. Restituisce NULL se il valore non è compreso tra -1 e 1

4 UN'ABBRONZATURA()

Restituisce l'arcotangente dell'espressione numerica.

5 ATAN2 ()

Restituisce l'arcotangente delle due variabili ad esso passate.

6 BIT_AND ()

Restituisce l'AND bit per bit di tutti i bit nell'espressione.

7 BIT_COUNT ()

Restituisce la rappresentazione di stringa del valore binario che gli è stato passato.

8 BIT_OR ()

Restituisce l'OR bit per bit di tutti i bit nell'espressione passata.

9 CEIL ()

Restituisce il valore intero più piccolo che non è inferiore all'espressione numerica passata

10 SOFFITTO()

Restituisce il valore intero più piccolo che non è inferiore all'espressione numerica passata

11 CONV ()

Converte l'espressione numerica da una base all'altra.

12 COS ()

Restituisce il coseno dell'espressione numerica passata. L'espressione numerica deve essere espressa in radianti.

13 CULLA()

Restituisce la cotangente dell'espressione numerica passata.

14 GRADI()

Restituisce un'espressione numerica convertita da radianti a gradi.

15 SCAD ()

Restituisce la base del logaritmo naturale (e) elevato alla potenza dell'espressione numerica passata.

16 PAVIMENTO()

Restituisce il valore intero più grande che non è maggiore dell'espressione numerica passata.

17 FORMATO()

Restituisce un'espressione numerica arrotondata a un numero di posizioni decimali.

18 PIÙ GRANDE()

Restituisce il valore più grande delle espressioni di input.

19 INTERVALLO()

Accetta più espressioni exp1, exp2 e exp3 così via .. e restituisce 0 se exp1 è minore di exp2, restituisce 1 se exp1 è minore di exp3 e così via.

20 MENO()

Restituisce l'input con valore minimo quando vengono forniti due o più.

21 LOG ()

Restituisce il logaritmo naturale dell'espressione numerica passata.

22 LOG10 ()

Restituisce il logaritmo in base 10 dell'espressione numerica passata.

23 MOD ()

Restituisce il resto di un'espressione immergendosi in un'altra espressione.

24 OTTOBRE ()

Restituisce la rappresentazione di stringa del valore ottale dell'espressione numerica passata. Restituisce NULL se il valore passato è NULL.

25 PI()

Restituisce il valore di pi greco

26 POW ()

Restituisce il valore di un'espressione elevata alla potenza di un'altra espressione

27 ENERGIA()

Restituisce il valore di un'espressione elevata alla potenza di un'altra espressione

28 RADIANTI ()

Restituisce il valore dell'espressione passata convertita da gradi a radianti.

29 IL GIRO()

Restituisce un'espressione numerica arrotondata a un numero intero. Può essere utilizzato per arrotondare un'espressione a un numero di punti decimali

30 PECCATO()

Restituisce il seno di un'espressione numerica espressa in radianti.

31 SQRT ()

Restituisce la radice quadrata non negativa di un'espressione numerica.

32 STD ()

Restituisce la deviazione standard dell'espressione numerica.

33 STDDEV ()

Restituisce la deviazione standard dell'espressione numerica.

34 TAN ()

Restituisce la tangente di un'espressione numerica espressa in radianti.

35 TRONCARE()

Restituisce exp1 numerico troncato a cifre decimali exp2. Se exp2 è 0, il risultato non avrà punto decimale.

ABS (X)

La funzione ABS () restituisce il valore assoluto di X. Considera il seguente esempio:

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)

Questa funzione restituisce l'arcoseno di X. Il valore di X deve essere compreso tra -1 e 1 altrimenti verrà restituito NULL. Considera il seguente esempio:

SQL> SELECT ACOS(1);
+---------------------------------------------------------+
| ACOS(1)                                                 |
+---------------------------------------------------------+
| 0.000000                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

ASIN (X)

La funzione ASIN () restituisce l'arcoseno di X. Il valore di X deve essere compreso tra -1 e 1 o viene restituito NULL.

SQL> SELECT ASIN(1);
+---------------------------------------------------------+
| ASIN(1)                                                 |
+---------------------------------------------------------+
| 1.5707963267949                                         |
+---------------------------------------------------------+
1 row in set (0.00 sec)

ATAN (X)

Questa funzione restituisce l'arcotangente di X.

SQL> SELECT ATAN(1);
+---------------------------------------------------------+
| ATAN(1)                                                 |
+---------------------------------------------------------+
| 0.78539816339745                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

ATAN2 (Y, X)

Questa funzione restituisce l'arcotangente dei due argomenti: X e Y. È simile all'arcotangente di Y / X, tranne per il fatto che i segni di entrambi vengono utilizzati per trovare il quadrante del risultato.

SQL> SELECT ATAN2(3,6);
+---------------------------------------------------------+
| ATAN2(3,6)                                              |
+---------------------------------------------------------+
| 0.46364760900081                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

BIT_AND (espressione)

La funzione BIT_AND restituisce l'AND bit per bit di tutti i bit nell'espressione. La premessa di base è che se due bit corrispondenti sono uguali, un'operazione AND bit a bit restituirà 1, mentre se sono diversi, un'operazione AND bit a bit restituirà 0. La funzione stessa restituisce un valore intero a 64 bit. Se non ci sono corrispondenze, restituirà 18446744073709551615. L'esempio seguente esegue la funzione BIT_AND sulla colonna PRICE raggruppata dal MAKER dell'auto -

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 (valore_numero)

La funzione BIT_COUNT () restituisce il numero di bit attivi in ​​numeric_value. L'esempio seguente mostra come utilizzare la funzione BIT_COUNT () per restituire il numero di bit attivi per un intervallo di numeri:

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 (espressione)

La funzione BIT_OR () restituisce l'OR bit per bit di tutti i bit nell'espressione. La premessa di base della funzione OR bit per bit è che restituisce 0 se i bit corrispondenti corrispondono e 1 se non lo fanno. La funzione restituisce un numero intero a 64 bit e, se non ci sono righe corrispondenti, restituisce 0. L'esempio seguente esegue la funzione BIT_OR () sulla colonna PRICE della tabella CARS, raggruppata dal 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)

SOFFITTO (X)

SOFFITTO (X)

Queste funzioni restituiscono il valore intero più piccolo che non è inferiore a X. Considera il seguente esempio:

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)

Lo scopo della funzione CONV () è convertire i numeri tra diverse basi numeriche. La funzione restituisce una stringa del valore N convertita da from_base a to_base. Il valore di base minimo è 2 e il massimo è 36. Se uno degli argomenti è NULL, la funzione restituisce NULL. Considera il seguente esempio, che converte il numero 5 dalla base 16 alla base 2:

SQL> SELECT CONV(5,16,2);
+---------------------------------------------------------+
| CONV(5,16,2)                                            |
+---------------------------------------------------------+
| 101                                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

COS (X)

Questa funzione restituisce il coseno di X. Il valore di X è espresso in radianti.

SQL>SELECT COS(90);
+---------------------------------------------------------+
| COS(90)                                                 |
+---------------------------------------------------------+
| -0.44807361612917                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

COT (X)

Questa funzione restituisce la cotangente di X. Considera il seguente esempio:

SQL>SELECT COT(1);
+---------------------------------------------------------+
| COT(1)                                                  |
+---------------------------------------------------------+
| 0.64209261593433                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

GRADI (X)

Questa funzione restituisce il valore di X convertito da radianti a gradi.

SQL>SELECT DEGREES(PI());
+---------------------------------------------------------+
| DEGREES(PI())                                           |
+---------------------------------------------------------+
| 180.000000                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SCAD (X)

Questa funzione restituisce il valore di e (la base del logaritmo naturale) elevato alla potenza di X.

SQL>SELECT EXP(3);
+---------------------------------------------------------+
| EXP(3)                                                  |
+---------------------------------------------------------+
| 20.085537                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

PAVIMENTO (X)

Questa funzione restituisce il valore intero più grande che non è maggiore di X.

SQL>SELECT FLOOR(7.55);
+---------------------------------------------------------+
| FLOOR(7.55)                                             |
+---------------------------------------------------------+
| 7                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

FORMATO (X, D)

La funzione FORMAT () viene utilizzata per formattare il numero X nel seguente formato: ###, ###, ###. ## troncato in D cifre decimali. L'esempio seguente mostra l'uso e l'output della funzione FORMAT ():

SQL>SELECT FORMAT(423423234.65434453,2);
+---------------------------------------------------------+
| FORMAT(423423234.65434453,2)                            |
+---------------------------------------------------------+
| 423,423,234.65                                          |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MIGLIORE (n1, n2, n3, ..........)

La funzione GREATEST () restituisce il valore massimo nel set di parametri di input (n1, n2, n3, e così via). L'esempio seguente utilizza la funzione GREATEST () per restituire il numero più grande da un insieme di valori numerici:

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)

INTERVALLO (N, N1, N2, N3, ..........)

La funzione INTERVALLO () confronta il valore di N con l'elenco di valori (N1, N2, N3 e così via). La funzione restituisce 0 se N <N1, 1 se N <N2, 2 se N <N3 e così via. Restituirà .1 se N è NULL. La lista valori deve essere nella forma N1 <N2 <N3 per funzionare correttamente. Il codice seguente è un semplice esempio di come funziona la funzione 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)

INTERVALLO (N, N1, N2, N3, ..........)

La funzione INTERVALLO () confronta il valore di N con l'elenco di valori (N1, N2, N3 e così via). La funzione restituisce 0 se N <N1, 1 se N <N2, 2 se N <N3 e così via. Restituirà .1 se N è NULL. La lista valori deve essere nella forma N1 <N2 <N3 per funzionare correttamente. Il codice seguente è un semplice esempio di come funziona la funzione 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)

Ricorda che 6 è l'indice a base zero nella lista valori del primo valore che era maggiore di N. Nel nostro caso, 7 era il valore incriminato e si trova nel sesto slot dell'indice.

MINIMO (N1, N2, N3, N4, ......)

La funzione LEAST () è l'opposto della funzione GREATEST (). Il suo scopo è restituire l'elemento di minor valore dalla lista valori (N1, N2, N3 e così via). L'esempio seguente mostra l'utilizzo e l'output corretti per la funzione 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)

LOG (X)

LOG (B, X)

La versione a singolo argomento della funzione restituirà il logaritmo naturale di X. Se viene chiamata con due argomenti, restituisce il logaritmo di X per una base arbitraria B. Considera il seguente esempio:

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)

Questa funzione restituisce il logaritmo in base 10 di X.

SQL>SELECT LOG10(100);
+---------------------------------------------------------+
| LOG10(100)                                              |
+---------------------------------------------------------+
| 2.000000                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MOD (N, M)

Questa funzione restituisce il resto di N diviso per M. Considera il seguente esempio:

SQL>SELECT MOD(29,3);
+---------------------------------------------------------+
| MOD(29,3)                                               |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

OTTOBRE (N)

La funzione OCT () restituisce la rappresentazione di stringa del numero ottale N. Ciò equivale a utilizzare CONV (N, 10,8).

SQL>SELECT OCT(12);
+---------------------------------------------------------+
| OCT(12)                                                 |
+---------------------------------------------------------+
| 14                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

PI()

Questa funzione restituisce semplicemente il valore di pi greco. SQL memorizza internamente l'intero valore a doppia precisione di pi greco.

SQL>SELECT PI();
+---------------------------------------------------------+
| PI()                                                    |
+---------------------------------------------------------+
| 3.141593                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

POW (X, Y)

POTENZA (X, Y)

Queste due funzioni restituiscono il valore di X elevato alla potenza di Y.

SQL> SELECT POWER(3,3);
+---------------------------------------------------------+
| POWER(3,3)                                              |
+---------------------------------------------------------+
| 27                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

RADIANTI (X)

Questa funzione restituisce il valore di X, convertito da gradi a radianti.

SQL>SELECT RADIANS(90);
+---------------------------------------------------------+
| RADIANS(90)                                             |
+---------------------------------------------------------+
|1.570796                                                 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TONDO (X)

TONDO (X, D)

Questa funzione restituisce X arrotondato al numero intero più vicino. Se viene fornito un secondo argomento, D, la funzione restituisce X arrotondato a D cifre decimali. D deve essere positivo o tutte le cifre a destra del punto decimale verranno rimosse. Considera il seguente esempio:

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)

SEGNO (X)

Questa funzione restituisce il segno di X (negativo, zero o positivo) come -1, 0 o 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)

PECCATO (X)

Questa funzione restituisce il seno di X. Considera il seguente esempio:

SQL>SELECT SIN(90);
+---------------------------------------------------------+
| SIN(90)                                                 |
+---------------------------------------------------------+
| 0.893997                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SQRT (X)

Questa funzione restituisce la radice quadrata non negativa di X. Considera il seguente esempio:

SQL>SELECT SQRT(49);
+---------------------------------------------------------+
| SQRT(49)                                                |
+---------------------------------------------------------+
| 7                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

STD (espressione)

STDDEV (espressione)

La funzione STD () viene utilizzata per restituire la deviazione standard dell'espressione. Ciò equivale a prendere la radice quadrata della VARIANZA () dell'espressione. Il seguente esempio calcola la deviazione standard della colonna PRICE nella nostra tabella CARS -

SQL>SELECT STD(PRICE) STD_DEVIATION FROM CARS;
+---------------------------------------------------------+
| STD_DEVIATION                                           |
+---------------------------------------------------------+
| 7650.2146                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TAN (X)

Questa funzione restituisce la tangente dell'argomento X, che è espressa in radianti.

SQL>SELECT TAN(45);
+---------------------------------------------------------+
| TAN(45)                                                 |
+---------------------------------------------------------+
| 1.619775                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TRONCO (X, D)

Questa funzione viene utilizzata per restituire il valore di X troncato al numero D di cifre decimali. Se D è 0, il punto decimale viene rimosso. Se D è negativo, il numero di valori D nella parte intera del valore viene troncato. Considera il seguente esempio:

SQL>SELECT TRUNCATE(7.536432,2);
+---------------------------------------------------------+
| TRUNCATE(7.536432,2)                                    |
+---------------------------------------------------------+
| 7.53                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)
sql-funzioni-utili.htm