Sei sulla pagina 1di 40

Installazione di MySQL su Linux

MySQL è distribuito gratuitamente per Linux sul sito http://www.mysql.com. Di solito l'ultima versione stabile viene identificata come "recommended". Vedremo come installare MySQL partendo dai file mysql-xxx.tar.gz (dove xxx sta per il numero della versione), sappiate comunque che esistono anche versioni in RPM o DEB.

Accertatevi di essere entrati nel sistema come root, altrimenti usate il comando su root. Per cominciare scompattate il file e spostatevi nella directory appena creata.

tar xzf mysql-xxx.tar.gz cd mysql-xxx

Adesso è il momento di configurare il programma che curerà l'installazione di MySQL nel sistema. Se non conoscete bene le opzioni il consiglio è quello di limitarsi a specificare il percorso di installazione: le altre impostazioni di default vanno bene nella maggioranza dei casi. Solitamente il percorso consigliato è /usr/local/mysql, ma naturalmente potete scegliere il percorso che vi sembra più comodo.

./configure --prefix=/usr/local/mysql

Adesso vedrete molte schermate di configurazione, teneto sott'occhio il README e fate attenzione alle opzioni proposte. Finita questa parte siete pronti per lanciare la compilazione vera e propria:

make

Il programma adesso è installato, ma è necessario compiere ancora qualche operazione prima di

essere operativi. La prima è quella di installare i file che permetteranno a MySQL di funzionare.

Rimanete nella stessa directory dalla quale avete lanciato gli altri comandi e digitate:

scripts/mysql_install_db

A questo punto potete tranquillamente cancellare la directory nella quale vi trovate. Essa infatti

contiene solamente file di installazione e temporanei; nel caso dobbiate reinstallare il programma

dovrete solamente scompattare nuovamente mysql-xxx.tar.gz.

Avviamo il server:

mysqld

Per controllare che tutto funzioni correttamente digitate

mysqladmin -u root status

Adesso potete vedere il paragrafo sulla configurazione di MySQL per iniziare a lavorare con il database.

Configurazione di MySQL su Windows e Linux

Adesso che il server MySQL è installato e attivo, la prima cosa da fare è quella di impostare una password per l'utente root, ovvero l'utente che è in grado di compiere tutte le operazioni su MySQL, compresa quella di fermare il server. MySQL permette l'accesso ai dati contenuti nei database esclusivamente agl utenti autorizzati, per questo è importante creare da subito degli utenti che abbiano delle possibilità di azione limitate per evitare seri problemi di sicurezza. Appena installato, MySQL ha un utente "root" che può accedere senza inserire alcuna password, in grado di compiere qualsiasi azione sul server. Quindi la prima cosa da fare adesso è quella di assegnare una password a "root" in modo da evitare che chiunque possa entrare e fare danni senza incontrare alcun blocco. Attenzione perché quello che stiamo per fare è estremamente importante: MySQL è un server e in quanto tale esso permette l'accesso a chiunque si trovi nella stessa rete. Questo significa che se il server è collegato a Internet, CHIUNQUE potrà accedere al server! Naturalmente la possibilità di

effettuare delle operazioni su di esso sarà vincolata al fatto di avere un nome utente e una password

di accesso.

Iniziamo assegnando una password all'utente "root". La password va inserita tra virgolette, come nell'esempio.

mysqladmin -u root password "mia_password"

Per assicurarci che MySQL abbia registrato il cambiamento, ricarichiamo le tabelle di accesso:

mysqladmin -u root reload

Se appare un messaggio d'errore, va tutto bene :)) Questo infatti significa che d'ora in poi dovrete inserire la password per operare sul server.

Proviamo ora a vedere se la password viene riconosciuta, ad esempio esaminando i parametri di lavoro del server:

mysqladmin -u root -p status

Appena premuto invio vi verrà richiesta la password. Mentre la scriverete non apparirà nulla; non preoccupatevi, è una misura di sicurezza per evitare che qualche curioso, sbirciando, riesca a vedere quanto è lunga la password. -u root indica a MySQL che volete accedere con il nome utente "root"; -p indica che vi dovrà essere richiesta la password per eseguire l'operazione. Come abbiamo visto omettendo -p il server

si rifiuta di compiere l'operazione.

Adesso dovrete inserire la password anche per fermare il server:

mysqladmin -u root -p shutdown

I tipi di campi in MySQL

I tipi di campi numerici in MySQL

Quando si va ad assegnare un campo di tipo numerico, è importante sapere quale scegliere, così da non trovarsi con una tabella che va sistemata o ritoccata per contenere i dati.

Ci sono casi in cui, quando si è certi che il database dovrà contenere una piccola quantità di dati, si va erroneamente a identificare comunque un campo di tipo INT, quando magari un TINYINT farebbe comunque lo stesso lavoro in maniera egregia.

Ma perché scervellarsi per trovare il tipo di dato numerico adatto? Per risparmiare spazio e migliorare le prestazioni del database. Se avessimo una tabella di nome "admin" con username e password dell'amministratore unico del sito, è bene evitare di scegliere un campo eccessivamente grande (come può essere BIGINT) perché occuperemo spazio inutile e peggioreremo le prestazioni di MySQL.

Nome del

Memoria

tipo

occupata

TINYINT

1 byte

SMALLINT

2 byte

MEDIUMINT

3 byte

INT

4 byte

BIGINT

8 byte

FLOAT(I,D)

4 byte

DOUBLE(I,D)

8 byte

Intervallo di valori consentito

Se solo positivi (UNSIGNED)

da -128 a +127

da 0 a +255

da -32768 a +32767

da 0 a +65535

da -8388608 a +8388607

da 0 a +16777215

da -2147483648 a +2147483647

da 0 a +4294967295

da -9223372036854775808 a

da 0 a

+9223372036854775807

+18446744073709550615

A seconda dei valori

A seconda dei valori

DECIMAL(I,D) Il peso di I + A seconda dei valori

2 Byte

I e D rappresentano i numeri Interi e Decimali ammessi.

Un approfondimento lo meritano i tipo FLOAT, DOUBLE e DECIMAL. Ad esempio FLOAT(2,3) indica a MySQL di salvare fino a due cifre per la parte intera di un numero e 3 per quella decimale. I numeri quindi saranno salvati fino a 99.999. Numeri con valori diversi, verranno arrotondati. Un numero come 45,7869 diventerà 45,787. DOUBLE e DECIMAL funzionano nella stessa maniera ma possono contenere valori maggiori (e quindi occupano più spazio).

Eccezioni dei valori nei dati di tipo numerico

Se all'interno di un campo di tipo numerico si specifica un valore maggiore di quanto ammesso, MySQL salverà nel database il massimo numero ammesso per quel campo. Per spiegare meglio il concetto, ammettiamo di avere un campo TINYINT (UNSIGNED ovvero privo di segno, quindi positivo: da 0 a 255): se provassimo ad inserire un valore pari a 4587, MySQL salverà 255 come valore. E' importante quindi porre molta attenzione nella scelta dei campi di tipo numerico. Anche perché sono i dati a cui MySQL accede più rapidamente.

I modificatori dei tipi numerici: AUTO_INCREMENT, UNIQUE e ZEROFILL

Il primo modificatore, AUTO_INCREMENT, permette di creare un campo numerico che aumenta ogni nuova riga. Quindi, aggiungendo un record a uno già presente, il valore del campo auto incrementale sarà 2. Se si cancellasse questo ultimo record e se ne aggiungesse un altro, il valore del nuovo campo AUTO_INCREMENT sarà 3. Questo perché, anche se una riga è stata cancellata, MySQL si ricorda il valore massimo e a questo aggiunge ogni volta una unità. Non è possibile modificare il valore che viene sommato alla nuova riga (è e resta +1). E' consigliabile utilizzare sempre un campo auto incrementale a cui fare riferimento per selezionare, modificare o cancellare i record. Tenetevi quindi sempre da parte un campo (magari di nome "id") di tipo auto incrementale. Sarà comodissimo in molti casi.

Il secondo modificatore per i dati numerici, UNIQUE, identifica un campo i cui valori sono uno diverso dall'altro. Se si tenta di aggiungere un record con lo stesso valore, MySQL genera un errore tipo:

1062 - Duplicate entry 'N ' for key N

L'ultimo modificatore ammesso da MySQL per i campi numerici è ZEROFILL, che consente di inserire tanti 0 quanti sono ammessi dal tipo di campo, prima della cifra che realmente viene salvata. Ad esempio, con un campo di tipo INT(5) e ZEROFILL, per salvare un numero come 78, questo verrà immagazzinato nella forma 00078. Può essere utile per salvare dati bancari che prevedono una lunghezza fissa, come ABI, CAB o numero di conto corrente.

I tipi di campi stringhe in MySQL

Un tipo di dato stringa è un campo che può contenere qualunque tipo di carattere: numerico, alfanumerico, simboli ecc. Come per i campi numerici ce ne sono di vari tipi, a seconda della quantità di dati che si vuole salvare.

Nella tabella seguente, maggiori informazioni:

Nome del tipo

Dimensioni massime Memoria occupata

CHAR

255 byte

X byte ( * )

VARCHAR

255 byte

X+1 byte ( * )

TINYTEXT

255 byte

X+1 byte ( * )

TINYBLOB

255 byte

X+2 byte ( * )

TEXT

65535 byte

X+2 byte ( * )

BLOB

65535 byte

X+2 byte ( * )

