Capitolo 3
Funzioni sulle potenze, logaritmi e radici
Per gli esempi verrà usata la tabella NUMERI sottostante:
NUMERI |
|||
A ----------------------------- |
B ------------------------------------ |
||
3, | 1415 | 4 | |
-45 | ,707 | ||
5 | 9 | ||
-57 | ,667 | 42 | |
15 | 55 | ||
-7 | ,2 | 5 | ,3 |
Questa funzione permette di elevare e a un esponente (e è una costante matematica che viene utilizzata in varie formule). Vediamo un esempio:
SELECT A, EXP(A)
FROM NUMERI;
A ----------------------------- |
EXP(A) ------------------------------------ |
||
3, | 1415 | 23 | ,138549 |
-45 | 2 | ,863E-20 | |
5 | 148 | ,41316 | |
-57 | ,667 | 9 | ,027E-26 |
15 | 3269017 | ,4 | |
-7 | ,2 | ,00074659 |
Questa funzione calcola il logaritmo naturale. Questa funzione non è implementata da Access .
Vediamo un esempio in cui si vuole calcolare i logaritmi della colonna A della tabella NUMERI:
SELECT A, LN(A)
FROM NUMERI;
ERRORE:
ORA-01428: l'argomento '-45' è esterno all'intervallo
Il messaggio d’errore che viene visualizzato è dato dal fatto che non è possibile determinare un logaritmo di un valore negativo quando la base è positiva: non esiste nessun esponente che elevato ad e (valore positivo) ci da come risultato un valore negativo.
Il ‘problema’ può essere risolto inserendo all’interno della funzione LN la funzione ABS che ci restituisce i valori assoluti di quelli specificati:
SELECT A, LN(ABS(A))
FROM NUMERI;
A ----------------------------- |
LN(ABS(A)) ------------------ |
|
3, | 1415 | 1,1447004 |
-45 | 3,8066625 |
|
5 | 1,6094379 |
|
-57 | ,667 | 4,0546851 |
15 | 2,7080502 |
|
-7 | ,2 | 1,974081 |
Questa funzione richiede due argomenti e calcola il logaritmo del secondo avendo come base il primo. Vediamo un esempio in cui si calcolano i logaritmi del numero 2 aventi come base i valori della colonna B della tabella NUMERI:
SELECT B, LOG(B, 2)
FROM NUMERI;
B ------------------------------------ |
LOG(B,2) ----------------------------------------- |
||
4 | ,5 | ||
,707 | -1 | ,999129 | |
9 | ,31546488 | ||
42 | ,18544902 | ||
55 | ,17296969 | ||
5 | ,3 | ,41562892 |
Questa funzione non ci permette, però, di calcolare il logaritmo in cui la base è negativa, dunque il primo argomento che viene passato alla funzione dovrà essere sempre maggiore di zero.
Questa funzione non è implementata da Access. Questa funzione consente di elevare un numero alla potenza di un altro. Il primo argomento è elevato alla potenza del secondo. Vediamo un esempio:
SELECT A, B, POWER(A, B)
FROM NUMERI;
ERRORE:
ORA-01428: l'argomento '-45' è esterno all'intervallo
Sembrerebbe che non sia possibile (matematicamente) elevare un valore negativo ad un indice frazionario, ma non è così, il problema dunque sussiste forse solamente per SQL implementato da Oracle. Il problema può essere risolto usando opportune funzioni viste in precedenza o evitando di far calcolare la potenza di un numero negativo usando un indice frazionario. Facciamo un’altra prova:
SELECT A, B, POWER(B, A)
FROM NUMERI;
A ------------------------- |
B ------------------- |
POWER(B,A) ----------------- |
||
3, | 1415 | 4 | 77,870231 |
|
-45 | ,707 | 5972090,5 |
||
5 | 9 | 59049 |
||
-57 | ,667 | 42 | 2,467E-94 |
|
15 | 55 | 1,275E+26 |
||
-7 | ,2 | 5 | ,3 | 6,098E-06 |
Questa funzione è implementata da Access con la sintassi ‘SQR(nome_campo)’. La funzione SQRT restituisce la radice quadrata di un argomento. Poiché la radice quadrata di un numero negativo non esiste, non è possibile utilizzare questa funzione con i numeri negativi.
Vediamo una esempio:
SELECT B, SQRT(B)
FROM NUMERI;
B |
SQRT(B) |
4 |
2 |
,707 |
,84083292 |
9 |
3 |
42 |
6,4807407 |
55 |
7,4161985 |
5,3 |
2,3021729 |
Queste funzioni ci permettono di manipolare i dati da visualizzare in tutti i modi e formati desiderati. Sono particolarmente utili quando abbiamo la necessità di rendere i dati più leggibili o quando vogliamo estrapolare delle informazioni sulle stringhe e i caratteri rappresentanti le informazioni.
Gli esempi presentati si basano sulla tabella CARATTERI sottostante:
CARATTERI |
|||
COGNOME |
NOME |
S |
CODICE |
ROSSI | GIGI | A |
32 |
BIANCHI | MARIO | J |
67 |
NERI | MARIA | C |
65 |
BRUNI | ANGELO | M |
87 |
SCURI | ANNA | A |
77 |
VERDI | ANTONIO | G |
52 |
Questa funzione fornisce il carattere corrispondente al codice ASCII passatogli. Vediamo un esempio:
SELECT CODICE, CHR(CODICE)
FROM CARATTERI;
CODICE ------------------------- |
CH ----------- |
32 | |
67 | C |
65 | A |
87 | W |
77 | M |
52 | 4 |
Questa sintassi non è accettata da Access. L’equivalente di questa funzione è stato utilizzato nel Capitolo 2, quando si è parlato di operatori. Il simbolo usato nel capitolo 2 è il seguente: || che unisce insieme due stringhe di caratteri, come la funzione CONCAT. Ecco un esempio:
SELECT CONCAT(NOME, COGNOME) "NOME E COGNOME"
FROM CARATTERI;
NOME E COGNOME ----------------------------------- |
GIGIROSSI |
MARIOBIANCHI |
MARIANERI |
ANGELOBRUNI |
ANNASCURI |
ANTONIOVERDI |
La funzione INITCAP trasforma in maiuscolo o lascia in maiuscolo il primo carattere di una parola e trasforma in minuscolo o lascia in minuscolo tutti gli altri caratteri. Questa funzione non è implementata da Access.
Vediamo un esempio:
SELECT NOME PRIMA, INITCAP(NOME) DOPO
FROM CARATTERI;
PRIMA ----------------- |
DOPO -------------- |
GIGI |
Gigi |
MARIO | Mario |
MARIA | Maria |
ANGELO | Angelo |
ANNA | Anna |
ANTONIO | Antonio |
La funzione LOWER trasforma tutti i caratteri di una parola in maiuscolo; UPPER esegue l’operatore inversa. Questa funzione non è implementata da Access. Vediamo degli esempi:
UPDATE CARATTERI
SET NOME = 'Mario'
WHERE NOME = 'MARIO';
Aggiornata 1 riga.
Con questa espressione abbiamo modificato il formato con cui viene rappresentato uno dei nomi della tabella CARATTERI , al fine di accertarci che la funzione esegua il suo compito correttamente.
SELECT NOME, UPPER(NOME), LOWER(NOME)
FROM CARATTERI;
NOME ------------------- |
UPPER(NOME) ----------------------------- |
LOWER(NOME) ----------------------------- |
GIGI |
GIGI | gigi |
Mario | MARIO | mario |
MARIA | MARIA | maria |
ANGELO | ANGELO | angelo |
ANNA | ANNA | anna |
ANTONIO | ANTONIO | antonio |
La ‘L’ e la ‘R’ stanno per left e right mentre ‘PAD’ significa in inglese cuscinetto.
Queste due funzioni richiedono da due a tre argomenti. Il primo argomento rappresenta le stringhe sulle quali operare. Il secondo argomento è il numero di caratteri da aggiungere alla stringa. Il terzo argomento (facoltativo) è il carattere da aggiungere, che può essere un singolo carattere o una stringa di caratteri; se non viene specificato, sarà automaticamente aggiunto uno spazio. Questa funzione non è implementata da Access. Vediamo alcuni esempi:
SELECT COGNOME, LPAD(COGNOME,20,'*')
FROM CARATTERI;
COGNOME ------------------ |
LPAD(COGNOME,20,'*') ------------------------------------- |
ROSSI |
***************ROSSI |
BIANCHI | *************BIANCHI |
NERI | ****************NERI |
BRUNI | ***************BRUNI |
SCURI | ***************SCURI |
VERDI | ***************VERDI |
SELECT COGNOME, LPAD(COGNOME,20,'tra')
FROM CARATTERI;
COGNOME ------------------ |
LPAD(COGNOME,20,'TRA') -------------------------------------- |
ROSSI |
tratratratratraROSSI |
BIANCHI | tratratratratBIANCHI |
NERI | tratratratratratNERI |
BRUNI | tratratratratraBRUNI |
SCURI | tratratratratraSCURI |
VERDI | tratratratratraVERDI |
SELECT COGNOME, RPAD(COGNOME,20,'/')
FROM CARATTERI;
COGNOME -------------------- |
RPAD(COGNOME,20,'/') --------------------------------- |
ROSSI |
ROSSI/////////////// |
BIANCHI | BIANCHI///////////// |
NERI | NERI//////////////// |
BRUNI | BRUNI/////////////// |
SCURI | SCURI/////////////// |
VERDI | VERDI/////////////// |
La ‘L’ e la ‘R’ stanno per left e right mentre To trim in inglese significa anche tagliare.
Il primo argomento, come per le funzioni RPAD e LPAD, rappresenta le stringhe sulle quali operare. Il secondo argomento può essere un carattere o una stringa di caratteri. Queste due funzioni non sono implementate da Access.
Vediamo alcuni esempi:
SELECT NOME, RTRIM(NOME, 'O')
FROM CARATTERI;
NOME ---------------- |
RTRIM(NOME, ‘O’) ------------------------------- |
GIGI |
GIGI |
MARIO | MARI |
MARIA | MARIA |
ANGELO | ANGEL |
ANNA | ANNA |
ANTONIO | ANTONI |
SELECT NOME, RTRIM(NOME, 'N')
FROM CARATTERI;
NOME ---------- |
RTRIM(NOME, ‘N’) ------------------------------- |
GIGI | GIGI |
MARIO | MARIO |
MARIA | MARIA |
ANGELO | ANGELO |
ANNA | ANNA |
ANTONIO | ANTONIO |
SELECT NOME, LTRIM(NOME, 'A')
FROM CARATTERI;
NOME ---------- |
LTRIM(NOME, ‘A’) ------------------------------ |
GIGI | GIGI |
MARIO | MARIO |
MARIA | MARIA |
ANGELO | NGELO |
ANNA | NNA |
ANTONIO | NTONIO |
REPACE permette di sostituire una stringa di caratteri con quella specifica. Richiede tre argomenti: il primo rappresenta le stringhe sulle quali effettuate le ricerche ; il secondo è la stringa da ricercare e sostituire; il terzo è facoltativo e specifica la stringa di sostituzione.
Se l’ultimo argomento non viene indicato, ogni ricorrenza della chiave di ricerca (stringa trovata) viene eliminata, senza essere sostituita da un’altra stringa. Questa funzione non è implementata da Access. Vediamo alcuni esempi:
SELECT NOME, REPLACE(NOME, 'R', '**')
FROM CARATTERI;
NOME |
REPLACE(NOME,'R','**) ------------------------------------ |
GIGI |
GIGI |
MARIO | MA**IO |
MARIA | MA**IA |
ANGELO | ANGELO |
ANNA | ANNA |
ANTONIO | ANTONIO |
SELECT NOME, REPLACE(NOME, 'A')
FROM CARATTERI;
NOME --------------- |
REPLACE(NOME, ‘A’) ---------------------------------- |
GIGI |
GIGI |
MARIO | MRIO |
MARIA | MRI |
ANGELO | NGELO |
ANNA | NN |
ANTONIO | NTONIO |
Questa funzione consente si estrarre una serie di caratteri (sottostringa) da una stringa specificata. SUBSTR richiede tre argomenti: il primo è la stringa specificata da esaminare; il secondo è la posizione del primo carattere da estrarre; il terzo è il numero di caratteri da estrarre. Se il terzo parametro viene omesso la query visualizza tutti i caratteri rimanenti dopo la posizione specificata. Questa funzione non è implementata da Access. Vediamo alcuni esempi:
SELECT COGNOME, SUBSTR(COGNOME, 2, 3)
FROM CARATTERI;
COGNOME ----------------- |
SUBSTR(COGNOME, 2, 3) -------------------------------------- |
ROSSI |
OSS |
BIANCHI | IAN |
NERI | ERI |
BRUNI | RUN |
SCURI | CUR |
VERDI | ERD |
SELECT COGNOME, SUBSTR(COGNOME,2)
FROM CARATTERI;
COGNOME ----------------- |
SUBSTR(COCOGNOME, 2) --------------------------------------- |
ROSSI |
OSSI |
BIANCHI | IANCHI |
NERI | ERI |
BRUNI | RUNI |
SCURI | CURI |
VERDI | ERDI |
Se viene utilizzato un numero negativo come secondo argomento, la posizione iniziale viene determinata contando la stringa da destra verso sinistra iniziando dal suo ultimo carattere. Vediamo alcuni esempi:
SELECT COGNOME, SUBSTR(COGNOME,-4, 2)
FROM CARATTERI;
COGNOME ------------------ |
SUBSTR(COGNOME, -4, 2) ---------------------------------------- |
ROSSI |
OS |
BIANCHI | NC |
NERI | NE |
BRUNI | RU |
SCURI | CU |
VERDI | ER |
SELECT COGNOME, SUBSTR(COGNOME,-5, 2)
FROM CARATTERI;
COGNOME ---------------------- |
SUBSTR(COGNOME,-5, 2) ------------------------------------- |
ROSSI |
RO |
BIANCHI | AN |
NERI | |
BRUNI | BR |
SCURI | SC |
VERDI | VE |
Vediamo un esempio in cui vogliamo visualizzare solo le iniziali dei nominativi presenti in CARATTERI:
SELECT SUBSTR(NOME, 1, 1) ||' - '|| SUBSTR(COGNOME, 1, 1)
FROM CARATTERI;
SUBST --------- |
G - R |
M - B |
M - N |
A - B |
A - S |
A - V |
La funzione INSTR permette di sapere in quale punto di una stringa si trova un particolare schema di caratteri. Il primo argomento della funzione è la stringa da esaminare. Il secondo argomento è lo schema da ricercare. Il terzo e il quarto argomento sono numeri che indicano dove iniziare le ricerche e quale tipo di corrispondenza fornire. Vediamo alcuni esempi:
SELECT COGNOME, INSTR(COGNOME, 'I', 2, 1)
FROM CARATTERI;
COGNOME ----------------- |
INSTR(COGNOME, 'I', 2, 1) -------------------------------------- |
ROSSI |
5 |
BIANCHI | 2 |
NERI | 4 |
BRUNI | 5 |
SCURI | 5 |
VERDI | 5 |
SELECT COGNOME, INSTR(COGNOME, 'I', 2, 2)
FROM CARATTERI;
COGNOME ----------------- |
INSTR(COGNOME,'I',2,2) -------------------------------------- |
ROSSI |
0 |
BIANCHI | 7 |
NERI | 0 |
BRUNI | 0 |
SCURI | 0 |
VERDI | 0 |
SELECT COGNOME, INSTR(COGNOME, 'R', 2, 2)
FROM CARATTERI;
COGNOME ----------------- |
INSTR(COGNOME, 'R', 2, 2) -------------------------------------- |
ROSSI |
0 |
BIANCHI | 0 |
NERI | 0 |
BRUNI | 0 |
SCURI | 0 |
VERDI | 0 |
SELECT COGNOME, INSTR(COGNOME, 'N', 2, 1)
FROM CARATTERI;
COGNOME ----------------- |
INSTR(COGNOME, 'N', 2, 1) -------------------------------------- |
ROSSI |
0 |
BIANCHI | 4 |
NERI | 0 |
BRUNI | 4 |
SCURI | 0 |
VERDI | 0 |
SELECT NOME, INSTR(NOME, 'N', 2, 2)
FROM CARATTERI;
COGNOME ----------------- |
INSTR(NOME, 'N', 2, 2) -------------------------------------- |
ROSSI |
0 |
BIANCHI | 0 |
NERI | 0 |
BRUNI | 0 |
SCURI | 3 |
VERDI | 5 |
Il valore di default per il terzo e il quarto argomento è 1.
Access implementa questa funzione usando un’altra sintassi, vediamo come:
InStr([inizio, ]stringa1, stringa2[, confronto])
La sintassi della funzione InStr è composta dai seguent argomenti:
La sintassi accettata da Access per tale funzione è: Len(nome_campo)
La funzione LENGTH restituisce la lunghezza del suo argomento, come in questo esempio:
SELECT NOME, LENGTH(NOME)
FROM CARATTERI;
NOME ---------------- |
LENGTH(NOME) --------------------------- |
GIGI | 4 |
MARIO | 5 |
MARIA | 5 |
ANGELO | 6 |
ANNA | 4 |
ANTONIO | 7 |
Questa funzione restituisce il nome dell’utente corrente alla tabella specificata. Questa funzione non è implementata da Access. Vediamo un esempio:
SELECT USER
FROM CARATTERI;
USER ------------------------------ |
DEMO |
DEMO |
DEMO |
DEMO |
DEMO |
DEMO |
pag. 6 di 20 |