MEDIUMTEXT 1,6 MB MEDIUMBLOB 1,6 MB

X+3 byte ( * ) X+3 byte ( * )

LONTEXT

4,2 GB

X+4 byte ( * )

LONGBLOB

4,2 GB

X+4 byte ( * )

(*) X è lo spazio occupato dal testo all'interno del campo

CHAR e VARCHAR

Questi due tipi di campi, nonostante la somiglianza nel nome, si comportano in maniera molto diversa. Il primo ha una lunghezza fissa, mentre il secondo è variabile. Ciò significa che se creassimo un campo CHAR(9) e al suo interno specificassimo "ciao", questo campo occuperebbe comunque 9 byte invece di 4. Con VARCHAR(9) invece, scrivendo al suo interno "ciao" il campo occuperebbe 5 byte (guardare la tabella superiore X+1 dove in questo caso è X=4, quindi 4+1=5).

All'interno di una tabella, non è possibile utilizzarli entrambi. Creando ad esempio due campi nella stessa tabella, uno CHAR e l'altro VARCHAR, MySQL renderà entrambi VARCHAR, come è possibile vedere dall'immagine seguente, realizzata con PhpMyAdmin.

dall'immagine seguente, realizzata con PhpMyAdmin . TEXT e BLOB TEXT e BLOB sono i campi di

TEXT e BLOB

TEXT e BLOB sono i campi di MySQL dedicati a contenere grandi quantità di dati. Fino a 4,2 GB con i LONGTEXT e LONGBLOB. Il secondo in particolare, il campo di tipo BLOB sta per Bynary Large Object e consente il salvataggio di interi file nel formato binario. Utile per nascondere file dietro username e password, senza così riuscire a rintracciare il percorso fisico del file (che infatti non esiste, essendo incluso direttamente nel database).

I modificatori

I modificatori previsti da questi tipi di campi sono:

BINARY:

ammesso dai campi CHAR e VARCHAR: i dati salvati saranno trattati come stringhe binarie.

DEFAULT:

ammesso da tutti i tipi di campi: imposta un valore predefinito nel caso il campo fosse lasciato vuoto.

NOT NULL:

ammesso da tutti i tipi di campi: impone che il campo non sia lasciato vuoto.

NULL:

ammesso da tutti i tipi di campi: se il campo non contiene un valore, sarà vuoto.

PRIMARY KEY:

ammesso da tutti i campi, ma è consigliabile impostarlo su dati di tipo numerico. Serve a impostare un indice i quali dati non devono essere vuoti.

Gli altri modificatori: UNIQUE, UNSIGNED e ZEROFILL sono stati trattati nella puntata dedicata

ai tipi di dati numerici.

I tipi di campi data in MySQL

I tipi di campi data sono tutti quei campi che contengono come valore la data e/o l'ora. Nella tabella che segue, li mostriamo uno ad uno:

Nome del tipo

Formato

Se vuoto (zero)

DATETIME

AAAA-MM-GG hh:mm:ss 0000-00-00 00:00:00

DATE

AAAA-MM-GG

0000-00-00

TIME

hh:mm:ss

00:00:00

YEAR

AAAA

0000

TIMESTAMP(2)

AA

00

TIMESTAMP(4)

AAMM

0000

TIMESTAMP(6)

AAMMGG

000000

TIMESTAMP(8)

AAAAMMGG

00000000

TIMESTAMP(10) AAMMGGhhmm

0000000000

TIMESTAMP(12) AAMMGGhhmmss

000000000000

TIMESTAMP(14) AAAAMMGGhhmmss

00000000000000

A=anno, M=mese, G=giorno, h=ora, m=minuti, s=secondi

DATETIME

E' il formato più completo e preciso a nostra disposizione. Varia da 1000-01-01 00:00:00 a 9999- 12-31 23:59:59

DATE

Uguale al precedente, ma senza l'ora. Ammette infatti dati a partire da 1000-01-01 al 9999-12-31.

TIME

Salva l'ora. I valori vanno da 00:00:00 a 23:59:59. E' possibile però salvare intervalli di valore tra un evento e un altro e qundi, ammettere ore differenti. In questo caso, i dati vanno da -838:59:59 a

838:59:59.

MySQL legge i valori partendo da destra, quindi, salvando un campo con il contenuto 8:32, nel database verrà interpretato come 00:08:32. Oltre ai due punti ( : ) MySQL ammette altri segni di interpunzione senza particolari difficoltà. L'immissione di un valore sbagliato sarà salvato come mezzanotte in punto (00:00:00).

YEAR

Salva l'anno ed è il campo più leggero: 1 solo byte. Ammette valori dal 1901 al 2155. Gli anni possono essere salvati a due o a quattro cifre. MySQL, in caso di anni a due cifre, interpreterà i valori da 70 a 99 come dal 1970 al 1999. Quelli dall'1 al 69, come dal 2001 al 2069. Per evitare fraintendimenti quindi, è consigliabile impostare l'anno a quattro cifre.

TIMESTAMP

Questo campo salva (nel formato scelto dal numero tra le parentesi, si veda la tabella superiore) il momento esatto in cui la tabella viene modificata. Quindi può essere utile per visualizzare (senza doverlo calcolare ogni volta) il momento dell'ultima modifica del record in cui il campo TIMESTAMP appartiene. Ammette anni compresi tra il 1970 e il 2037. Tutti i tipi di TIMESTAMP occupano lo stesso spazio: 4 byte. Perché questo? Nonostante i vari formati? Perché MySQL salva comunque tutti i dati e poi ne visualizza solo quelli richiesti. Ad esempio, con TIMESTAMP(2) il database visualizza solo due cifre dell'anno, ma in memoria ha tutti gli altri dati (anno a 4 cifre, mese, giorno, ora, minuti e secondi). Quando infatti modifichiamo il tipo di TIMESTAMP, ad esempio con TIMESTAMP(8) lui ha tutti i dati in memoria. La stessa cosa avviene quando abbassiamo il valore di TIMESTAMP, visualizzando quindi meno dati. MySQL non cancellerà i vari valori, semplicemente li nasconderà

Altri tipi di campi in MySQL

I tipi di campi che ancora non abbiamo trattato sono i campi a scelta. Quando l'utente dovrà selezionare per forza una delle voci previste (ad esempio da un menù a tendina: <select>) è bene porre la propria attenzione su questi campi, perché MySQL ci accede più rapidamente di quelli testuali.

ENUM

Indica a MySQL le varie possibilità previste. Ad esempio, con:

ENUM('mare','montagna','lago')

Si impone l'utente la scelta di uno di queste tre possibilità. Altri valori, saranno trattati come valori vuoti (NULL), a meno che non sia definito un valore di default. Si possono inserire fino a 65.535 voci.

Tornando all'esempio precedente: ENUM('mare','montagna','lago') a questo tipo di campo (che chiameremo "scelta_vacanze") è possibile selezionare una voce come se ci si trovasse di fronte a un array (che parte da 1 come in VB e derivati - tipo VBScript). Ad esempio, con:

Avremo come risultato il valore "montagna".

SET

Questo tipo di dato è uguale a ENUM, con la differenza di poter effettuare una scelta multipla. Il campo ENUM infatti, consente di scegliere un solo valore alla volta.

Introduzione a PhpMyAdmin

PhpMyAdmin è un'interfaccia grafica sviluppata in Php in grado di interagire con database MySQL senza la necessità di scrivere alcuna riga di codice SQL. Tutti gli RDBMS infatti sono interrogabili grazie a tools di amministrazione (come ad esempio "SQL Server Enterprise Manager" per Microsoft SQL Server, "Toad" per Oracle e "pgAdmin3" per PostgreSQL) oppure da complesse linee di codice SQL (Structured Query Language).

Il progetto PhpMyAdmin è raggiungibile all'indirizzo http://www.phpmyadmin.net e rilasciato sotto licenza GNU, ovvero distribuibile gratuitamente con i relativi codici sorgenti. Disponibile in oltre 40 lingue differenti, compreso l'italiano, offre tutto ciò che un ottimo SQL developer avrebbe bisogno:

a)

creare o cancellare database

b)

creare, copiare, cancellare, rinominare e modificare tabelle

c)

occuparsi della manutenzione delle tabelle

d)

rimuovere, modificare ed aggiungere campi

e)

eseguire qualsiasi istruzione SQL, anche queries in modalità batch

f)

gestire le chiavi (key) nei campi

g)

caricare file di testo all'interno delle tabelle

h)

creare e leggere dump (backup su file) di tabelle

i)

esportare dati in formato CSV, XML e Latex

l)

amministrare server multipli

m) gestire utenti e privilegi MySQL

n)verificare l'integrità referenziale delle tabelle in MyISAM

o) usare la modalità Query-by-example (QBE), per la creazione automatica di complesse queries

collegando le tabelle richieste

p) creare PDF grafici del layout del Database

q) eseguire ricerche globali all'interno del database o in un sottoinsieme di quest'ultimo

r) trasformare i dati salvati in qualsiasi formato utilizzando un set di funzioni predefinite, ad

esempio la visualizzazione di dati BLOB come immagini o link per il download

s) supportare le tabelle e le chiavi esterne (straniere) InnoDB

t) offrire un'interfaccia grafica in una delle supportate

Installazione e configurazione

Per prima cosa occorre scaricare l'ultima versione stabile del programma all'indirizzo

www.phpmyadmin.net/home_page/downloads.php

A) Decomprimere (untar o unzip) la distribuzione nella directory root del server Web (o del

localhost). Se non si avesse l'accesso diretto alla cartella root, è consigliabile inserire i file in una directory sulla macchina locale, e, una volta configurato il tutto, trasferire la cartella sul server Web

utilizzando, ad esempio, il protocollo FTP. Con sistemi Windows e Mac il pacchetto si estrarrà avvalendosi di programmi tipo WinZip e ZipIt, con Linux digitando le seguenti stringhe:

$ cd /usr/local/apache/htdocs/

$ tar -xzvf /tmp/phpMyAdmin-2.5.3.tar.gz

La decompressione creerà una cartella denominata PhpMyAdmin

B) Aprire il file config.inc.php con l'editor preferito e cambiare i valori relativi all'host, all'utente,

alla password ed alla modalità di autenticazione a seconda del proprio ambiente di lavoro. Ad esempio, "host" identifica il server dove si trova MySQL. Inserire inoltre il valore corretto per l'$cfg['PmaAbsoluteUri']. Ad esempio:

$cfg['PmaAbsoluteUri'] = 'http://localhost/phpMyAdmin/';

C) Si raccomanda di proteggere la directory in cui è installato phpMyAdmin (a meno che non si

tratti di una intranet o che si preferisca un metodo di autenticazione basato su HTTP o cookie) ad

esempio con HTTP-AUTH (all'interno del file .htaccess)

D) Maggiori informazioni e dettagli tecnici nella

www.phpmyadmin.net/pma_localized_docs/Documentation-it.html#config

Amministrare MySQL con PhpMyAdmin

Creazione e cancellazione database MySQL

Se godiamo di diritti particolari sul server (oppure lavoriamo su un db locale) PhpMyAdmin ha funzioni avanzate di creazione e cancellazione di database MySQL. L'operazione risulta elementare e di immediata esecuzione, infatti come possiamo notare dalla pagina principale, la prima voce nel frame a destra ed esattamente nella sezione dedicata a MySQl c'è "Crea un nuovo database".

Stesso discorso vale per la cancellazione, ne lla pagina "SQL", vi dovrebbe essere un link

Stesso discorso vale per la cancellazione, nella pagina "SQL", vi dovrebbe essere un link denominato "Elimina database".

Creazione e cancellazione di una tabella

Per creare una nuova tabella è necessario posizionarsi sul database, che nel nostro esempio si chiama "odns":

database, che nel nostro esempio si chiama "odns": In fondo alla pagina apparirà il form per

In fondo alla pagina apparirà il form per scegliere il nome della nuova tabella e il numero di campi da inserire:

nome della nuova tabella e il numero di campi da inserire: Scelto il nome ed il

Scelto il nome ed il numero di campi, apparirà una pagina dove scegliere il nome dei campi. Tralasciando gli aspetti tecnici legati al tipo di campo (argomento trattato nelle puntate precedenti su MySQL) , per questa recensione è sufficiente nominare i campi ad esempio: pippo1, pippo2, pippo3 ed impostare la dimensione del campo (ad esempio 10).

Premuto il bottone Salva, PhpMyAdmin visualizzerà la query SQL ed offrirà all'amministratore la possibilità di

Premuto il bottone Salva, PhpMyAdmin visualizzerà la query SQL ed offrirà all'amministratore la possibilità di studiare il codice Php generato. Ora nel database "Odns" vi è una nuova tabella denominata "prova".

Modifica e cancellazione di tabelle in MySQL

Posizionandoci sulla tabella, PhpMyAdmin mostra le caratteristiche principali della tabella stessa (dimensioni, data di creazione e ultima modifica). Inoltre un Menu per effettuare tutte le operazioni necessarie alla gestione della tabella. Vediamo nel nostro esempio con la tabella "prova" cosa ci permette di fare PhpMyAdmin:

"prova" cosa ci permette di fare PhpMyAdmin: La prima pagina, appena scelta la tabella, è deno

La prima pagina, appena scelta la tabella, è denominata "Struttura", dove abbiamo appena descritto l'utilità: visualizza i campi e ne descrive le peculiarità.

Con la voce "Mostra" si ha la possibilità di visualizzare il contenuto dei campi, di default impostato a 30 record per pagina.

Con la voce "SQL" l'utente ha la facoltà di eseguire operazione direttamente con sintassi SQL.

Con la voce "Cerca" si possono trovare i dati nei record tramite un potente strumento di ricerca avanzata.

Con la voce "Inserisci" si potrà inserire una nuova riga nella tabella.

Tramite la voce "Esporta" tutti i campi o a seconda della volontà dell'utente, parzialmente, potranno essere esportati in diversi formati: SQL, LaTex, CSV per Excel, CSV, Xml.

Con la voce "Operazioni", tutte le proprietà della tabella saranno modificabili, dal nome alla sua ottimizzazione e/o copiatura.

Grazie al campo "Svuota" tutti i dati presenti nella tabella verrano eliminati, mantenendo però la struttura della tabella e soprattutto se si avessero dati autocrementali il primo record ripartirebbe da

Con la voce "Elimina", naturalmente si cancella la tabella intera, quindi sia i dati in essa presente, sia la struttura. Per sicurezza, PhpMyAdmin chiede la conferma se per errore si dovesse cliccare la voce

Modifica e cancellazione di campi in MySQL

MYSQL: PHPMYADMIN

Risorse.net

di campi in MySQL M Y SQL: P HP M Y A DMIN Risorse.net Per modificare

Per modificare o cancellare un campo è sufficiente posizionarsi sulle icone presenti nella "Struttura" tabella. Di seguito l'immagine che chiarisce il tutto:

tabella. Di seguito l'immagi ne che chiarisce il tutto: La prima icona modifica il campo, la

La prima icona modifica il campo, la seconda lo cancella, la terza aggiunge il modificatore PRIMARY KEY, la quarta aggiunge un indice, la quinta aggiunge il modificatore UNIQUE, la sesta aggiunge l'indice FULLTEXT. Per chiarimenti sui modificatori, rimandiamo alla puntata della guida a MySQL dedicata ai tipi di campi.

L'indice FULLTEXT merita un approfondimento. Per sfruttare le query di tipo Full Text si ha la necessità di avere un indice multiplo, mentre PhpMyAdmin imposta indici FULLTEXT unici (anche se supporta e visualizza correttamente gli indici FULLTEXT multipli). Per sapere come fare e cosa sono le query Full Text, rimandiamo alla puntata dedicata proprio alle query

Backup e ripristino del database MySQL

MYSQL: PHPMYADMIN

Risorse.net

del database MySQL M Y SQL: P HP M Y A DMIN Risorse.net Per effettuare una

Per effettuare una copia di sicurezza (detto anche dump) del proprio database MySQL, occorre selezionare dal menu a destra la voce Home e dal frame a destra selezionare la voce "Esporta", come raffigurato dall'immagine sottostante:

L'esportazione è un'operazione che raccomandiamo a tutti di eseguire periodicamente, anche perchè con il tool

L'esportazione è un'operazione che raccomandiamo a tutti di eseguire periodicamente, anche perchè con il tool PhpMyAdmin è un lavoro che dura pochi minuti (anche con database molto corposi).

Per fare in modo di avere una copia perfetta, la redazione di Risorse.net,per questa prova ha deciso

di

fleggare le voci "Aggiungi DROP DATABASE" e "Aggiungi Drop table"; il motivo è semplice,

in

caso di ripristino, la copia sovrascriverà tutto il vecchio database.

Di seguito l'immagine della finestra di PhpMyAdmin:

Simuliamo ora un danneggiamento del database di prova di Risorse.ne t, il db "odns". Avendo

Simuliamo ora un danneggiamento del database di prova di Risorse.net, il db "odns". Avendo prudenzialmente effettuato la copia, il compito del ripristino è davvero un'operazione semplice. Utilizzando PhpMyAdmin, entriamo nel db (se esiste ancora) e selezionamo la voce "SQL". Scegliamo Percorso del file, tramite il bottone "Sfoglia" e aprendo il file .sql precedentemente salvato eseguiamo la query. Ecco la pagina di PhpMyAdmin che raffigura il processo:

SQL di base SQL, acronimo di Structured Query Language, è un linguaggio utilizzato per manipolare

SQL di base

SQL, acronimo di Structured Query Language, è un linguaggio utilizzato per manipolare database. MySQL sfrutta proprio SQL per interagire con gli utenti, attraverso dei comandi comunemente chiamati query. Una query permette di "parlare" al database e consente di effettuare operazioni sul suo contenuto o sulla sua struttura.

Per selezionare i campi di un database, si usa il termine SELECT. Ammettiamo di dover estrarre il contenuto da tutti i campi di una tabella di nome "clienti", faremo:

SELECT * FROM clienti;

L'asterisco ( * ) ci consente di richiamare i campi senza specificare tutti i loro nomi. Il termine FROM permette di identificare il nome della tabella dalla quale estrapolare i dati. Se volessimo invece estrarre un solo campo, è inutile estrarli tutti e potremmo quindi usare il nome specifico, ad esempio:

SELECT ordini FROM clienti;

Se i campi fossero più di uno, è necessario separare i vari valori con una virgola ( , ) ad esempio:

SELECT ordini, citta, fatture FROM clienti;

Affinare la query: la clausola WHERE

Può essere necessario specificare meglio una query in modo tale da avere un risultato vicino alle nostre esigenze. Ad esempio, potremmo voler estrarre solo i nomi dei clienti della città di Milano, ecco come fare:

SELECT nome FROM clienti WHERE citta = 'milano';

In questo modo, avremo come risultato solo i nomi dei clienti che hanno sede a Milano.

Più in profondità: AND e OR

Facendo riferimento all'esempio di prima, potremmo richiedere i nomi dei clienti che hanno sede a Milano e hanno effettuato più di 10 ordini. Ecco come:

SELECT nome FROM clienti WHERE citta = 'milano' AND ordini <= 10;

Con la query sopra specificata, avremo sottomano i clienti di Milano con un numero di ordini maggiore o uguale a 10. Il termine AND può essere tranquillamente sostituito da due e commerciali ( && ).

Il termine OR, permette di creare un'alternativa. Ad esempio, se volessimo estrarre i clienti con sede a Milano oppure a Napoli, faremo:

SELECT nome FROM clienti WHERE citta = 'milano' OR citta = 'napoli';

Il termine OR può essere sostituito dalle due barre verticali ( || ).

Ordiniamo i dati: ORDER BY

Per ordinare l'estrazione di una tabella, si può usare ORDER BY, applicandolo magari assieme ai termini ASC (di default) e DESC.

Vediamo un esempio:

SELECT * FROM clienti ORDER BY ordini DESC;

In questo modo avremo i clienti estratti secondo il numero di ordini effettuati. Con DESC

specifichiamo dal numero più alto a quello più basso. Al contrario, ASC ordina dal numero più basso al più alto ed è di default.

ASC e DESC funzionano anche con campi diversi dai campi di tipo INT o simili. In caso di campi

di stringhe (TEXT, VARCHAR ecc.) seguiranno l'ordine alfabetico:

ASC dalla A alla Z. DESC il contrario, dalla Z alla A.

Quindi, tornando all'esempio precedente, per avere i nomi delle aziende clienti in ordine alfabetico, faremo:

SELECT * FROM clienti ORDER BY nome ASC;

ORDER BY multipli

Si possono ordinare i campi anche in base a più valori. Ammettiamo di volere i risultati delle query

precedenti, dai clienti che hanno fatto più ordini a quelli che ne hanno fatti meno, in ordine

alfabetico.

SELECT * FROM clienti ORDER BY nome, ordini DESC;

In questo modo, avremo le società in ordine alfabetico e da chi ha fatto più ordini a chi ne ha fatti di

meno.

Operatori di confronto

Quando si eseguono query SQL, è importante sapere quali operatori possono essere usati per confrontare un campo con un altro, oppure con un valore da noi specificato.

I

più usati sono:

<

>

<=

>=

=

!=

LIKE

I primi cinque operatori, sono uguali a tutti gli altri linguaggi di scripting o di programmazione e

identificano:

Minore

Maggiore

Minore o uguale

Maggiore o uguale

Uguale

Diverso

Un approfondimento a parte merita LIKE, che consente di effettuare una comparazione tra campi simili, anche non uguali.

Ad esempio, ammettiamo di voler estrarre, dalla tabella clienti, quelle aziende che contengano nella descrizione della società la parola Internet. Ecco come fare:

SELECT nome FROM clienti WHERE descrizione LIKE '%internet%'

I due simboli di percentuale ( % ), servono a MySQL per sapere che prima e dopo il termine

internet, potrebbero esserci altre parole. Se non avessimo usato questa query, magari usando WHERE descrizione = 'internet', il database avrebbe cercato quelle aziende che contengano nel campo descrizione la sola parola internet.

Possiamo anche usare le % in maniera diversa. Ad esempio:

SELECT nome FROM clienti WHERE citta LIKE 'mila%'

In questo modo, MySQL estrarrà tutte quei clienti che hanno come sede la parola mila seguita da altro testo, ad esempio: Milano, Milazzo, Milano Marittima ecc.

Operatori matematici

Con MySQL è possibile eseguire delle query utilizzando all'interno della sintassi SQL degli operatori matematici, che sono i classici della somma, sottrazione, moltiplicazione e divisione.

Somma

Possiamo sommare due o più campi per ottenere un nuovo campo, ad esempio:

SELECT (primoCampo + secondoCampo) AS totale FROM nomeTabella;

In questo modo, avremo una colonna di nome "totale" in cui saranno contenute tutte le somme dei

due campi.

Differenza

Come per la somma, possiamo fare:

SELECT (primoCampo - secondoCampo) AS differenza FROM nomeTabella;

Moltiplicazione

All'interno delle query è possibile anche moltiplicare i valori di più campi, ad esempio:

SELECT (primoCampo * secondoCampo) AS risultato FROM nomeTabella;

Divisione

E ancora, per la divisione, possiamo usare:

SELECT (primoCampo / secondoCampo) AS risultato FROM nomeTabella;

Elevazione a potenza

L'elevazione a potenza con MySQL si può ottenere usando due funzioni: POW(x,y) o POWER(x,y), dove x rappresenta la base della potenza e y l'esponente. Ecco un esempio:

SELECT POW(10,3);

Restituisce: 1000.000000

Radice quadrata

La radice quadrata non negativa di un numero si ottiene con:

SELECT SQRT(9);

E restituisce: 3.000000

Casi pratici

Gli operatori matematici possono essere molto comodi anche per ordinare dei risultati. Ammettiamo

di avere una tabella che contenga i voti totali assegnati a un articolo e il numero di persone che

hanno votato. Per ordinare i records così da ottenere gli articoli più apprezzati, faremo:

SELECT id,titolo FROM articoli ORDER BY (voti_totali / numero_voti) DESC;

Per migliorare la query e avere sottomano anche la media dei voti di ogni articolo, possiamo crearci un campo provvisorio con il comando AS, ecco come:

SELECT (voti_totali / numero_voti) AS mediaVoto, id, titolo FROM articoli ORDER BY mediaVoto DESC.

Altri operatori e funzioni matematiche

Nella puntata dedicata agli operatori matematici di base, abbiamo visto le sintassi SQL per eseguire calcoli su un RDBMS MySQL.

In questa puntata vedremo gli operatori più avanzati, che consentono i calcoli di logaritmi, seni e

coseni, tangenti, archi e arrotondamenti.

LEAST

La funzione LEAST restituisce la cifra più piccola di quelle passate come parametri. Ad esempio:

SELECT LEAST(1, 4, 5, 8.6, 0.9);

Restituisce: 0.9

GREATEST

Funzione simile alla precedente, ma ricava il numero più grande. Tipo:

SELECT GREATEST(1, 4, 5, 8.6, 0.9);

Restituisce: 8.6

MOD

Questa funzione da' come risultato il resto di un numero (passato come primo parametro) diviso per l'altro numero (passato come secondo parametro). Vediamo:

SELECT MOD(5,2);

Restituisce 1

FLOOR

La funzione FLOOR arrotonda la cifra specificata all'intero più grande inferiore alla cifra stessa. Ecco un esempio chiarificatore:

SELECT FLOOR(11.5);

Restituisce: 11

CEILING

Questa funzione è molto simile alla FLOOR ma esegue l'arrotondamento al valore minore non inferiore alla cifra stessa. Ecco il solito esempio "schiarsci-idee":

SELECT CEILING(11.5);

Restituisce: 12

ROUND

A questa funzione vengono passati due parametri: nel primo il numero da arrotondare e nel secondo

parametro, a quale cifra decimale effettuare l'arrotondamento.

Ecco come:

SELECT ROUND(12.5682,2);

Restituisce: 12.57

Se il secondo parametro non venisse specificato, la cifra viene arrotondata all'intero più grande

inferiore alla cifra stessa (proprio come la funzione FLOOR). Ad esempio:

SELECT ROUND(12.5);

Restituisce: 12

EXP

La funzione EXP restituisce la base dei logaritmi naturali elevata alla potenza della cifra indicata. Ecco come:

SELECT EXP(2);

Restituisce: 7.389056

LOG

Questa funzione da' come risultato il logaritmo naturale del numero indicato. Ecco:

SELECT LOG(12);

Restituisce: 2.484907

LOG10

Questa funzione, simile alla precedente, restituisce il logaritmo del numero specificato in base 10.

SELECT LOG10(12);

Restituisce: 1.079181

SIGN

La funzione SIGN consente di ottenere tre risultati diversi in base al segno della cifra indicata. Un numero positivo restituirebbe 1, un numero negativo -1 e un numero nullo (0 - zero) restituirebbe per l'appunto 0. Vediamo tre esempi:

SELECT SIGN(5);

Restituisce: 1

SELECT SIGN(-2);

Restituisce: -1

SELECT SIGN(0);

Restituisce: 0

SIN

La funzione SIN ottiene il seno di una cifra data in radianti:

SELECT SIN(10);

COS

Questa funzione calcola il coseno di un numero dato in radianti:

SELECT COS(10);

Restituisce: -0.839072

TAN

La funzione TAN calcola la tangente di un numero espresso in radianti:

SELECT TAN(10);

Restituisce: 0.648361

ASIN

Questa funzione calcola l'arco seno di un numero. Restituisce NULL se la cifra non fosse compresa tra -1 e 1.

SELECT ASIN(-0.5);

Restituisce: -0.523599

ACOS

Simile alla precedente, ma restituisce ovviamente l'arco coseno della cifra indicata quando quest'ultima fosse compresa tra -1 e 1. Altrimenti restituirebbe NULL.

SELECT ACOS(-0.5);

Restituisce: 2.094395

ATAN

Questa restituisce invece l'arco tangente della cifra indicata:

SELECT ATAN(3);

Restituisce: 1.249046

ATAN2

Questa restituisce invece l'arco tangente delle due cifre indicate, tipo:

SELECT ATAN2(3,4);

Restituisce: 0.643501

COT

La funzione COT restituisce la cotagente della cifra data, ad esempio:

SELECT COT(5);

Restituisce: -0.29581292

DEGREES

Questa funzione converte i numeri da radianti a gradi:

SELECT DEGREES(2);

Restituisce: 114.59155902616

RADIANS

Effettua l'operazione inversa della funzione precedente. Ovvero partendo da un numero in gradi, lo converte in radianti.

SELECT RADIANS(114.59155902616);

Restituisce: 1.9999999999999

Funzioni condizionali

Le funzioni condizionali di MySQL consentono di eseguire query verificando che un'istruzione sia vera o falsa. Come per tutti i linguaggi di programmazione, la condizione e il relativo comportamente viene suddiviso su tre passaggi:

1. La condizione

2. Se la condizione è vera, esegue questa istruzione

3. Se la condizione è falsa, esegue un'altra istruzione

Il classico If

Then

Else

MySQL prevede diverse sintassi per le verifiche condizionali. Vediamone alcune:

La funzione IF

La funzione IF permette di confrontare dei campi e restituire delle istruzioni diversi a seconda della veridicità della condizione iniziale:

SELECT IF(primoCampo != secondoCampo, 1, 0) FROM nomeTabella;

Con questo tipo di query, MySQL confronta il primoCampo con il secondoCampo. Se fossero diversi, restituirebbe 1, altrimenti 0.

Vediamo un caso banale ma pratico. Possiamo effettuare la verifica condizionale IF anche con dei numeri. Ad esempio:

SELECT IF(1<2, 'vero', 'falso');

In questo caso, MySQL restituisce "vero", perché 1 è minore di 2.

IFNULL

Questa funzione può risultare molto comoda per intercettare i NULL che MySQL potrebbe

restituire. IFNULL infatti intercetta i casi di NULL e restituisce ciò che il database administrator desidera.

Può essere utile quando si divide un campo per un altro quando non si sa cosa contengano i due campi (magari perché dinamicamente modificati dagli utenti). Se infatti il secondo campo fosse zero ( 0 ), dividere per 0 restituisce un errore, per MySQL quindi è NULL. Onde evitare questo problema, si usa il condizionale IFNULL. Vediamo un esempio con dei numeri:

SELECT IFNULL(2/0,'impossibile');

In questo caso MySQL, invece di restituire NULL, restituisce "impossibile".

CASE

Questo condizionale consente a MySQL di verificare più campi, come per il Select Case di Visual Basic o Switch() per i linguaggi derivati da C (Java, Javascript, C# ecc.).

Quindi, invece di avere una sola condizione, CASE consente di effettuare più verifiche, ad esempio:

SELECT CASE 1 WHEN primoCampo = 'primoValore' THEN 1 WHEN secondoCampo = 'secondoValore' THEN 2 WHEN terzoCampo = 'terzoValore' THEN 3 ELSE 'nessuna condizione è vera' END;

In questo modo, se uno dei valori del campo primoCampo è uguale a "primoValore", allora MySQL restituisce 1. E così via per il secondoCampo e il terzoCampo. Se nessuna condizione è soddisfatta, MySQL restituisce "nessuna condizione è vera". Il comando END finale, chiude il CASE.

Funzioni aggregate

Le funzioni aggregate servono per eseguire operazioni matematiche su una o più colonne di MySQL.

COUNT

La funzione COUNT viene utilizzata per recuperare il numero di righe di una colonna. Ad esempio:

SELECT COUNT(*) AS totale FROM nomeTabella;

Questa funzione può essere utilizzata su qualunque tipo di dato.

COUNT(DISTINCT)

Questa funzione restituisce il numero delle diverse combinazioni che non contengono il valore NULL. Ad esempio, se in una colonna abbiamo 10 righe: 5 contenenti la parola "calcio", 3 contenenti il termine "tennis" e le ultime 2 con "golf", effettuando un COUNT(DISTINCT) avremo il numero di combinazioni diverse, ovvero 3 (calcio, tennis, golf).

SELECT(DISTINCT nomeCampo) FROM nomeTabella;

Per riassumere quindi, se avessimo una tabella di MySQL che raccoglie le registrazioni a un determinato sito, SELECT COUNT(DISTINCT) può essere utile per sapere quanti nomi diversi sono stati usati, oppure quanti diversi titoli di studio ecc.

MAX

Questa funzione restituisce il valore più alto contenuto all'interno di una colonna. Per i campi numerici, restituisce il numero più alto, per quelli testuali (nei nuovi MySQL questa operazione è permessa) seleziona il campo che secondo l'ordine alfabetico è più avanti (ad esempio due valori:

Alessandro e Filippo prende Filippo)

SELECT MAX(nomeCampo) FROM nomeTabella;

MIN

Questa funzione fa esattamente l'opposto della precedente: prende il valore più basso. Ecco un esempio:

SELECT MIN(nomeCampo) FROM nomeTabella;

AVG

Restituisce una media dei valori presenti in un campo. Da applicare ai soli campi numerici:

SELECT AVG(nomeCampoNumerico) FROM nomeTabella;

SUM

La funzione SUM somma i valori contenuti nel campo:

SELECT SUM(nomeCampoNumerico) FROM nomeTabella;

Anche questa funzione, va applicata ai soli campi numerici.

STD

Questa è una funzione utile per gli statistici. Calcola infatti la distanza di un valore dalla media, e si ottiene con:

SELECT STD(nomeCampoNumerico) FROM nomeTabella;

GROUP BY

La clausola GROUP BY consente di raggruppare un set di risultati in presenza di una delle funzioni aggregate previste da MySQL.

Ammettiamo di avere una tabella con tre voci:

id (INT e AUTO_INCREMENT)

ordini (TINYINT)

cliente (VARCHAR)

Per sapere quale sia la distanza dalla media degli ordini di ogni cliente, faremo:

SELECT STD(ordini) AS dispersione, cliente FROM nomeTabella GROUP BY cliente;

In questo modo avremo due tabelle, "dispersione" che contiene la distanza della media degli ordini e "cliente" contenente appunto il nome del cliente.

Nomi di tabelle e campi in MySQL

Nella puntata SQL di base all'interno di questa guida a MySQL, abbiamo visto che SQL è a tutti gli effetti un linguaggio. In quanto tale, ha regole grammaticali e strutturali che vanno rispettate, così da interagire alla perfezione con il database.

Tra queste regole, come per quasi tutti i linguaggi, esistono nomi riservati che non possono essere utilizzati:

ALTER

AND

AS

CREATE

CROSS JOIN

DELETE

DROP

FROM

FULL JOIN

GROUP BY

INSERT

INTO

JOIN

LEFT JOIN

LIKE

LIMIT

ON

OR

ORDER BY

RIGHT JOIN

SELECT

SET

UPDATE

WHERE

Altri consigli nell'assegnazione dei nomi

Quando andiamo assegnare i nomi delle nostre tabelle e dei nostri campi, esistono altre piccole regole che è meglio seguire. E' bene evitare caratteri particolari all'interno dei nomi. Per un migliore funzionamento, è bene utilizzare solo:

Caratteri alfanumerici

Per inserire spazi tra le parole, usare il simbolo underscore ( _ )

E nient'altro. E' bene quindi evitare altri simboli ( ? , . ` ' " @ ù à ò ì è é + * ecc.), utilizzare il carattere di spaziatura o anche il semplice trattino ( - ). Questo ultimo simbolo, merita un approfondimento a parte. Se ci trovassimo di fronte a un campo dal nome:

voti-totali

Per estrarlo, magari dalla tabella "voti", dovremmo fare:

SELECT `voti-totali` FROM voti

Questo perché la presenza del trattino ( - ) ci impone l'utilizzo del simbolo ` per raggruppare il nome del campo (o della tabella).

Migliorare la leggibilità delle query

Una pratica che seguo da molto tempo per migliorare la leggibilità delle query SQL (con MySQL o

altri database) è quella di utilizzare i comandi in maiuscolo e i nomi dei campi in minuscolo. Questo

mi è molto utile quando devo scrivere query più strutturate, ad esempio:

SELECT * FROM fornitori WHERE id_prodotto IN (SELECT id_prodotto FROM prodotti_spediti AS o, mezzo_di_trasporto AS s WHERE s.mezzo_di_trasporto LIKE 'gomma%' AND s.mezzo_di_trasporto=o.mezzo_usato)

Casi particolari: gli escape

Esistono casi in cui è necessario applicare gli escape ad alcuni caratteri. Ammettiamo di voler realizzare una query simile:

SELECT * FROM nomeTabella WHERE titolo = 'L'utilità di MySQL';

In questo caso, avremo un errore perché non è possibile usare l'apice sigolo ( ' ) quando abbiamo già usato gli apostrofi come delimitatori del valore del campo. E' necessario quindi applicare l'escape al carattere apostrofo, come segue:

SELECT * FROM nomeTabella WHERE titolo = 'L\'utilità di MySQL';

Un altro carattere che va obbligatoriamente sottoposto a escape è la backslash ( \ ). Come segue:

INSERT INTO nomeTabella VALUES('La backslash (\\) va sottoposta a escape con il segno \\');

Funzioni automatiche per gli escape

Spesso MySQL viene utilizzato nel Web associato ad un linguaggio di sviluppo, come PHP, oppure a una tecnologia lato server come ASP. Per effettuare gli escape dei caratteri quindi, si possono usare funzioni predefinite:

PHP Con PHP è possibile sfruttare alcune funzioni predefinite, come ad esempio:

mysql_escape_string() Aggiunge le sequenze di escape in una stringa (implementata dalla versione 4.0.3 di PHP).

mysql_real_escape_string() Aggiunge le sequenze di escape ai caratteri speciali in una stringa per l'uso in una istruzione SQL, tenendo conto dell'attuale set di caratteri della connessione (presente dalla versione 4.3.0 di PHP).

PHP comunque, ha molte altre funzioni dedicate a MySQL, disponibili nella documentazione

ufficiale.

ASP

Le ASP non prevedono funzioni già realizzate ma sarebbe utile farsene una.

Ad esempio qualcosa tipo:

Function PerSQL(info) PerSQL = Replace(Replace(info,"\","\\"),"'","\'") End Function

Come ricavare l'ultimo record

Altri database però non supportano il TOP, come ad esempio MySQL. In questo caso, è necessario usare la proprietà LIMIT, già vista all'interno del Magazine nell'articolo La paginazione in MySQL.

Il funzionamento è molto simile ai database Microsoft:

SELECT * FROM NomeTabella O
SELECT * FROM NomeTabella O

Estrarre record casuali da MySQL e SQL Server

MySQL e SQL Server estraggono record casuali con sintassi differenti ma simili. Vediamo prima con MySQL

SELECT * FROM tabella ORDER
SELECT * FROM tabella ORDER

In questo modo, estrarremo un solo record a caso. Per cambiare, è sufficiente modificare LIMIT 1 con i record che si vogliono estrarre (ad esempio LIMIT 3 ne estrae tre, oppure LIMIT 5,6 ne estrae sei partendo dal quinto).

Inserire una nuova riga

Per aggiungere una riga all'interno di una tabella in MySQL, si utilizza il termine INSERT.

Ammettiamo ora di voler aggiungere una nuova voce all'interno della tabella clienti:

INSERT INTO clienti(id,nome,descrizione,citta,ordini) VALUES('102','WebMilano Enterprise','Web agency','Milano','1')

In questo modo, abbiamo inserito i nuovi valori specificati tra le parentesi del termine VALUES all'interno della tabella clienti (INSERT INTO), i cui campi sono specificati anch'essi tra parentesi tonde.

Se dovessimo inserire tutti i valori nella nuova riga, possiamo anche omettere i vari campi all'interno della tabella. Ad esempio:

INSERT INTO clienti VALUES('102','WebMilano Enterprise','Web agency','Milano','1')

I campi che possono essere lasciati vuoti (perché auto incrementali, null ecc.) possono anche non essere inseriti all'interno della query. Ammettiamo che "id" sia un campo incrementale e che "ordini" abbia come valore predefinito 1. Possiamo evitare di specificarli, ad esempio:

INSERT INTO clienti(nome,descrizione,citta) VALUES('WebMilano Enterprise','Web agency','Milano')

Durante l'operazione di inserimento, dobbiamo fare attenzione che a ogni campo specificato tra le parentesi tonde all'interno della tabella, sia associato un valore interno a VALUES. Se ad esempio inserissimo per errore più valori all'interno di VALUES rispetto a quanti ne avessimo specificati dopo INTO nomeTabella, MySQL ci risponderebbe con un errore simile:

ERROR 1136 - Column count doesn't match value count at row N

Dove N è la riga dell'errore.

In questo caso, significa appunto che nel campo VALUES abbiamo specificato più valori di quanto

possibile.

Lo stesso errore ci verrebbe restituito se facessimo il caso opposto, ovvero mancasse l'inserimento

di qualche campo specificato nella query.

Effettuare inserimenti multipli con MySQL

Quando dobbiamo inserire più righe all'interno di una sola tabella, a rigor di logica dovremmo usare tante istruzioni INSERT INTO quante sono le nuova righe. MySQL invece, consente gli inserimenti multipli con una sola istruzione INSERT INTO, ad esempio:

INSERT INTO clienti(nome,descrizione,citta) VALUES('WebMilano.NET','WebAgency','Milano'), VALUES('Latte & tipici','Casearia','Modena'), VALUES('Auto e occasioni','Concessionaria','Palermo')

Ogni VALUES va separato dall'altro con una virgola ( , )

Nessuno ci vieta comunque di usare più INSERT INTO, ad esempio:

INSERT INTO clienti(nome,descrizione,citta) VALUES('WebMilano.NET','WebAgency','Milano') INSERT INTO clienti(nome,descrizione,citta) VALUES('Latte & tipici','Casearia','Modena') INSERT INTO clienti(nome,descrizione,citta) VALUES('Auto e occasioni','Concessionaria','Milano')

Anche se con più INSERT INTO avremo un calo di prestazioni e soprattutto uno spreco di codice inutile.

Modificare una riga

La modifica delle righe di una tabella MySQL avviene attraverso il termine UPDATE.

Modificare una sola riga

Il codice è:

UPDATE nomeTabella SET nomeCampo = 'nuovoValore' WHERE id = 'n';

Dove "n" identifica il campo id univoco (di tipo INT e AUTO_INCREMENT) da modificare.

Modificare più righe

La modifica di più righe è molto simile alla procedura seguita per la modifica di una sola riga, è

sufficiente solo allargare le coincidenze della clausola WHERE. Ad esempio, per modificare tutti i

records che hanno il cmapo "id" maggiore a 10, faremo:

UPDATE nomeTabella SET nomeCampo = 'nuovoValore' WHERE id > 10;

Ci sono casi in cui è necessario modificare più righe che hanno "id" non raggruppabili. Sarà

necessario specificare una nuova istruzione UPDATE, ad esempio:

UPDATE nomeTabella SET nomeCampo = 'nuovoValore' WHERE id = 5; UPDATE nomeTabella SET nomeCampo = 'altroValore' WHERE id = 12; UPDATE nomeTabella SET nomeCampo = 'ennesimoValore' WHERE id = 25;

Modificare tutte le righe

Per modificare tutte le righe di una tabella, si può prendere la query precedente e omettere la clausola WHERE:

UPDATE nomeTabella SET nomeCampo = 'nuovoValore';

Modificare i valori con operatori matematici

Come abbiamo già visto nella puntata dedicata agli operatori matematici, nel caso in cui avessimo

un campo numerico, possiamo modificarlo al volo, senza bisogno di estrarlo e operarci poi sopra con un linguaggio server side come PHP.

Ad esempio, per aggiungere una unità a un campo INT, possiamo fare:

UPDATE nomeTabella SET nomeCampo = nomeCampo + 1;

Per raddoppiare il campo, potremmo fare:

UPDATE nomeTabella SET nomeCampo = nomeCampo * 2;

Passare da Access a MySQL

Qualche giorno fa mi sono ritrovato nella necessità di trasportare tre tabelle da Access a MySQL, in pratica si trattava di un database da poco più di un MB (oltre cento records nella tabella più popolosa) e mi sono interessato all'argomento, leggendomi le esperienze di altri utenti e articoli ad hoc.

Avevo sottomano un portatile e dovevo fare il lavoro il prima possibile. Così ho dovuto scartare la possibilità di utilizzare i driver MyODBC o salvare i dati in formato .csv per poi accedere

direttamente a MySQL.

Così mi sono messo a cercare in Rete un software creato apposta e ho trovato un ottimo prodotto, il cui nome è tutto un programma: Access to MySQL, disponibile all'indirizzo www.convert-

in.com/acc2sql.htm.

Il convertitore lavora bene anche con diverse versioni di MySQL e supporta due diverse opzioni: la connessione diretta a MySQL e la creazione di un file cosidetto di DUMP, il quale consente di ricreare la struttura delle tabelle e il loro contenuto in pochi minuti.

I file di DUMP, non sono altro che la lista dei comandi SQL (CREATE, INSERT ecc.) per la creazione delle tabelle con la stessa struttura presente in Access. Si occupa anche di popolare le tabelle con i records trovati. Il file di DUMP poi, è possibile riutilizzarlo in qualunque software per gestire MySQL da remoto, anche PhpMyAdmin.

Nel mio caso specifico, ho usato la versione demo di Access to MySQL, la quale consente di ricreare la struttura delle tabelle e inserire fino a 5 records. E per gli altri? Mi sono creato un file in locale che leggesse i rimanenti records e mi creasse un mio personale file di DUMP con le istruzioni per inserire ciò che la versione demo del software non faceva. Vediamo come.

Innanzitutto ho lanciato il software Access to MySQL e ho lasciato che lavorasse per me. Ho scelto prima la creazione del file di DUMP:

per me. Ho scelto prima la creazione del file di DUMP: Poi ho scelto le opzioni

Poi ho scelto le opzioni offerte dal software: il database MySQL usato (nel mio caso 3.23.6 o superiori e MS Windows).

Come si può vedere dall'immagine successiva, si può scegliere tra MySQL nelle versioni inferiori o superiori alla 3.23.6 e se il database risiede su una macchina dotata di un sistema operativo Windows o Unix (\r\n e \n sono le due istruzioni per intercettare una nuova riga, ovvero un ritorno a capo, con i due OS).

E ancora, ho selezionato "Add lock for write around 'INSERT' statements" e "Insert 'CREATE TABLE' statements", entrambi utili nel mio caso specifico.

Se ci interessasse, potremmo anche selezionare la possibilità di creare un nuovo database all'interno

di MySQL oppure di inserire dei commenti

cosa che a me assolutamente non interessava.

dei commenti cosa che a me assolutamente non interessava. Il passo successivo, quello sulla si curezza

Il passo successivo, quello sulla sicurezza di Access, l'ho saltato e ho poi specificato il percorso del file .mdb e la directory dove salvare il file .sql contenente il file di DUMP. In questo caso, se il database Access è protetto da password, è possibile specificare la parola chiave:

Se si cliccasse sulla voce "Convert table definitions only", Access To MySQL creerebbe il file

Se si cliccasse sulla voce "Convert table definitions only", Access To MySQL creerebbe il file di DUMP solo per importare la struttura della tabella, senza includere i records presenti.

La finestra seguente, rileva le tabelle di Access e ci chiede quali di queste vogliamo convertire su MySQL. Selezionamo quelle che ci interessano e passiamo avanti:

e ci chiede quali di queste vogliamo convertire su MySQL . Selezionamo quelle che ci interessano

L'ultima finestra ci avviserà di aver terminato il lavoro. Ora possiamo aprire il file .sql che abbiamo salvato nel terzo passaggio. Il codice interno è SQL, per fare un esempio, abbiamo convertito una semplice tabella Access e pubblichiamo qui il codice SQL per inserirla in MySQL (il file DUMP in pratica):

DROP TABLE IF EXISTS `controllovoti`; CREATE TABLE `controllovoti` ( `id` INT NOT NULL AUTO_INCREMENT, `idrisorsa` INT NOT NULL DEFAULT 0, `ip` VARCHAR(50), `data` CHAR(19), INDEX `id` (`id`), INDEX `idrisorsa` (`idrisorsa`), PRIMARY KEY `PrimaryKey` (`id`) ); LOCK TABLES `controllovoti` WRITE; INSERT INTO `controllovoti` VALUES(2, 1, '127.0.0.3', '2001-11-09 21:45:19'); INSERT INTO `controllovoti` VALUES(3, 1, '127.0.0.2', '2001-11-09 21:48:19'); INSERT INTO `controllovoti` VALUES(4, 1, '127.0.0.4', '2001-11-09 21:49:19'); INSERT INTO `controllovoti` VALUES(5, 3, '127.0.0.5', '2001-11-09 22:38:46'); INSERT INTO `controllovoti` VALUES(6, 3, '127.0.0.1', '2001-11-11 01:26:10'); UNLOCK TABLES; ALTER TABLE `controllovoti` CHANGE `data` `data` DATETIME;

Ora possiamo effettuare una query al database MySQL con i comandi del file di DUMP. Da PhpMyAdmin è possibile effettuarla attraverso l'apposita textarea copiando e incollando il codice SQL. Se il file è troppo lungo, possiamo sfruttare la possibilità di effettuare query da un file di testo, attraverso l'apposito comando sfoglia:

possiamo sfruttare la possibilità di effettu are query da un file di testo, attraverso l'apposito comando

l sofware di gestione di MySQL da remoto (in questo caso PhpMyAdmin) una volta portata a termine la query (può volerci qualche secondo se il file di DUMP è molto lungo) ci avviserà dell'esito finale. Nel mio caso è stato positivo, e ho così potuto concentrarmi sull'inserimento dei records mancanti. Ricordo infatti che Access to MySQL demo importa solo 5 records.

Nota: chi vuole, può comunque comprarsi la versione definitiva del software di conversione, che nella soluzione base costa meno di 40 dollari, ma a me piace sviluppare e imparare e così ho fatto da solo. Per chi volesse, sono disponibili maggiori informazioni

Riprendendo il filo del discorso, mi sono creato un file .asp che interrogasse il database Access e restituisse la sintassi SQL e quindi il file di DUMP. Ecco cosa ho scritto:

<%

dim strConn strConn="Provider = Microsoft.Jet.OLEDB.4.0; Data Source = "&Server.MapPath("/percorso_del/db.mdb")&"; Persist Security Info = False"

Set conn=Server.CreateObject("ADODB.Connection") conn.Open strConn

set rs = Server.CreateObject("ADODB.Recordset")

sql = "SELECT * FROM controllovoti WHERE id > 5"

rs.open sql, conn, 1, 3

do while not rs.eof

response.write("INSERT INTO `controllovoti` VALUES(" & rs("id") & ", '" & rs("idrisorsa") & "','" & rs("ip") & "','" & Rs("data") & "');" & VbCrLF) rs.movenext

loop

rs.close

set rs=Nothing

conn.Close set conn=Nothing

%>

Una volta ottenuto il codice, ho visualizzato l'HTML e mi sono salvato il codice prodotto. Poi ho aperto PhpMyAdmin alla tabella che mi interessava e ho eseguito la query attraverso il file salvato. In questo modo, avevo convertito il mio database da Access a MySQL, senza spendere un euro e in 5 minuti di tempo.

La paginazione dei dati con MySQL e le ASP

Quando si estrapolano informazioni da un database, si ha spesso la necessità di paginarli, ovvero estrarne un po' alla volta e permetterne poi la navigazione degli altri attraverso l'utilizzo delle pagine seguenti e poi precedenti. E' una pratica diffusissima nel Web, ma anche quando si lavora con grandi quantità di dati al di fuori dal WWW. Pe revitare tempi di attesa troppo lunghi, si può infatti eseguire la cosidetta paginazione.

MySQL supporta la paginazione dei dati attraverso l'istruzione LIMIT, che limita appunto l'estrapolazione di dati. Una query simile:

SELECT * FROM dati LIMIT 1,5

Specifica a MySQL di prendere i records dal primo al quinto all'interno della tabella dati. I due valori che seguono l'istruzione LIMIT, indicano da quale record iniziare a prendere i dati e quanti prenderne (1,5: per l'appunto dal primo record, prendine cinque).

Se avessimo voluto prenderli dal ventesimo al trentesimo, avremmo scritto:

SELECT * FROM dati LIMIT 20,10

Ovvero, partendo dal ventesimo record, prendine 10 Abbiamo visto che l'istruzione LIMIT circoscrive la quantità di informazioni da ricavare dal database. Quando però si ha la necessità di paginare i dati, è importante che gli estremi della proprietà LIMIT vengano calcolati dinamicamente. Questo perché è necessario indicare ogni volta da che record partire l'estrazione e a quale fermarsi.

Ammettiamo di voler estrarre 5 records per pagina, la query dovrebbe essere:

SELECT * FROM dati LIMIT 1,5

Per la prima pagina, ma poi per la seconda sarà:

SELECT * FROM dati LIMIT 6,5

E per la terza:

SELECT * FROM dati LIMIT 11,5

E così via

pagina deve corrispondere il record iniziale e finale dell'estrazione, fermandosi quando i records

saranno terminati.

Questi due valori da indicare a LIMIT vanno ricavati dinamicamente, ovvero ad ogni

Otteniamo il totale di records

Prima di iniziare la paginazione vera e propria, è necessario estrapolare il dato totale di records, così da evitare di paginare dati quando i records saranno finiti. La query è:

SELECT COUNT(*) AS totale FROM NomeTabella

In questo modo con la voce totale avremo il numero di records estratti dalla query. Da questo punto in poi andremo avanti con le ASP, ma tradurre il codice in PHP (o altri linguaggi) è davvero molto semplice. Si tratta solo di costrutti if e calcoli matematici.

Prepariamo la paginazione

Con la query di prima, avevamo ricavato il totale di record estratti. Ora possiamo calcolarci dinamicamente i vari valori di LIMIT. Attraverso queste semplici istruzioni:

dim pagina pagina = Cint(request.querystring("pag")) if pagina<=0 then pagina=1

SQLcount = "SELECT COUNT(NomeTabella.NomeCampo) AS totale FROM NomeTabella GROUP BY NomeTabella.id"

Set adoRstCount=adoCon.Execute(SQLcount)

PageSize = 5

' Quanti records per pagina

inizio = (pagina-1)*PageSize

' il primo record di ogni pagina

totali = Cint(adoRstCount("totale"))

' Quanti records abbiamo estratto dalla query

NumPagine = totali/PageSize

' Quante pagine abbiamo ottenuto

' L'if successivo serve ad arrotondare per eccesso il numero di pagine

' nel caso in cui ottenessimo un numero decimale

' ad esempio 20 records da distribuire in 6 pagine

If NumPagine-Cint(NumPagine) > 0 Then NumPagine = Cint(NumPagine+1)

Else

NumPagine = Cint(NumPagine) End If

adoRstCount.Close Set adoRstCount=Nothing

In questo modo, all'interno delle variabili:

PageSize: abbiamo i records da distribuire in ogni pagina. inizio: Il primo valore da assegnare a LIMIT. NumPagine: Il numero totale di pagine.

Eseguiamo la query

Con le variabili ottenute, ora è sufficiente ricostruire la query dinamica. Apriamo quindi una nuova

connessione al database ed estrapoliamo i dati:

SQL = "SELECT * FROM NomeTabella LIMIT " & inizio & ", " & PageSize

Set adoRst=adoCon.Execute(SQL)

if totali > 0 then

Response.write("Sono stati trovati <b>" & totali & "</b> records<br><br>")

for i=1 to PageSize if adoRst.eof<>true and adoRst.bof<>true then

' qui inseriamo i dati che vogliamo stampare a video

adoRst.movenext

next

Else

end if

Response.write("Nessun record trovato")

end if

If totali > PageSize AND NumPagine > pagina then Response.write("<a href='?pag=" & Cint(pagina+1) & "'>Pagina successiva</a><br>") End If

If pagina > 1 then Response.write("<br><a href='?pag=" & Cint(pagina-1) & "'>Pagina precedente</a>") End If

adoRst.close Set adoRst=Nothing

Conclusioni

Abbiamo visto come paginare i dati con un database MySQL. Riassumendo, il codice si compone di tre parti fondamentali:

1. Otteniamo il totale di records con una query ad hoc usando l'istruzione COUNT()

2. Prepariamo le variabili per la paginazione dei dati

3. Eseguiamo l'ultima query con le variabili precedentemente ottenute

Le regular expressions con MySQL

MySQL supporta l'utilizzo delle Regular Expressions (o espressioni regolari) all'interno delle query.

Per utilizzarle, un esempio di sintassi può essere la seguente:

SELECT * FROM nomeTabella WHERE nomeCampo REGEXP "pattern";

Il pattern include le istruzioni per verificare la regular expression. Sono tanti i caratteri speciali ammessi nell'espressione regolare. Partiamo da un esempio pratico per analizzarli tutti. Ammettiamo di voler cercare tutti quei campi i cui valori iniziano con la lettera "r" e finiscano con la lettera "o". Faremo:

SELECT * FROM nomeTabella WHERE nomeCampo REGEXP "^r.+o$";

Vediamo cosa significano i simboli usati nella query appena vista:

^ che inizia con il carattere successivo

. cerca ogni tipo di carattere (anche ritorni a capo)

+ che siano presenti una o più volte

$ che termini con il carattere precedente

In questo modo, i risultati precedenti comprenderanno valori come:

roberto

Roberto

ROBERTO

romolo

Rho

Ma non stringhe tipo "ro". Perché tra il carattere "r" e "o" ci dovrà essere almeno un altro carattere. Neppure termini come "alrogo" o "arrotare" sarebbero accettati, perché la stringa dovrà iniziare con "r" e finire con "o".

Altri caratteri speciali

Le regular expressions con MySQL supportano comunque altri caratteri speciali. Vediamoli tutti, anche quelli appena analizzati, qui di seguito:

^ che iniziano con il carattere successivo

$ che finiscano con il carattere precedente

. cerca ogni carattere

* il carattere precedente dovrà essere presente 0 (zero) o più volte

+ il carattere precedente dovrà essere presente 1 (una) o più volte

? il carattere precedente dovrà essere presente 0 (zero) o 1 (una) volta

questo|altro cerca la stringa "questo" oppure (OR) la stringa "altro"

(parola)* cerca 0 (zero) o più istanze della stringa "parola"

a{3,5} il carattere precedente alla { (parentesi graffa), in questo caso "a", dovrà essere presente almeno 3 volte, ma non più di 5 volte

[b-eFl] cerca una stringa che contenga le lettere dalla "b" alla "e" (b c d e), e anche la lettera "F" e la lettera "l"

[^b-eFl] cerca una stringa che NON contenga le lettere dalla "b" alla "e" (b c d e), e anche la lettera "F" e la lettera "l"

"[[:stringa:]] cerca il termine "stringa", preceduto o seguito da qualunque carattere ("questa è una megastringa MySQL" sarebbe accettato)

[[:<:]]stringa[[:>:]] cerca il termine "stringa" che sia una parola a sé stante (ovvero separata da ciò che c'è prima e dopo da almeno uno spazio ("questa è una stringa per MySQL" sarebbe accettato ma "questa è una megastringa per MySQL" non sarebbe accettato).

Vediamo qualche esempio pratico:

SELECT "prova" REGEXP "[a-z]";

Restituisce 1 (vero).

SELECT "02800111222" REGEXP "^[0-9]{1,}[0-9]$";

Restituisce 1, ma anche:

SELECT "02800111222" REGEXP "^[0-9]+[0-9]$";

Restituisce 1. Il simbolo + infatti, significa presente una o più volte. I simboli {1,} significano appunto presente almeno 1 (una) volta, e il massimo di volte non è indicato (quindi una o più volte)

Eseguire query Full text

Le query Full Text consentono di eseguire ricerche ad alta precisione all'interno di un database. E' possibile sfruttarle solo dalla versione 3.23.23 di MySQL e solo con tabelle di tipo MyISAM e campi CHAR, VARCHAR, o TEXT. Per eseguire una query Full text su MySQL, è necessario creare un indice che riunisca i vari campi che vanno sfruttati nella query. Per fare ciò, è sufficiente aggiungere un INDEX di tipo FULLTEXT a tali campi. Su una tabella già esistente, possiamo fare:

ALTER TABLE nomeTabella ADD FULLTEXT (primoCampo,secondoCampo,terzoCampo,

);

Se invece dovessimo creare una nuova tabella, allora nel momento in cui andiamo a specificare i vari campi, possiamo aggiungere il FULLTEXT, ad esempio:

CREATE TABLE nomeTabella ( id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY, titolo VARCHAR(200), testo TEXT, FULLTEXT (titolo,testo)

);

Una volta aggiunto l'indice FULLTEXT, possiamo iniziare a eseguire le nostre query. Ammettiamo di voler cercare la parola MySQL all'interno dei campi "titolo" e "testo" (della tabella "notizie") e ordinare i risultati secondo l'attinenza della parola ricercata nei due campi. Ecco come fare:

SELECT titolo,descrizione, MATCH(titolo,testo) AGAINST('mysql') AS attinenza FROM notizie WHERE MATCH(titolo,testo) AGAINST('mysql') ORDER BY attinenza DESC

Così otterremo i due campi titolo e descrizione che all'interno di titolo e testo avranno la parola mysql, ordinati secondo l'attinenza data da MySQL. Ecco come potrebbe essere il risultato della query precedente:

titolo

descrizione

attinenza

Rilasciato MySQL 4.0.16

Il database Open Source più utilizzato si aggiorna

7.212370387556

Disponibile MySQL 4.0.15

Nuova versione di bug fix di uno dei DBMS più usati al mondo

7.0089304929524

MySQL disponibile su IBM eServer zSeries

Il database open Source è ora configurabile anche su IBM eServer zSeries con Linux installato

6.1195414142892

MySQL ora è più potente

Una nuova e importante caratteristica di MySQL è il pieno supporto delle transazioni per applicativi di e-commerce

5.233245521266

Rilasciato MySQL 4.0.11

Disponibile per il download la nuova versione del popolare database

4.86869959964

Vulnerabilità nel database MySQL

Grave problema di sicurezza all'interno del più utilizzato database open source

3.8611711513829

Rilasciato phpMyAdmin 2.5.4

Il programma che interagisce con il database MySQL si aggiorna

3.6027420458677

Rilasciato JMyAdmin 0.7

Il team di sviluppo di JMyAdmin, il sistema web based di gestione di MySql open source italiano, ha rilasciato la nuova versione

3.4924819304996

Nuova falla di sicurezza in Phpbb

Uno dei più apprezzati forum Open Source soffre di una delicata vulnerabilità

2.4627044551326

Rilasciato YaBB SE 1.5.2: si consiglia l'aggiornamento immediato

Uno dei più apprezzati Forum per siti Web, si aggiorna e ripara a diverse falle di sicurezza

2.254412718088

Questo sistema di query Full text può esserci molto utile se volessimo ordinare i risultati di una ricerca in base alla rilevanza di una parola, proprio come fanno i motori di ricerca più blasonati, che ordinano le varie pagine trovate in base a degli algoritmi propri.

Più nello specifico: query Full Text meglio definite

MySQL 4.0.1 e successivi è in grado di scendere ancora più nello specifico ed effettuare delle ricerche con gli operatori logici che utilizzano i motori di ricerca. Torniamo alla sintassi SQL di prima e ammettiamo di voler cercare solo quei records che contengono la parola MySQL ma non PhpMyAdmin. Ecco come si può fare:

SELECT titolo,descrizione, MATCH(titolo,testo) AGAINST('+mysql -phpmyadmin' IN BOOLEAN MODE) AS attinenza FROM notizie WHERE MATCH(titolo,testo) AGAINST('+mysql -phpmyadmin' IN BOOLEAN MODE) ORDER BY attinenza DESC

Vediamo ora tutti i casi e gli operatori utili nelle ricerche FullText:

mysql phpmyadmin:

Trova uno dei termini nei campi specificati

+mysql +phpmyadmin:

Nella ricerca, dovranno essere presenti entrambi i campi

+mysql phpmyadmin:

Seleziona i campi con entrambe le parole, ma assegna un'attinenza maggiore al termine premesso da +

+mysql -phpmyadmin:

Cerca i campi che contengono mysql ma non phpmyadmin

+mysql +(>sql <php):

Trova mysql con sql o mysql con php ma assegna un'attinenza maggiore a mysql con sql piuttosto che a mysql con php

my*:

Estrarrà tutti i campi che contengono il termine my seguito da altri caratteri. Come mysql, myadmin, myodbc ecc.

"query mysql":

Troverà termini come "query mysql con phpmyadmin" ma non "query SQL con mysql su phpmyadmin". Ciò significa che, includendo i termini tra virgolette, si vuole che la ricerca venga effettuata sulla esatta posizione delle due o più parole.