MySQL - Guida rapida

Cos'è un database?

Un database è un'applicazione separata che memorizza una raccolta di dati. Ogni database dispone di una o più API distinte per la creazione, l'accesso, la gestione, la ricerca e la replica dei dati in esso contenuti.

È possibile utilizzare anche altri tipi di archivi dati, come file nel file system o tabelle hash di grandi dimensioni in memoria, ma il recupero e la scrittura dei dati non sarebbero così rapidi e facili con questi tipi di sistemi.

Al giorno d'oggi, utilizziamo sistemi di gestione di database relazionali (RDBMS) per archiviare e gestire enormi volumi di dati. Questo è chiamato database relazionale perché tutti i dati vengono memorizzati in tabelle diverse e le relazioni vengono stabilite utilizzando chiavi primarie o altre chiavi note comeForeign Keys.

UN Relational DataBase Management System (RDBMS) è un software che -

• Consente di implementare un database con tabelle, colonne e indici.

• Garantisce l'integrità referenziale tra le righe di varie tabelle.

• Aggiorna automaticamente gli indici.

• Interpreta una query SQL e combina le informazioni di varie tabelle.

Terminologia RDBMS

Prima di procedere alla spiegazione del sistema di database MySQL, rivediamo alcune definizioni relative al database.

• Database - Un database è una raccolta di tabelle, con dati correlati.

• Table- Una tabella è una matrice con dati. Una tabella in un database ha l'aspetto di un semplice foglio di calcolo.

• Column - Una colonna (elemento dati) contiene dati dello stesso tipo, ad esempio il codice postale della colonna.

• Row - Una riga (= tupla, voce o record) è un gruppo di dati correlati, ad esempio i dati di una sottoscrizione.

• Redundancy - Memorizzazione dei dati due volte, in modo ridondante per rendere il sistema più veloce.

• Primary Key- Una chiave primaria è unica. Un valore chiave non può essere presente due volte in una tabella. Con una chiave, puoi trovare solo una riga.

• Foreign Key - Una chiave esterna è il perno di collegamento tra due tabelle.

• Compound Key - Una chiave composta (chiave composita) è una chiave costituita da più colonne, perché una colonna non è sufficientemente unica.

• Index - Un indice in un database assomiglia a un indice sul retro di un libro.

• Referential Integrity - L'integrità referenziale garantisce che un valore di chiave esterna punti sempre a una riga esistente.

Database MySQL

MySQL è un RDBMS veloce e facile da usare utilizzato da molte piccole e grandi aziende. MySQL è sviluppato, commercializzato e supportato da MySQL AB, una società svedese. MySQL sta diventando così popolare a causa di molte buone ragioni:

• MySQL è rilasciato con una licenza open source. Quindi non hai nulla da pagare per usarlo.

• MySQL è un programma molto potente a sé stante. Gestisce un ampio sottoinsieme delle funzionalità dei pacchetti di database più costosi e potenti.

• MySQL utilizza una forma standard del noto linguaggio di dati SQL.

• MySQL funziona su molti sistemi operativi e con molti linguaggi inclusi PHP, PERL, C, C ++, JAVA, ecc.

• MySQL funziona molto rapidamente e funziona bene anche con grandi set di dati.

• MySQL è molto amichevole con PHP, il linguaggio più apprezzato per lo sviluppo web.

• MySQL supporta database di grandi dimensioni, fino a 50 milioni di righe o più in una tabella. Il limite di dimensione file predefinito per una tabella è 4 GB, ma puoi aumentarlo (se il tuo sistema operativo è in grado di gestirlo) fino a un limite teorico di 8 milioni di terabyte (TB).

• MySQL è personalizzabile. La licenza GPL open source consente ai programmatori di modificare il software MySQL per adattarlo ai propri ambienti specifici.

Prima di iniziare

Prima di iniziare questo tutorial, dovresti avere una conoscenza di base delle informazioni trattate nei nostri tutorial PHP e HTML.

Questo tutorial si concentra principalmente sull'utilizzo di MySQL in un ambiente PHP. Molti esempi forniti in questo tutorial saranno utili per i programmatori PHP.

Ti consigliamo di controllare il nostro tutorial PHP come riferimento.

Tutti i download per MySQL si trovano in Download di MySQL . Scegli il numero di versione diMySQL Community Server che è richiesto insieme alla piattaforma su cui verrà eseguito.

Installazione di MySQL su Linux / UNIX

Il modo consigliato per installare MySQL su un sistema Linux è tramite RPM. MySQL AB rende i seguenti RPM disponibili per il download sul proprio sito Web:

• MySQL - Il server database MySQL gestisce i database e le tabelle, controlla l'accesso degli utenti ed elabora le query SQL.

• MySQL-client - Programmi client MySQL, che consentono di connettersi e interagire con il server.

• MySQL-devel - Librerie e file di intestazione che tornano utili durante la compilazione di altri programmi che utilizzano MySQL.

• MySQL-shared - Librerie condivise per il client MySQL.

• MySQL-bench - Strumenti di benchmark e test delle prestazioni per il server di database MySQL.

Gli RPM MySQL elencati qui sono tutti basati su un file SuSE Linux system, ma di solito funzionano su altre varianti di Linux senza difficoltà.

Ora, dovrai seguire i passaggi indicati di seguito, per procedere con l'installazione -

• Accedi al sistema utilizzando il root utente.

• Passa alla directory contenente gli RPM.

• Installa il server di database MySQL eseguendo il seguente comando. Ricorda di sostituire il nome del file in corsivo con il nome del file del tuo RPM.

[root@host]# rpm -i MySQL-5.0.9-0.i386.rpm

Il comando precedente si occupa di installare il server MySQL, creare un utente di MySQL, creare la configurazione necessaria e avviare automaticamente il server MySQL.

Puoi trovare tutti i binari relativi a MySQL in / usr / bin e / usr / sbin. Tutte le tabelle e i database verranno creati nella directory / var / lib / mysql.

La casella del codice seguente ha un passaggio facoltativo ma consigliato per installare gli RPM rimanenti nello stesso modo:

[root@host]# rpm -i MySQL-client-5.0.9-0.i386.rpm
[root@host]# rpm -i MySQL-devel-5.0.9-0.i386.rpm
[root@host]# rpm -i MySQL-shared-5.0.9-0.i386.rpm
[root@host]# rpm -i MySQL-bench-5.0.9-0.i386.rpm

Installazione di MySQL su Windows

L'installazione predefinita su qualsiasi versione di Windows è ora molto più semplice di prima, poiché MySQL ora viene fornito in modo ordinato con un programma di installazione. Basta scaricare il pacchetto di installazione, decomprimerlo ovunque ed eseguire il file setup.exe.

Il programma di installazione predefinito setup.exe ti guiderà attraverso il processo banale e per impostazione predefinita installerà tutto in C: \ mysql.

Testare il server avviandolo per la prima volta dal prompt dei comandi. Vai alla posizione del filemysqld server che è probabilmente C: \ mysql \ bin e digita -

mysqld.exe --console

NOTE - Se sei su NT, dovrai usare mysqld-nt.exe invece di mysqld.exe

Se tutto è andato bene, vedrai alcuni messaggi sull'avvio e InnoDB. In caso contrario, potresti avere un problema di autorizzazioni. Assicurati che la directory che contiene i tuoi dati sia accessibile a qualsiasi utente (probabilmente MySQL) con cui vengono eseguiti i processi del database.

MySQL non si aggiungerà al menu di avvio e non esiste nemmeno un modo GUI particolarmente carino per arrestare il server. Pertanto, se si tende ad avviare il server facendo doppio clic sull'eseguibile mysqld, è necessario ricordarsi di interrompere manualmente il processo utilizzando mysqladmin, Elenco attività, Gestione attività o altri mezzi specifici di Windows.

Verifica dell'installazione di MySQL

Dopo che MySQL è stato installato con successo, le tabelle di base sono state inizializzate e il server è stato avviato: puoi verificare che tutto funzioni come dovrebbe tramite alcuni semplici test.

Usa l'utility mysqladmin per ottenere lo stato del server

Uso mysqladminbinario per controllare la versione del server. Questo binario sarebbe disponibile in / usr / bin su Linux e in C: \ mysql \ bin su Windows.

[root@host]# mysqladmin --version

Produrrà il seguente risultato su Linux. Può variare a seconda dell'installazione -

mysqladmin  Ver 8.23 Distrib 5.0.9-0, for redhat-linux-gnu on i386

Se non ricevi un messaggio del genere, potrebbe esserci qualche problema nella tua installazione e potresti aver bisogno di aiuto per risolverlo.

Esegui semplici comandi SQL utilizzando il client MySQL

Puoi connetterti al tuo server MySQL tramite il client MySQL e utilizzando il mysqlcomando. In questo momento, non è necessario fornire alcuna password in quanto per impostazione predefinita sarà vuota.

Puoi semplicemente usare il seguente comando:

[root@host]# mysql

Dovrebbe essere ricompensato con un prompt mysql>. Ora sei connesso al server MySQL e puoi eseguire tutti i comandi SQL al prompt mysql> come segue:

mysql> SHOW DATABASES;
+----------+
| Database |
+----------+
|   mysql  | 
|   test   |  
+----------+
2 rows in set (0.13 sec)

Passaggi post-installazione

MySQL viene fornito con una password vuota per l'utente MySQL root. Non appena hai installato correttamente il database e il client, devi impostare una password di root come indicato nel seguente blocco di codice:

[root@host]# mysqladmin -u root password "new_password";

Ora per effettuare una connessione al tuo server MySQL, dovresti usare il seguente comando:

[root@host]# mysql -u root -p
Enter password:*******

Gli utenti UNIX vorranno anche inserire la directory MySQL nel PATH, in modo da non dover continuare a digitare il percorso completo ogni volta che si desidera utilizzare il client della riga di comando.

Per bash, sarebbe qualcosa del tipo -

export PATH = $PATH:/usr/bin:/usr/sbin

Esecuzione di MySQL all'avvio

Se vuoi eseguire il server MySQL all'avvio, assicurati di avere la seguente voce nel file /etc/rc.local.

/etc/init.d/mysqld start

Inoltre, dovresti avere il binario mysqld nella directory /etc/init.d/.

Esecuzione e chiusura di MySQL Server

Innanzitutto controlla se il tuo server MySQL è in esecuzione o meno. Puoi usare il seguente comando per controllarlo:

ps -ef | grep mysqld

Se il tuo MySql è in esecuzione, vedrai mysqldprocesso elencato nel risultato. Se il server non è in esecuzione, è possibile avviarlo utilizzando il seguente comando:

root@host# cd /usr/bin
./safe_mysqld &

Ora, se vuoi chiudere un server MySQL già in esecuzione, puoi farlo usando il seguente comando:

root@host# cd /usr/bin
./mysqladmin -u root -p shutdown
Enter password: ******

Configurazione di un account utente MySQL

Per aggiungere un nuovo utente a MySQL, è sufficiente aggiungere una nuova voce al file user tabella nel database mysql.

Il seguente programma è un esempio di aggiunta di un nuovo utente guest con i privilegi SELECT, INSERT e UPDATE con la password guest123; la query SQL è -

root@host# mysql -u root -p
Enter password:*******
mysql> use mysql;
Database changed

mysql> INSERT INTO user 
   (host, user, password, 
   select_priv, insert_priv, update_priv) 
   VALUES ('localhost', 'guest', 
   PASSWORD('guest123'), 'Y', 'Y', 'Y');
Query OK, 1 row affected (0.20 sec)

mysql> FLUSH PRIVILEGES;
Query OK, 1 row affected (0.01 sec)

mysql> SELECT host, user, password FROM user WHERE user = 'guest';
+-----------+---------+------------------+
|    host   |   user  |     password     |    
+-----------+---------+------------------+
| localhost |  guest  | 6f8c114b58f2ce9e |
+-----------+---------+------------------+
1 row in set (0.00 sec)

Quando si aggiunge un nuovo utente, ricordarsi di crittografare la nuova password utilizzando la funzione PASSWORD () fornita da MySQL. Come puoi vedere nell'esempio sopra, la password mypass è crittografata con 6f8c114b58f2ce9e.

Notare la dichiarazione FLUSH PRIVILEGES. Questo dice al server di ricaricare le tabelle di concessione. Se non lo usi, non sarai in grado di connetterti a MySQL utilizzando il nuovo account utente almeno fino a quando il server non verrà riavviato.

È inoltre possibile specificare altri privilegi per un nuovo utente impostando i valori delle seguenti colonne nella tabella utente su "Y" durante l'esecuzione della query INSERT oppure è possibile aggiornarli in seguito utilizzando la query UPDATE.

• Select_priv
• Insert_priv
• Update_priv
• Delete_priv
• Create_priv
• Drop_priv
• Reload_priv
• Shutdown_priv
• Process_priv
• File_priv
• Grant_priv
• References_priv
• Index_priv
• Alter_priv

Un altro modo per aggiungere un account utente è utilizzare il comando GRANT SQL. Il seguente esempio aggiungerà userzara con password zara123 per un database particolare, denominato TUTORIALS.

root@host# mysql -u root -p password;
Enter password:*******
mysql> use mysql;
Database changed

mysql> GRANT SELECT,INSERT,UPDATE,DELETE,CREATE,DROP
   -> ON TUTORIALS.*
   -> TO 'zara'@'localhost'
   -> IDENTIFIED BY 'zara123';

Questo creerà anche una voce nella tabella del database MySQL chiamata come user.

NOTE - MySQL non termina un comando fino a quando non si inserisce un punto e virgola (;) alla fine del comando SQL.

La configurazione del file /etc/my.cnf

Nella maggior parte dei casi, non dovresti toccare questo file. Per impostazione predefinita, avrà le seguenti voci:

[mysqld]
datadir = /var/lib/mysql
socket = /var/lib/mysql/mysql.sock

[mysql.server]
user = mysql
basedir = /var/lib

[safe_mysqld]
err-log = /var/log/mysqld.log
pid-file = /var/run/mysqld/mysqld.pid

Qui puoi specificare una directory diversa per il registro degli errori, altrimenti non dovresti cambiare nessuna voce in questa tabella.

Comando amministrativo MySQL

Ecco l'elenco degli importanti comandi MySQL, che utilizzerai di volta in volta per lavorare con il database MySQL:

• USE Databasename - Questo verrà utilizzato per selezionare un database nell'area di lavoro MySQL.

• SHOW DATABASES - Elenca i database accessibili dal DBMS MySQL.

• SHOW TABLES - Mostra le tabelle nel database una volta che un database è stato selezionato con il comando use.

• SHOW COLUMNS FROM tablename: Mostra gli attributi, i tipi di attributi, le informazioni sulla chiave, se NULL è consentito, i valori predefiniti e altre informazioni per una tabella.

• SHOW INDEX FROM tablename - Presenta i dettagli di tutti gli indici sulla tabella, inclusa la CHIAVE PRIMARIA.

• SHOW TABLE STATUS LIKE tablename\G - Riporta i dettagli delle prestazioni e delle statistiche del DBMS MySQL.

Nel prossimo capitolo, discuteremo di come viene utilizzata la sintassi PHP in MySQL.

MySQL funziona molto bene in combinazione di vari linguaggi di programmazione come PERL, C, C ++, JAVA e PHP. Di questi linguaggi, PHP è il più popolare grazie alle sue capacità di sviluppo di applicazioni web.

Questo tutorial si concentra principalmente sull'utilizzo di MySQL in un ambiente PHP. Se sei interessato a MySQL con PERL, puoi prendere in considerazione la lettura del tutorial PERL .

PHP fornisce varie funzioni per accedere al database MySQL e per manipolare i record di dati all'interno del database MySQL. Dovresti chiamare le funzioni PHP nello stesso modo in cui chiami qualsiasi altra funzione PHP.

Le funzioni PHP da utilizzare con MySQL hanno il seguente formato generale:

mysql_function(value,value,...);

La seconda parte del nome della funzione è specifica della funzione, di solito una parola che descrive ciò che fa la funzione. Le seguenti sono due delle funzioni, che useremo nel nostro tutorial:

mysqli_connect($connect);
mysqli_query($connect,"SQL statement");

L'esempio seguente mostra una sintassi generica di PHP per chiamare qualsiasi funzione MySQL.

<html>
   <head>
      <title>PHP with MySQL</title>
   </head>
   
   <body>
      <?php
         $retval = mysql_function(value, [value,...]);
         if( !$retval ) {
            die ( "Error: a related error message" );
         }
         // Otherwise MySQL  or PHP Statements
      ?>
   </body>
</html>

A partire dal prossimo capitolo, vedremo tutte le importanti funzionalità di MySQL insieme a PHP.

Connessione MySQL tramite MySQL Binary

È possibile stabilire il database MySQL utilizzando il mysql binario al prompt dei comandi.

Esempio

Ecco un semplice esempio per connettersi al server MySQL dal prompt dei comandi:

[root@host]# mysql -u root -p
Enter password:******

Questo ti darà il prompt dei comandi mysql> dove sarai in grado di eseguire qualsiasi comando SQL. Di seguito è riportato il risultato del comando precedente:

Il seguente blocco di codice mostra il risultato del codice precedente:

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 2854760 to server version: 5.0.9

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

Nell'esempio sopra, abbiamo usato rootcome utente ma puoi usare anche qualsiasi altro utente. Qualsiasi utente sarà in grado di eseguire tutte le operazioni SQL consentite a quell'utente.

Puoi disconnetterti dal database MySQL in qualsiasi momento utilizzando il exit comando a mysql> prompt.

mysql> exit
Bye

Connessione MySQL tramite script PHP

PHP fornisce mysql_connect()funzione per aprire una connessione al database. Questa funzione accetta cinque parametri e restituisce un identificatore di collegamento MySQL in caso di successo o FALSE in caso di fallimento.

Sintassi

connection mysql_connect(server,user,passwd,new_link,client_flag);

Sr.No.	Parametro e descrizione
1	server Facoltativo: il nome host che esegue il server di database. Se non specificato, il valore predefinito saràlocalhost:3306.
2	user Facoltativo: il nome utente che accede al database. Se non specificato, il valore predefinito sarà il nome dell'utente che possiede il processo del server.
3	passwd Facoltativo: la password dell'utente che accede al database. Se non specificato, l'impostazione predefinita sarà una password vuota.
4	new_link Opzionale - Se viene effettuata una seconda chiamata a mysql_connect () con gli stessi argomenti, non verrà stabilita alcuna nuova connessione; invece, verrà restituito l'identificativo della connessione già aperta.
5	client_flags Facoltativo: una combinazione delle seguenti costanti MYSQL_CLIENT_SSL: utilizza la crittografia SSL. MYSQL_CLIENT_COMPRESS: utilizza il protocollo di compressione. MYSQL_CLIENT_IGNORE_SPACE - Consenti spazio dopo i nomi delle funzioni. MYSQL_CLIENT_INTERACTIVE - Consenti secondi di timeout interattivo di inattività prima di chiudere la connessione.

Puoi disconnetterti dal database MySQL in qualsiasi momento utilizzando un'altra funzione PHP mysql_close(). Questa funzione accetta un singolo parametro, che è una connessione restituita damysql_connect() funzione.

Sintassi

bool mysql_close ( resource $link_identifier );

Se una risorsa non viene specificata, viene chiuso l'ultimo database aperto. Questa funzione restituisce true se chiude correttamente la connessione, altrimenti restituisce false.

Esempio

Prova il seguente esempio per connetterti a un server MySQL:

<html>
   <head>
      <title>Connecting MySQL Server</title>
   </head>
   <body>
      <?php
         $dbhost = 'localhost:3306'; $dbuser = 'guest';
         $dbpass = 'guest123'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
            die('Could not connect: ' . mysql_error());
         }
         echo 'Connected successfully';
         mysql_close($conn);
      ?>
   </body>
</html>

Crea database usando mysqladmin

Avresti bisogno di privilegi speciali per creare o eliminare un database MySQL. Quindi, supponendo che tu abbia accesso all'utente root, puoi creare qualsiasi database usando mysqlmysqladmin binario.

Esempio

Ecco un semplice esempio per creare un database chiamato TUTORIALS -

[root@host]# mysqladmin -u root -p create TUTORIALS
Enter password:******

Questo creerà un database MySQL chiamato TUTORIAL.

Crea un database usando PHP Script

PHP utilizza mysql_queryfunzione per creare o eliminare un database MySQL. Questa funzione accetta due parametri e restituisce TRUE in caso di successo o FALSE in caso di fallimento.

Sintassi

bool mysql_query( sql, connection );

Sr.No.	Parametro e descrizione
1	sql Obbligatorio: query SQL per creare o eliminare un database MySQL
2	connection Facoltativo: se non specificato, verrà utilizzata l'ultima connessione aperta da mysql_connect.

Esempio

Il seguente esempio per creare un database:

<html>
   <head>
      <title>Creating MySQL Database</title>
   </head>
   
   <body>
      <?php
         $dbhost = 'localhost:3036';
         $dbuser = 'root'; $dbpass = 'rootpassword';
         $conn = mysql_connect($dbhost, $dbuser, $dbpass);
         
         if(! $conn ) { die('Could not connect: ' . mysql_error()); } echo 'Connected successfully<br />'; $sql = 'CREATE DATABASE TUTORIALS';
         $retval = mysql_query( $sql, $conn ); if(! $retval ) {
            die('Could not create database: ' . mysql_error());
         }
         echo "Database TUTORIALS created successfully\n";
         mysql_close($conn);
      ?>
   </body>
</html>

Rilascia un database utilizzando mysqladmin

Avresti bisogno di privilegi speciali per creare o eliminare un database MySQL. Quindi, supponendo che tu abbia accesso all'utente root, puoi creare qualsiasi database usando mysqlmysqladmin binario.

Fai attenzione durante l'eliminazione di qualsiasi database perché perderai tutti i dati disponibili nel tuo database.

Ecco un esempio per eliminare un database (TUTORIAL) creato nel capitolo precedente:

[root@host]# mysqladmin -u root -p drop TUTORIALS
Enter password:******

Questo ti darà un avviso e confermerà se vuoi davvero eliminare questo database o meno.

Dropping the database is potentially a very bad thing to do.
Any data stored in the database will be destroyed.

Do you really want to drop the 'TUTORIALS' database [y/N] y
Database "TUTORIALS" dropped

Elimina database utilizzando PHP Script

PHP utilizza mysql_queryfunzione per creare o eliminare un database MySQL. Questa funzione accetta due parametri e restituisce TRUE in caso di successo o FALSE in caso di fallimento.

Sintassi

bool mysql_query( sql, connection );

Suor n	Parametro e descrizione
1	sql Obbligatorio: query SQL per creare o eliminare un database MySQL
2	connection Facoltativo: se non specificato, verrà utilizzata l'ultima connessione aperta da mysql_connect.

Esempio

Prova il seguente esempio per eliminare un database:

<html>
   <head>
      <title>Deleting MySQL Database</title>
   </head>
   
   <body>
      <?php
         $dbhost = 'localhost:3036';
         $dbuser = 'root'; $dbpass = 'rootpassword';
         $conn = mysql_connect($dbhost, $dbuser, $dbpass);
         
         if(! $conn ) { die('Could not connect: ' . mysql_error()); } echo 'Connected successfully<br />'; $sql = 'DROP DATABASE TUTORIALS';
         $retval = mysql_query( $sql, $conn ); if(! $retval ) {
            die('Could not delete database: ' . mysql_error());
         }
         echo "Database TUTORIALS deleted successfully\n";
         mysql_close($conn);
      ?>
   </body>
</html>

WARNING- Durante l'eliminazione di un database utilizzando lo script PHP, non richiede alcuna conferma. Quindi fai attenzione durante l'eliminazione di un database MySQL.

Dopo esserti connesso al server MySQL, è necessario selezionare un database con cui lavorare. Questo perché potrebbe esserci più di un database disponibile con MySQL Server.

Selezione del database MySQL dal prompt dei comandi

È molto semplice selezionare un database dal prompt mysql>. Puoi usare il comando SQLuse per selezionare un database.

Esempio

Ecco un esempio per selezionare un database chiamato TUTORIALS -

[root@host]# mysql -u root -p
Enter password:******
mysql> use TUTORIALS;
Database changed
mysql>

Ora hai selezionato il database TUTORIAL e tutte le operazioni successive verranno eseguite sul database TUTORIALS.

NOTE- Tutti i nomi dei database, i nomi delle tabelle, i nomi dei campi delle tabelle fanno distinzione tra maiuscole e minuscole. Quindi dovresti usare i nomi corretti mentre dai qualsiasi comando SQL.

Selezione di un database MySQL tramite script PHP

PHP fornisce la funzione mysql_select_dbper selezionare un database. Restituisce TRUE in caso di successo o FALSE in caso di fallimento.

Sintassi

bool mysql_select_db( db_name, connection );

Sr.No.	Parametro e descrizione
1	db_name Obbligatorio: selezionare il nome del database MySQL
2	connection Facoltativo: se non specificato, verrà utilizzata l'ultima connessione aperta da mysql_connect.

Esempio

Ecco un esempio che mostra come selezionare un database.

<html>
   <head>
      <title>Selecting MySQL Database</title>
   </head>
   
   <body>
      <?php
         $dbhost = 'localhost:3036';
         $dbuser = 'guest'; $dbpass = 'guest123';
         $conn = mysql_connect($dbhost, $dbuser, $dbpass);
         
         if(! $conn ) { die('Could not connect: ' . mysql_error()); } echo 'Connected successfully'; mysql_select_db( 'TUTORIALS' ); mysql_close($conn);
      ?>
   </body>
</html>

La definizione corretta dei campi in una tabella è importante per l'ottimizzazione complessiva del database. Dovresti usare solo il tipo e la dimensione del campo che devi veramente usare. Ad esempio, non definire un campo largo 10 caratteri, se sai che utilizzerai solo 2 caratteri. Questi tipi di campi (o colonne) vengono anche denominati tipi di dati, dopotype of data immagazzinerete in quei campi.

MySQL utilizza molti diversi tipi di dati suddivisi in tre categorie:

• Numeric
• Data e ora
• Tipi di stringa.

Vediamoli ora in dettaglio.

Tipi di dati numerici

MySQL utilizza tutti i tipi di dati numerici ANSI SQL standard, quindi se vieni a MySQL da un sistema di database diverso, queste definizioni ti sembreranno familiari.

Il seguente elenco mostra i tipi di dati numerici comuni e le loro descrizioni:

• INT- Un numero intero di dimensioni normali che può essere firmato o non firmato. Se firmato, l'intervallo consentito è compreso tra -2147483648 e 2147483647. Se non firmato, l'intervallo consentito è compreso tra 0 e 4294967295. È possibile specificare una larghezza fino a 11 cifre.

• TINYINT- Un numero intero molto piccolo che può essere firmato o non firmato. Se firmato, l'intervallo consentito è compreso tra -128 e 127. Se non firmato, l'intervallo consentito è compreso tra 0 e 255. È possibile specificare una larghezza fino a 4 cifre.

• SMALLINT- Un piccolo numero intero che può essere firmato o non firmato. Se firmato, l'intervallo consentito è compreso tra -32768 e 32767. Se non firmato, l'intervallo consentito è compreso tra 0 e 65535. È possibile specificare una larghezza fino a 5 cifre.

• MEDIUMINT- Un numero intero di medie dimensioni che può essere firmato o non firmato. Se firmato, l'intervallo consentito è compreso tra -8388608 e 8388607. Se non firmato, l'intervallo consentito è compreso tra 0 e 16777215. È possibile specificare una larghezza fino a 9 cifre.

• BIGINT- Un numero intero grande che può essere firmato o non firmato. Se firmato, l'intervallo consentito va da -9223372036854775808 a 9223372036854775807. Se non firmato, l'intervallo consentito è compreso tra 0 e 18446744073709551615. È possibile specificare una larghezza fino a 20 cifre.

• FLOAT(M,D)- Un numero a virgola mobile che non può essere annullato. È possibile definire la lunghezza del display (M) e il numero di decimali (D). Questo non è richiesto e verrà impostato automaticamente su 10,2, dove 2 è il numero di decimali e 10 è il numero totale di cifre (inclusi i decimali). La precisione decimale può arrivare a 24 posizioni per un FLOAT.

• DOUBLE(M,D)- Un numero a virgola mobile a doppia precisione che non può essere deselezionato. È possibile definire la lunghezza del display (M) e il numero di decimali (D). Questo non è richiesto e il valore predefinito sarà 16,4, dove 4 è il numero di decimali. La precisione decimale può arrivare a 53 posizioni per un DOPPIO. REAL è sinonimo di DOPPIO.

• DECIMAL(M,D)- Un numero a virgola mobile decompresso che non può essere rimosso. Nei decimali decompressi, ogni decimale corrisponde a un byte. È necessario definire la lunghezza del display (M) e il numero di decimali (D). NUMERIC è sinonimo di DECIMAL.

Tipi di data e ora

I tipi di dati di data e ora di MySQL sono i seguenti:

• DATE- Una data nel formato AAAA-MM-GG, tra 1000-01-01 e 9999-12-31. Ad esempio, 30 dicembre ^° 1973 sarebbe stato archiviato come 1973/12/30.

• DATETIME- Una combinazione di data e ora nel formato AAAA-MM-GG HH: MM: SS, tra 1000-01-01 00:00:00 e 9999-12-31 23:59:59. Ad esempio, 3:30 del pomeriggio del 30 dicembre ^° 1973 potrebbero essere memorizzati come 1973/12/30 15:30:00.

• TIMESTAMP- Un timestamp tra la mezzanotte, 1 gennaio ^st 1970 e qualche volta nel 2037. Questo appare come il formato DATETIME precedente, solo senza i trattini tra i numeri; 3:30 del pomeriggio del 30 dicembre ^° 1973 potrebbero essere memorizzati come 19.731,230153 miliardi (AAAAMMGGHHMMSS).

• TIME - Memorizza l'ora in un formato HH: MM: SS.

• YEAR(M)- Memorizza un anno in un formato a 2 o 4 cifre. Se la lunghezza è specificata come 2 (ad esempio YEAR (2)), YEAR può essere compresa tra 1970 e 2069 (70 e 69). Se la lunghezza è specificata come 4, YEAR può essere compreso tra 1901 e 2155. La lunghezza predefinita è 4.

Tipi di stringa

Sebbene i tipi numerici e di data siano divertenti, la maggior parte dei dati che memorizzerai sarà in un formato stringa. Questo elenco descrive i tipi di dati di stringa comuni in MySQL.

• CHAR(M)- Una stringa di lunghezza fissa compresa tra 1 e 255 caratteri (ad esempio CHAR (5)), riempita a destra con spazi fino alla lunghezza specificata quando memorizzata. Non è necessario definire una lunghezza, ma il valore predefinito è 1.

• VARCHAR(M)- Una stringa di lunghezza variabile compresa tra 1 e 255 caratteri. Ad esempio, VARCHAR (25). È necessario definire una lunghezza quando si crea un campo VARCHAR.

• BLOB or TEXT- Un campo con una lunghezza massima di 65535 caratteri. I BLOB sono "oggetti binari di grandi dimensioni" e vengono utilizzati per memorizzare grandi quantità di dati binari, come immagini o altri tipi di file. I campi definiti come TESTO contengono anche grandi quantità di dati. La differenza tra i due è che gli ordinamenti ei confronti sui dati memorizzati lo sonocase sensitive su BLOB e sono not case sensitivenei campi TESTO. Non si specifica una lunghezza con BLOB o TEXT.

• TINYBLOB or TINYTEXT- Una colonna BLOB o TEXT con una lunghezza massima di 255 caratteri. Non si specifica una lunghezza con TINYBLOB o TINYTEXT.

• MEDIUMBLOB or MEDIUMTEXT- Una colonna BLOB o TEXT con una lunghezza massima di 16777215 caratteri. Non si specifica una lunghezza con MEDIUMBLOB o MEDIUMTEXT.

• LONGBLOB or LONGTEXT- Una colonna BLOB o TEXT con una lunghezza massima di 4294967295 caratteri. Non si specifica una lunghezza con LONGBLOB o LONGTEXT.

• ENUM- Un'enumerazione, che è un termine di fantasia per la lista. Quando si definisce un ENUM, si crea un elenco di elementi da cui è necessario selezionare il valore (oppure può essere NULL). Ad esempio, se desideri che il tuo campo contenga "A" o "B" o "C", definiresti ENUM come ENUM ('A', 'B', 'C') e solo quei valori (o NULL) potrebbe mai popolare quel campo.

Nel prossimo capitolo, discuteremo come creare tabelle in MySQL.

Per cominciare, il comando di creazione della tabella richiede i seguenti dettagli:

• Nome della tabella
• Nome dei campi
• Definizioni per ogni campo

Sintassi

Ecco una sintassi SQL generica per creare una tabella MySQL:

CREATE TABLE table_name (column_name column_type);

Ora creeremo la seguente tabella nel file TUTORIALS Banca dati.

create table tutorials_tbl(
   tutorial_id INT NOT NULL AUTO_INCREMENT,
   tutorial_title VARCHAR(100) NOT NULL,
   tutorial_author VARCHAR(40) NOT NULL,
   submission_date DATE,
   PRIMARY KEY ( tutorial_id )
);

Qui, alcuni elementi richiedono una spiegazione:

• Attributo di campo NOT NULLviene utilizzato perché non vogliamo che questo campo sia NULL. Quindi, se un utente proverà a creare un record con un valore NULL, MySQL genererà un errore.

• Attributo di campo AUTO_INCREMENT dice a MySQL di andare avanti e di aggiungere il prossimo numero disponibile al campo id.

• Parola chiave PRIMARY KEYviene utilizzato per definire una colonna come chiave primaria. È possibile utilizzare più colonne separate da una virgola per definire una chiave primaria.

Creazione di tabelle dal prompt dei comandi

È facile creare una tabella MySQL dal prompt mysql>. Utilizzerai il comando SQLCREATE TABLE per creare una tabella.

Esempio

Ecco un esempio, che creerà tutorials_tbl -

root@host# mysql -u root -p
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> CREATE TABLE tutorials_tbl(
   -> tutorial_id INT NOT NULL AUTO_INCREMENT,
   -> tutorial_title VARCHAR(100) NOT NULL,
   -> tutorial_author VARCHAR(40) NOT NULL,
   -> submission_date DATE,
   -> PRIMARY KEY ( tutorial_id )
   -> );
Query OK, 0 rows affected (0.16 sec)
mysql>

NOTE - MySQL non termina un comando fino a quando non inserisci un punto e virgola (;) alla fine del comando SQL.

Creazione di tabelle utilizzando script PHP

Per creare una nuova tabella in qualsiasi database esistente è necessario utilizzare la funzione PHP mysql_query(). Passerai il suo secondo argomento con un comando SQL appropriato per creare una tabella.

Esempio

Il seguente programma è un esempio per creare una tabella utilizzando lo script PHP:

<html>
   <head>
      <title>Creating MySQL Tables</title>
   </head>
   
   <body>
      <?php
         $dbhost = 'localhost:3036'; $dbuser = 'root';
         $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
            die('Could not connect: ' . mysql_error());
         }
         echo 'Connected successfully<br />';
         $sql = "CREATE TABLE tutorials_tbl( ". "tutorial_id INT NOT NULL AUTO_INCREMENT, ". "tutorial_title VARCHAR(100) NOT NULL, ". "tutorial_author VARCHAR(40) NOT NULL, ". "submission_date DATE, ". "PRIMARY KEY ( tutorial_id )); "; mysql_select_db( 'TUTORIALS' ); $retval = mysql_query( $sql, $conn );
         
         if(! $retval ) { die('Could not create table: ' . mysql_error()); } echo "Table created successfully\n"; mysql_close($conn);
      ?>
   </body>
</html>

È molto facile eliminare una tabella MySQL esistente, ma è necessario prestare molta attenzione durante l'eliminazione di qualsiasi tabella esistente perché i dati persi non verranno recuperati dopo l'eliminazione di una tabella.

Sintassi

Ecco una sintassi SQL generica per eliminare una tabella MySQL:

DROP TABLE table_name ;

Eliminazione di tabelle dal prompt dei comandi

Per eliminare le tabelle dal prompt dei comandi, è necessario eseguire il comando SQL DROP TABLE al prompt mysql>.

Esempio

Il seguente programma è un esempio che elimina il file tutorials_tbl -

root@host# mysql -u root -p
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> DROP TABLE tutorials_tbl
Query OK, 0 rows affected (0.8 sec)
mysql>

Eliminazione di tabelle tramite script PHP

Per eliminare una tabella esistente in qualsiasi database, è necessario utilizzare la funzione PHP mysql_query(). Passerai il suo secondo argomento con un comando SQL appropriato per eliminare una tabella.

Esempio

<html>
   <head>
      <title>Creating MySQL Tables</title>
   </head>
   
   <body>
      <?php
         $dbhost = 'localhost:3036'; $dbuser = 'root';
         $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
            die('Could not connect: ' . mysql_error());
         }
         echo 'Connected successfully<br />';
         $sql = "DROP TABLE tutorials_tbl"; mysql_select_db( 'TUTORIALS' ); $retval = mysql_query( $sql, $conn );
         
         if(! $retval ) { die('Could not delete table: ' . mysql_error()); } echo "Table deleted successfully\n"; mysql_close($conn);
      ?>
   </body>
</html>

Per inserire dati in una tabella MySQL, è necessario utilizzare SQL INSERT INTOcomando. È possibile inserire dati nella tabella MySQL utilizzando il prompt mysql> o utilizzando qualsiasi script come PHP.

Sintassi

Ecco una sintassi SQL generica del comando INSERT INTO per inserire dati nella tabella MySQL:

INSERT INTO table_name ( field1, field2,...fieldN )
   VALUES
   ( value1, value2,...valueN );

Per inserire tipi di dati stringa, è necessario mantenere tutti i valori tra virgolette doppie o singole. Per esempio"value".

Inserimento di dati dal prompt dei comandi

Per inserire dati dal prompt dei comandi, utilizzeremo il comando SQL INSERT INTO per inserire i dati nella tabella MySQL tutorials_tbl.

Esempio

Il seguente esempio creerà 3 record in tutorials_tbl tavolo -

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed

mysql> INSERT INTO tutorials_tbl 
   ->(tutorial_title, tutorial_author, submission_date)
   ->VALUES
   ->("Learn PHP", "John Poul", NOW());
Query OK, 1 row affected (0.01 sec)

mysql> INSERT INTO tutorials_tbl
   ->(tutorial_title, tutorial_author, submission_date)
   ->VALUES
   ->("Learn MySQL", "Abdul S", NOW());
Query OK, 1 row affected (0.01 sec)

mysql> INSERT INTO tutorials_tbl
   ->(tutorial_title, tutorial_author, submission_date)
   ->VALUES
   ->("JAVA Tutorial", "Sanjay", '2007-05-06');
Query OK, 1 row affected (0.01 sec)
mysql>

NOTE- Notare che tutti i segni di freccia (->) non fanno parte del comando SQL. Indicano una nuova riga e vengono creati automaticamente dal prompt di MySQL premendo il tasto Invio senza inserire un punto e virgola alla fine di ogni riga del comando.

Nell'esempio sopra, non abbiamo fornito un tutorial_id perché al momento della creazione della tabella, avevamo dato l'opzione AUTO_INCREMENT per questo campo. Quindi MySQL si occupa di inserire questi ID automaticamente. Qui,NOW() è una funzione MySQL, che restituisce la data e l'ora correnti.

Inserimento di dati utilizzando uno script PHP

È possibile utilizzare lo stesso comando SQL INSERT INTO nella funzione PHP mysql_query() per inserire dati in una tabella MySQL.

Esempio

Questo esempio prenderà tre parametri dall'utente e li inserirà nella tabella MySQL -

<html>

   <head>
      <title>Add New Record in MySQL Database</title>
   </head>

   <body>
      <?php
         if(isset($_POST['add'])) { $dbhost = 'localhost:3036';
            $dbuser = 'root'; $dbpass = 'rootpassword';
            $conn = mysql_connect($dbhost, $dbuser, $dbpass);
         
            if(! $conn ) { die('Could not connect: ' . mysql_error()); } if(! get_magic_quotes_gpc() ) { $tutorial_title = addslashes ($_POST['tutorial_title']); $tutorial_author = addslashes ($_POST['tutorial_author']); } else { $tutorial_title = $_POST['tutorial_title']; $tutorial_author = $_POST['tutorial_author']; } $submission_date = $_POST['submission_date']; $sql = "INSERT INTO tutorials_tbl ".
               "(tutorial_title,tutorial_author, submission_date) "."VALUES ".
               "('$tutorial_title','$tutorial_author','$submission_date')"; mysql_select_db('TUTORIALS'); $retval = mysql_query( $sql, $conn );
         
            if(! $retval ) { die('Could not enter data: ' . mysql_error()); } echo "Entered data successfully\n"; mysql_close($conn);
         } else {
      ?>
   
      <form method = "post" action = "<?php $_PHP_SELF ?>">
         <table width = "600" border = "0" cellspacing = "1" cellpadding = "2">
            <tr>
               <td width = "250">Tutorial Title</td>
               <td>
                  <input name = "tutorial_title" type = "text" id = "tutorial_title">
               </td>
            </tr>
         
            <tr>
               <td width = "250">Tutorial Author</td>
               <td>
                  <input name = "tutorial_author" type = "text" id = "tutorial_author">
               </td>
            </tr>
         
            <tr>
               <td width = "250">Submission Date [   yyyy-mm-dd ]</td>
               <td>
                  <input name = "submission_date" type = "text" id = "submission_date">
               </td>
            </tr>
      
            <tr>
               <td width = "250"> </td>
               <td> </td>
            </tr>
         
            <tr>
               <td width = "250"> </td>
               <td>
                  <input name = "add" type = "submit" id = "add"  value = "Add Tutorial">
               </td>
            </tr>
         </table>
      </form>
   <?php
      }
   ?>
   </body>
</html>

Mentre si esegue un inserimento dati, è meglio usare la funzione get_magic_quotes_gpc()per verificare se la configurazione corrente per magic quote è impostata o meno. Se questa funzione restituisce false, utilizza la funzioneaddslashes() per aggiungere barre prima delle virgolette.

Puoi mettere molte convalide in giro per verificare se i dati inseriti sono corretti o meno e puoi intraprendere l'azione appropriata.

L'SQL SELECTviene utilizzato per recuperare i dati dal database MySQL. Puoi usare questo comando al prompt mysql> così come in qualsiasi script come PHP.

Sintassi

Ecco la sintassi SQL generica del comando SELECT per recuperare i dati dalla tabella MySQL -

SELECT field1, field2,...fieldN 
FROM table_name1, table_name2...
[WHERE Clause]
[OFFSET M ][LIMIT N]

• È possibile utilizzare una o più tabelle separate da virgola per includere varie condizioni utilizzando una clausola WHERE, ma la clausola WHERE è una parte facoltativa del comando SELECT.

• È possibile recuperare uno o più campi in un singolo comando SELECT.

• È possibile specificare asterisco (*) al posto dei campi. In questo caso, SELECT restituirà tutti i campi.

• È possibile specificare qualsiasi condizione utilizzando la clausola WHERE.

• È possibile specificare un offset utilizzando OFFSETda dove SELECT inizierà a restituire i record. Per impostazione predefinita, l'offset inizia da zero.

• Puoi limitare il numero di resi utilizzando il file LIMIT attributo.

Recupero dei dati da un prompt dei comandi

Questo utilizzerà il comando SQL SELECT per recuperare i dati dalla tabella MySQL tutorials_tbl.

Esempio

Il seguente esempio restituirà tutti i record da tutorials_tbl tavolo -

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> SELECT * from tutorials_tbl 
+-------------+----------------+-----------------+-----------------+
| tutorial_id | tutorial_title | tutorial_author | submission_date |
+-------------+----------------+-----------------+-----------------+
|           1 | Learn PHP      | John Poul       | 2007-05-21      |
|           2 | Learn MySQL    | Abdul S         | 2007-05-21      |
|           3 | JAVA Tutorial  | Sanjay          | 2007-05-21      |
+-------------+----------------+-----------------+-----------------+
3 rows in set (0.01 sec)

mysql>

Recupero dei dati utilizzando uno script PHP

È possibile utilizzare lo stesso comando SQL SELECT in una funzione PHP mysql_query(). Questa funzione viene utilizzata per eseguire il comando SQL e successivamente un'altra funzione PHPmysql_fetch_array()può essere utilizzato per recuperare tutti i dati selezionati. Questa funzione restituisce la riga come un array associativo, un array numerico o entrambi. Questa funzione restituisce FALSE se non ci sono più righe.

Il seguente programma è un semplice esempio che mostrerà come recuperare / visualizzare i record dal file tutorials_tbl tavolo.

Esempio

Il seguente blocco di codice visualizzerà tutti i record dalla tabella tutorials_tbl.

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);
   
   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'SELECT tutorial_id, tutorial_title, tutorial_author, submission_date FROM tutorials_tbl';

   mysql_select_db('TUTORIALS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not get data: ' . mysql_error());
   }
   
   while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) {
      echo "Tutorial ID :{$row['tutorial_id']} <br> ". "Title: {$row['tutorial_title']} <br> ".
         "Author: {$row['tutorial_author']} <br> ". "Submission Date : {$row['submission_date']} <br> ".
         "--------------------------------<br>";
   } 
   echo "Fetched data successfully\n";
   mysql_close($conn);
?>

Il contenuto delle righe viene assegnato alla variabile $ riga e i valori in quella riga vengono quindi stampati.

NOTE - Ricorda sempre di mettere le parentesi graffe quando vuoi inserire un valore di array direttamente in una stringa.

Nell'esempio sopra, la costante MYSQL_ASSOC viene utilizzato come secondo argomento della funzione PHP mysql_fetch_array(), in modo che restituisca la riga come un array associativo. Con un array associativo è possibile accedere al campo utilizzando il loro nome invece di utilizzare l'indice.

PHP fornisce un'altra funzione chiamata mysql_fetch_assoc(), che restituisce anche la riga come matrice associativa.

Esempio

Il seguente esempio per visualizzare tutti i record dalla tabella tutorial_tbl utilizzando la funzione mysql_fetch_assoc ().

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }
   
   $sql = 'SELECT tutorial_id, tutorial_title, tutorial_author, submission_date FROM tutorials_tbl'; mysql_select_db('TUTORIALS'); $retval = mysql_query( $sql, $conn );
   
   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_assoc($retval)) { echo "Tutorial ID :{$row['tutorial_id']}  <br> ".
         "Title: {$row['tutorial_title']} <br> ". "Author: {$row['tutorial_author']} <br> ".
         "Submission Date : {$row['submission_date']} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

Puoi anche usare la costante MYSQL_NUMcome secondo argomento della funzione PHP mysql_fetch_array (). Ciò farà sì che la funzione restituisca un array con l'indice numerico.

Esempio

Prova il seguente esempio per visualizzare tutti i record dalla tabella tutorials_tbl utilizzando l'argomento MYSQL_NUM.

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }
   
   $sql = 'SELECT tutorial_id, tutorial_title, tutorial_author, submission_date FROM tutorials_tbl'; mysql_select_db('TUTORIALS'); $retval = mysql_query( $sql, $conn );
   
   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_NUM)) { echo "Tutorial ID :{$row[0]}  <br> ".
         "Title: {$row[1]} <br> ". "Author: {$row[2]} <br> ".
         "Submission Date : {$row[3]} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

Tutti i tre esempi precedenti produrranno lo stesso risultato.

Liberare la memoria

È buona norma rilasciare la memoria del cursore alla fine di ogni istruzione SELECT. Questo può essere fatto usando la funzione PHPmysql_free_result(). Il seguente programma è un esempio per mostrare come dovrebbe essere utilizzato.

Esempio

Prova il seguente esempio:

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }
   
   $sql = 'SELECT tutorial_id, tutorial_title, tutorial_author, submission_date FROM tutorials_tbl'; mysql_select_db('TUTORIALS'); $retval = mysql_query( $sql, $conn );
   
   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_NUM)) { echo "Tutorial ID :{$row[0]}  <br> ".
         "Title: {$row[1]} <br> ". "Author: {$row[2]} <br> ".
         "Submission Date : {$row[3]} <br> ". "--------------------------------<br>"; } mysql_free_result($retval);
   echo "Fetched data successfully\n";
   mysql_close($conn);
?>

Durante il recupero dei dati, puoi scrivere un codice complesso come preferisci, ma la procedura rimarrà la stessa di cui sopra.

Abbiamo visto l'SQL SELECTcomando per recuperare i dati da una tabella MySQL. Possiamo usare una clausola condizionale chiamataWHERE Clauseper filtrare i risultati. Utilizzando questa clausola WHERE, possiamo specificare un criterio di selezione per selezionare i record richiesti da una tabella.

Sintassi

Il seguente blocco di codice ha una sintassi SQL generica del comando SELECT con la clausola WHERE per recuperare i dati dalla tabella MySQL -

SELECT field1, field2,...fieldN table_name1, table_name2...
[WHERE condition1 [AND [OR]] condition2.....

• È possibile utilizzare una o più tabelle separate da una virgola per includere varie condizioni utilizzando una clausola WHERE, ma la clausola WHERE è una parte facoltativa del comando SELECT.

• È possibile specificare qualsiasi condizione utilizzando la clausola WHERE.

• È possibile specificare più di una condizione utilizzando il file AND o il OR operatori.

• Una clausola WHERE può essere utilizzata insieme al comando SQL DELETE o UPDATE anche per specificare una condizione.

Il WHERE la clausola funziona come un file if conditionin qualsiasi linguaggio di programmazione. Questa clausola viene utilizzata per confrontare il valore dato con il valore del campo disponibile in una tabella MySQL. Se il valore fornito dall'esterno è uguale al valore del campo disponibile nella tabella MySQL, restituisce quella riga.

Ecco l'elenco degli operatori, che possono essere utilizzati con il WHERE clausola.

Supponiamo che il campo A abbia 10 e il campo B ne abbia 20, quindi -

Operatore	Descrizione	Esempio
=	Verifica se i valori dei due operandi sono uguali o meno, in caso affermativo la condizione diventa vera.	(A = B) non è vero.
! =	Controlla se i valori dei due operandi sono uguali o meno, se i valori non sono uguali la condizione diventa vera.	(A! = B) è vero.
>	Verifica se il valore dell'operando sinistro è maggiore del valore dell'operando destro, in caso affermativo la condizione diventa vera.	(A> B) non è vero.
<	Controlla se il valore dell'operando sinistro è inferiore al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(A <B) è vero.
> =	Controlla se il valore dell'operando sinistro è maggiore o uguale al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(A> = B) non è vero.
<=	Controlla se il valore dell'operando sinistro è minore o uguale al valore dell'operando destro, se sì, la condizione diventa vera.	(A <= B) è vero.

La clausola WHERE è molto utile quando si desidera recuperare le righe selezionate da una tabella, soprattutto quando si utilizza il MySQL Join. I join sono discussi in un altro capitolo.

È pratica comune cercare i record utilizzando l'estensione Primary Key per rendere la ricerca più veloce.

Se la condizione data non corrisponde a nessun record nella tabella, la query non restituirà alcuna riga.

Recupero dei dati dal prompt dei comandi

Questo utilizzerà il comando SQL SELECT con la clausola WHERE per recuperare i dati selezionati dalla tabella MySQL - tutorials_tbl.

Esempio

Il seguente esempio restituirà tutti i record da tutorials_tbl tabella per la quale il nome dell'autore è Sanjay.

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> SELECT * from tutorials_tbl WHERE tutorial_author = 'Sanjay';
+-------------+----------------+-----------------+-----------------+
| tutorial_id | tutorial_title | tutorial_author | submission_date |
+-------------+----------------+-----------------+-----------------+
|      3      | JAVA Tutorial  |      Sanjay     |    2007-05-21   |      
+-------------+----------------+-----------------+-----------------+
1 rows in set (0.01 sec)

mysql>

A meno che non si esegua un file LIKEconfronto su una stringa, il confronto non fa distinzione tra maiuscole e minuscole. Puoi rendere sensibile la tua ricerca tra maiuscole e minuscole utilizzando l'estensioneBINARY parola chiave come segue -

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> SELECT * from tutorials_tbl \
   WHERE BINARY tutorial_author = 'sanjay';
Empty set (0.02 sec)

mysql>

Recupero dei dati utilizzando uno script PHP

È possibile utilizzare lo stesso comando SQL SELECT con WHERE CLAUSE nella funzione PHP mysql_query(). Questa funzione viene utilizzata per eseguire il comando SQL e successivamente un'altra funzione PHPmysql_fetch_array()può essere utilizzato per recuperare tutti i dati selezionati. Questa funzione restituisce una riga come matrice associativa, matrice numerica o entrambi. Questa funzione restituisce FALSE se non ci sono più righe.

Esempio

Il seguente esempio restituirà tutti i record da tutorials_tbl tabella per la quale il nome dell'autore è Sanjay -

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);

   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'SELECT tutorial_id, tutorial_title, 
      tutorial_author, submission_date
      FROM tutorials_tbl
      WHERE tutorial_author = "Sanjay"';

   mysql_select_db('TUTORIALS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not get data: ' . mysql_error());
   }

   while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) {
      echo "Tutorial ID :{$row['tutorial_id']} <br> ". "Title: {$row['tutorial_title']} <br> ".
      "Author: {$row['tutorial_author']} <br> ". "Submission Date : {$row['submission_date']} <br> ".
      "--------------------------------<br>";
   } 

   echo "Fetched data successfully\n";
   mysql_close($conn);
?>

Potrebbe esserci un requisito in cui i dati esistenti in una tabella MySQL devono essere modificati. Puoi farlo usando SQLUPDATEcomando. Ciò modificherà qualsiasi valore di campo di qualsiasi tabella MySQL.

Sintassi

Il seguente blocco di codice ha una sintassi SQL generica del comando UPDATE per modificare i dati nella tabella MySQL -

UPDATE table_name SET field1 = new-value1, field2 = new-value2
[WHERE Clause]

• Puoi aggiornare uno o più campi del tutto.
• È possibile specificare qualsiasi condizione utilizzando la clausola WHERE.
• È possibile aggiornare i valori in una singola tabella alla volta.

La clausola WHERE è molto utile quando si desidera aggiornare le righe selezionate in una tabella.

Aggiornamento dei dati dal prompt dei comandi

Questo utilizzerà il comando SQL UPDATE con la clausola WHERE per aggiornare i dati selezionati nella tabella MySQL tutorials_tbl.

Esempio

Il seguente esempio aggiornerà il tutorial_title campo per un record con tutorial_id come 3.

root@host# mysql -u root -p password;
Enter password:*******

mysql> use TUTORIALS;
Database changed

mysql> UPDATE tutorials_tbl 
   -> SET tutorial_title = 'Learning JAVA' 
   -> WHERE tutorial_id = 3;
Query OK, 1 row affected (0.04 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql>

Aggiornamento dei dati utilizzando uno script PHP

È possibile utilizzare il comando SQL UPDATE con o senza WHERE CLAUSE nella funzione PHP - mysql_query(). Questa funzione eseguirà il comando SQL in modo simile a come viene eseguito al prompt mysql>.

Esempio

Il seguente esempio per aggiornare il tutorial_title campo per un record avente tutorial_id come 3.

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);
   
   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'UPDATE tutorials_tbl
      SET tutorial_title="Learning JAVA"
      WHERE tutorial_id=3';

   mysql_select_db('TUTORIALS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not update data: ' . mysql_error());
   }
   echo "Updated data successfully\n";
   mysql_close($conn);
?>

Se desideri eliminare un record da qualsiasi tabella MySQL, puoi utilizzare il comando SQL DELETE FROM. Puoi utilizzare questo comando al prompt mysql> così come in qualsiasi script come PHP.

Sintassi

Il seguente blocco di codice ha una sintassi SQL generica del comando DELETE per eliminare i dati da una tabella MySQL.

DELETE FROM table_name [WHERE Clause]

• Se la clausola WHERE non è specificata, tutti i record verranno eliminati dalla tabella MySQL data.

• È possibile specificare qualsiasi condizione utilizzando la clausola WHERE.

• È possibile eliminare i record in una singola tabella alla volta.

La clausola WHERE è molto utile quando si desidera eliminare le righe selezionate in una tabella.

Eliminazione dei dati dal prompt dei comandi

Questo utilizzerà il comando SQL DELETE con la clausola WHERE per eliminare i dati selezionati nella tabella MySQL - tutorials_tbl.

Esempio

Il seguente esempio eliminerà un record da tutorial_tbl il cui tutorial_id è 3.

root@host# mysql -u root -p password;
Enter password:*******

mysql> use TUTORIALS;
Database changed

mysql> DELETE FROM tutorials_tbl WHERE tutorial_id=3;
Query OK, 1 row affected (0.23 sec)

mysql>

Eliminazione dei dati utilizzando uno script PHP

Puoi usare il comando SQL DELETE con o senza WHERE CLAUSE nella funzione PHP - mysql_query(). Questa funzione eseguirà il comando SQL nello stesso modo in cui viene eseguito al prompt mysql>.

Esempio

Prova il seguente esempio per eliminare un record da tutorial_tbl il cui tutorial_id è 3.

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);
   
   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'DELETE FROM tutorials_tbl WHERE tutorial_id = 3';

   mysql_select_db('TUTORIALS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not delete data: ' . mysql_error());
   }
   echo "Deleted data successfully\n";
   mysql_close($conn);
?>

Abbiamo visto l'SQL SELECTcomando per recuperare i dati dalla tabella MySQL. Possiamo anche usare una clausola condizionale chiamata comeWHERE clausola per selezionare i record richiesti.

Una clausola WHERE con il segno "uguale a" (=) funziona bene dove vogliamo fare una corrispondenza esatta. Come se "tutorial_author = 'Sanjay'". Ma potrebbe esserci un requisito in cui vogliamo filtrare tutti i risultati in cui il nome tutorial_author dovrebbe contenere "jay". Questo può essere gestito usandoSQL LIKE Clause insieme alla clausola WHERE.

Se la clausola SQL LIKE viene utilizzata insieme al carattere%, funzionerà come un metacarattere (*) come in UNIX, elencando tutti i file o le directory al prompt dei comandi. Senza un carattere%, la clausola LIKE è molto simile aequal to firmare insieme alla clausola WHERE.

Sintassi

Il seguente blocco di codice ha una sintassi SQL generica del comando SELECT insieme alla clausola LIKE per recuperare i dati da una tabella MySQL.

SELECT field1, field2,...fieldN table_name1, table_name2...
WHERE field1 LIKE condition1 [AND [OR]] filed2 = 'somevalue'

• È possibile specificare qualsiasi condizione utilizzando la clausola WHERE.

• È possibile utilizzare la clausola LIKE insieme alla clausola WHERE.

• È possibile utilizzare la clausola LIKE al posto di equals to cartello.

• Quando LIKE viene utilizzato insieme al segno%, funzionerà come una ricerca di meta caratteri.

• È possibile specificare più di una condizione utilizzando AND o OR operatori.

• Una clausola WHERE ... LIKE può essere utilizzata insieme al comando SQL DELETE o UPDATE anche per specificare una condizione.

Utilizzo della clausola LIKE nel prompt dei comandi

Questo utilizzerà il comando SQL SELECT con la clausola WHERE ... LIKE per recuperare i dati selezionati dalla tabella MySQL - tutorials_tbl.

Esempio

Il seguente esempio restituirà tutti i record da tutorials_tbl tabella per la quale il nome dell'autore termina con jay -

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> SELECT * from tutorials_tbl 
   -> WHERE tutorial_author LIKE '%jay';
+-------------+----------------+-----------------+-----------------+
| tutorial_id | tutorial_title | tutorial_author | submission_date |
+-------------+----------------+-----------------+-----------------+
|      3      |  JAVA Tutorial |     Sanjay      |    2007-05-21   |   
+-------------+----------------+-----------------+-----------------+
1 rows in set (0.01 sec)

mysql>

Utilizzo della clausola LIKE all'interno dello script PHP

È possibile utilizzare una sintassi simile della clausola WHERE ... LIKE nella funzione PHP - mysql_query(). Questa funzione viene utilizzata per eseguire il comando SQL e successivamente un'altra funzione PHP -mysql_fetch_array() può essere utilizzato per recuperare tutti i dati selezionati, se la clausola WHERE ... LIKE viene utilizzata insieme al comando SELECT.

Ma se la clausola WHERE ... LIKE viene utilizzata con il comando DELETE o UPDATE, non sono necessarie ulteriori chiamate di funzione PHP.

Esempio

Prova il seguente esempio per restituire tutti i record dal file tutorials_tbl tabella per la quale contiene il nome dell'autore jay -

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);

   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'SELECT tutorial_id, tutorial_title, 
      tutorial_author, submission_date
      FROM tutorials_tbl
      WHERE tutorial_author LIKE "%jay%"';

   mysql_select_db('TUTORIALS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not get data: ' . mysql_error());
   }

   while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) {
      echo "Tutorial ID :{$row['tutorial_id']} <br> ". "Title: {$row['tutorial_title']} <br> ".
         "Author: {$row['tutorial_author']} <br> ". "Submission Date : {$row['submission_date']} <br> ".
         "--------------------------------<br>";
   } 
   echo "Fetched data successfully\n";
   mysql_close($conn);
?>

Abbiamo visto l'SQL SELECTcomando per recuperare i dati da una tabella MySQL. Quando selezioni le righe, il server MySQL è libero di restituirle in qualsiasi ordine, a meno che tu non lo indichi diversamente dicendo come ordinare il risultato. Tuttavia, si ordina un set di risultati aggiungendo un fileORDER BY clausola che denomina la colonna o le colonne che si desidera ordinare.

Sintassi

Il seguente blocco di codice è una sintassi SQL generica del comando SELECT insieme alla clausola ORDER BY per ordinare i dati da una tabella MySQL.

SELECT field1, field2,...fieldN table_name1, table_name2...
ORDER BY field1, [field2...] [ASC [DESC]]

• È possibile ordinare il risultato restituito su qualsiasi campo, se tale campo viene elencato.

• Puoi ordinare il risultato su più di un campo.

• È possibile utilizzare la parola chiave ASC o DESC per ottenere risultati in ordine crescente o decrescente. Per impostazione predefinita, è l'ordine crescente.

• È possibile utilizzare la clausola WHERE ... LIKE nel solito modo per inserire una condizione.

Utilizzo della clausola ORDER BY nel prompt dei comandi

Questo utilizzerà il comando SQL SELECT con l'estensione ORDER BY clausola per recuperare i dati dalla tabella MySQL - tutorials_tbl.

Esempio

Prova il seguente esempio, che restituisce il risultato in ordine crescente.

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> SELECT * from tutorials_tbl ORDER BY tutorial_author ASC
+-------------+----------------+-----------------+-----------------+
| tutorial_id | tutorial_title | tutorial_author | submission_date |
+-------------+----------------+-----------------+-----------------+
|      2      |  Learn MySQL   |     Abdul S     |    2007-05-24   |   
|      1      |   Learn PHP    |    John Poul    |    2007-05-24   |   
|      3      | JAVA Tutorial  |     Sanjay      |    2007-05-06   |   
+-------------+----------------+-----------------+-----------------+
3 rows in set (0.42 sec)

mysql>

Verificare tutti i nomi degli autori elencati in ordine crescente.

Utilizzo della clausola ORDER BY all'interno di uno script PHP

È possibile utilizzare una sintassi simile della clausola ORDER BY nella funzione PHP - mysql_query(). Questa funzione viene utilizzata per eseguire il comando SQL e successivamente un'altra funzione PHPmysql_fetch_array() può essere utilizzato per recuperare tutti i dati selezionati.

Esempio

Prova il seguente esempio, che restituisce il risultato in ordine decrescente degli autori del tutorial.

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);
   
   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'SELECT tutorial_id, tutorial_title, 
      tutorial_author, submission_date
      FROM tutorials_tbl
      ORDER BY  tutorial_author DESC';

   mysql_select_db('TUTORIALS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not get data: ' . mysql_error());
   }

   while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) {
      echo "Tutorial ID :{$row['tutorial_id']} <br> ". "Title: {$row['tutorial_title']} <br> ".
         "Author: {$row['tutorial_author']} <br> ". "Submission Date : {$row['submission_date']} <br> ".
         "--------------------------------<br>";
   } 
   echo "Fetched data successfully\n";
   mysql_close($conn);
?>

Nei capitoli precedenti, stavamo ottenendo i dati da una tabella alla volta. Questo è abbastanza buono per riprese semplici, ma nella maggior parte degli usi MySQL del mondo reale, sarà spesso necessario ottenere dati da più tabelle in una singola query.

È possibile utilizzare più tabelle nella singola query SQL. L'atto di unirsi in MySQL si riferisce a frantumare due o più tabelle in una singola tabella.

È possibile utilizzare JOINS nelle istruzioni SELECT, UPDATE e DELETE per unire le tabelle MySQL. Vedremo anche un esempio del LEFT JOIN che è diverso dal semplice MySQL JOIN.

Utilizzo dei join dal prompt dei comandi

Supponiamo di avere due tavoli tcount_tbl e tutorials_tbl, in TUTORIAL. Ora dai un'occhiata agli esempi forniti di seguito:

Esempio

I seguenti esempi:

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> SELECT * FROM tcount_tbl;
+-----------------+----------------+
| tutorial_author | tutorial_count |
+-----------------+----------------+
|      mahran     |       20       |     
|      mahnaz     |      NULL      |        
|       Jen       |      NULL      |          
|      Gill       |       20       |          
|    John Poul    |        1       |      
|     Sanjay      |        1       |        
+-----------------+----------------+
6 rows in set (0.01 sec)
mysql> SELECT * from tutorials_tbl;
+-------------+----------------+-----------------+-----------------+
| tutorial_id | tutorial_title | tutorial_author | submission_date |
+-------------+----------------+-----------------+-----------------+
|      1      |  Learn PHP     |     John Poul   |    2007-05-24   |   
|      2      |  Learn MySQL   |      Abdul S    |    2007-05-24   |   
|      3      | JAVA Tutorial  |      Sanjay     |    2007-05-06   |   
+-------------+----------------+-----------------+-----------------+
3 rows in set (0.00 sec)
mysql>

Ora possiamo scrivere una query SQL per unire queste due tabelle. Questa query selezionerà tutti gli autori dalla tabellatutorials_tbl e raccoglierà il numero corrispondente di tutorial dal file tcount_tbl.

mysql> SELECT a.tutorial_id, a.tutorial_author, b.tutorial_count
   -> FROM tutorials_tbl a, tcount_tbl b
   -> WHERE a.tutorial_author = b.tutorial_author;
+-------------+-----------------+----------------+
| tutorial_id | tutorial_author | tutorial_count |
+-------------+-----------------+----------------+
|      1      |    John Poul    |        1       |
|      3      |     Sanjay      |        1       |
+-------------+-----------------+----------------+
2 rows in set (0.01 sec)
mysql>

Utilizzo dei join in uno script PHP

È possibile utilizzare una qualsiasi delle query SQL sopra menzionate nello script PHP. Hai solo bisogno di passare la query SQL nella funzione PHPmysql_query() e poi recupererai i risultati nel solito modo.

Esempio

Il seguente esempio:

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);
   
   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'SELECT a.tutorial_id, a.tutorial_author, b.tutorial_count
      FROM tutorials_tbl a, tcount_tbl b
      WHERE a.tutorial_author = b.tutorial_author';

   mysql_select_db('TUTORIALS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not get data: ' . mysql_error());
   }

   while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) {
      echo "Author:{$row['tutorial_author']} <br> ". "Count: {$row['tutorial_count']} <br> ".
         "Tutorial ID: {$row['tutorial_id']} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

MySQL LEFT JOIN

Un left join di MySQL è diverso da un semplice join. Un MySQL LEFT JOIN dà qualche considerazione extra alla tabella che si trova a sinistra.

Se faccio un file LEFT JOIN, Ottengo tutti i record che corrispondono allo stesso modo e INOLTRE ottengo un record extra per ogni record non abbinato nella tabella sinistra del join: assicurandomi così (nel mio esempio) che ogni AUTORE riceva una menzione.

Esempio

Prova il seguente esempio per comprendere LEFT JOIN.

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> SELECT a.tutorial_id, a.tutorial_author, b.tutorial_count
   -> FROM tutorials_tbl a LEFT JOIN tcount_tbl b
   -> ON a.tutorial_author = b.tutorial_author;
+-------------+-----------------+----------------+
| tutorial_id | tutorial_author | tutorial_count |
+-------------+-----------------+----------------+
|      1      |    John Poul    |       1        |
|      2      |     Abdul S     |      NULL      |
|      3      |     Sanjay      |       1        |
+-------------+-----------------+----------------+
3 rows in set (0.02 sec)

Dovresti fare più pratica per acquisire familiarità con JOINS. Questo è un concetto un po 'complesso in MySQL / SQL e diventerà più chiaro durante l'esecuzione di esempi reali.

Abbiamo visto l'SQL SELECT comando insieme al WHERE clausola per recuperare i dati da una tabella MySQL, ma quando proviamo a dare una condizione, che confronta il campo o il valore della colonna con NULL, non funziona correttamente.

Per gestire una situazione del genere, MySQL fornisce tre operatori:

• IS NULL - Questo operatore restituisce true, se il valore della colonna è NULL.

• IS NOT NULL - Questo operatore restituisce true, se il valore della colonna non è NULL.

• <=> - Questo operatore confronta i valori, che (a differenza dell'operatore =) è vero anche per due valori NULL.

Le condizioni che coinvolgono NULL sono speciali. Non puoi usare =NULL o! = NULLper cercare valori NULL nelle colonne. Tali confronti falliscono sempre perché è impossibile dire se sono veri o meno. A volte, anche NULL = NULL fallisce.

Per cercare colonne che sono o non sono NULL, utilizzare IS NULL o IS NOT NULL.

Utilizzo di valori NULL nel prompt dei comandi

Supponiamo che ci sia una tabella chiamata tcount_tbl nel database TUTORIALS e contiene due colonne vale a dire tutorial_author e tutorial_count, dove un tutorial_count NULL indica che il valore è sconosciuto.

Esempio

Prova i seguenti esempi:

root@host# mysql -u root -p password;
Enter password:*******

mysql> use TUTORIALS;
Database changed

mysql> create table tcount_tbl
   -> (
   -> tutorial_author varchar(40) NOT NULL,
   -> tutorial_count  INT
   -> );
Query OK, 0 rows affected (0.05 sec)

mysql> INSERT INTO tcount_tbl
   -> (tutorial_author, tutorial_count) values ('mahran', 20);

mysql> INSERT INTO tcount_tbl
   -> (tutorial_author, tutorial_count) values ('mahnaz', NULL);

mysql> INSERT INTO tcount_tbl
   -> (tutorial_author, tutorial_count) values ('Jen', NULL);

mysql> INSERT INTO tcount_tbl
   -> (tutorial_author, tutorial_count) values ('Gill', 20);

mysql> SELECT * from tcount_tbl;
+-----------------+----------------+
| tutorial_author | tutorial_count |
+-----------------+----------------+
|     mahran      |       20       |
|     mahnaz      |      NULL      |
|      Jen        |      NULL      |
|     Gill        |       20       |
+-----------------+----------------+
4 rows in set (0.00 sec)

mysql>

Puoi vedere che = e != non funzionano con i valori NULL come segue -

mysql> SELECT * FROM tcount_tbl WHERE tutorial_count = NULL;
Empty set (0.00 sec)

mysql> SELECT * FROM tcount_tbl WHERE tutorial_count != NULL;
Empty set (0.01 sec)

Per trovare i record in cui la colonna tutorial_count è o non è NULL, le query devono essere scritte come mostrato nel programma seguente.

mysql> SELECT * FROM tcount_tbl 
   -> WHERE tutorial_count IS NULL;
+-----------------+----------------+
| tutorial_author | tutorial_count |
+-----------------+----------------+
|     mahnaz      |      NULL      |
|      Jen        |      NULL      |
+-----------------+----------------+
2 rows in set (0.00 sec)
mysql> SELECT * from tcount_tbl 
   -> WHERE tutorial_count IS NOT NULL;
+-----------------+----------------+
| tutorial_author | tutorial_count |
+-----------------+----------------+
|     mahran      |       20       |
|     Gill        |       20       |
+-----------------+----------------+
2 rows in set (0.00 sec)

Gestione dei valori NULL in uno script PHP

Puoi usare il file if...else condizione per preparare una query in base al valore NULL.

Esempio

L'esempio seguente utilizza tutorial_count dall'esterno e poi lo confronta con il valore disponibile nella tabella.

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   if( isset($tutorial_count )) { $sql = 'SELECT tutorial_author, tutorial_count
         FROM  tcount_tbl
         WHERE tutorial_count = $tutorial_count'; } else { $sql = 'SELECT tutorial_author, tutorial_count
         FROM  tcount_tbl
         WHERE tutorial_count IS $tutorial_count'; } mysql_select_db('TUTORIALS'); $retval = mysql_query( $sql, $conn );
   
   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) { echo "Author:{$row['tutorial_author']}  <br> ".
         "Count: {$row['tutorial_count']} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

Hai visto il pattern MySQL che corrisponde a LIKE ...%. MySQL supporta un altro tipo di operazione di corrispondenza dei modelli basata sulle espressioni regolari e suREGEXPoperatore. Se sei a conoscenza di PHP o PERL, allora è molto semplice da capire perché questa corrispondenza è la stessa di quelli che scrivono le espressioni regolari.

Di seguito è riportata la tabella del modello, che può essere utilizzata insieme al file REGEXP operatore.

Modello	Ciò che il modello corrisponde
^	Inizio della stringa
$	Fine della stringa
.	Qualsiasi singolo carattere
[...]	Qualsiasi carattere elencato tra parentesi quadre
[^ ...]	Qualsiasi carattere non elencato tra parentesi quadre
p1 | p2 | p3	Alternanza; corrisponde a uno qualsiasi dei modelli p1, p2 o p3
*	Zero o più istanze dell'elemento precedente
+	Una o più istanze dell'elemento precedente
{n}	n istanze dell'elemento precedente
{m, n}	da m a n istanze dell'elemento precedente

Esempi

Ora, in base alla tabella sopra, puoi eseguire vari tipi di query SQL per soddisfare le tue esigenze. Qui ne elencherò alcuni per la tua comprensione.

Considera che abbiamo un tavolo chiamato person_tbl e sta avendo un campo chiamato name -

Query per trovare tutti i nomi che iniziano con 'st' -

mysql> SELECT name FROM person_tbl WHERE name REGEXP '^st';

Query per trovare tutti i nomi che finiscono con 'ok' -

mysql> SELECT name FROM person_tbl WHERE name REGEXP 'ok$';

Query per trovare tutti i nomi che contengono 'mar' -

mysql> SELECT name FROM person_tbl WHERE name REGEXP 'mar';

Query per trovare tutti i nomi che iniziano con una vocale e finiscono con 'ok' -

mysql> SELECT FirstName FROM intque.person_tbl WHERE FirstName REGEXP '^[aeiou].*ok$';

Una transazione è un gruppo sequenziale di operazioni di manipolazione del database, che viene eseguito come se fosse una singola unità di lavoro. In altre parole, una transazione non sarà mai completa a meno che ogni singola operazione all'interno del gruppo non abbia successo. Se qualsiasi operazione all'interno della transazione fallisce, l'intera transazione fallirà.

In pratica, raggrupperai molte query SQL in un gruppo e le eseguirai tutte insieme come parte di una transazione.

Proprietà delle transazioni

Le transazioni hanno le seguenti quattro proprietà standard, solitamente indicate con l'acronimo ACID -

• Atomicity- Ciò garantisce che tutte le operazioni all'interno dell'unità di lavoro siano completate con successo; in caso contrario, la transazione viene interrotta al punto di errore e le operazioni precedenti vengono riportate allo stato precedente.

• Consistency - Ciò garantisce che il database modifichi correttamente gli stati su una transazione confermata con successo.

• Isolation - Ciò consente alle transazioni di operare in modo indipendente e trasparente l'una con l'altra.

• Durability - Ciò garantisce che il risultato o l'effetto di una transazione confermata persista in caso di guasto del sistema.

In MySQL, le transazioni iniziano con l'istruzione BEGIN WORK e terminare con a COMMIT o a ROLLBACKdichiarazione. I comandi SQL tra le istruzioni di inizio e fine costituiscono la maggior parte della transazione.

COMMIT e ROLLBACK

Queste due parole chiave Commit e Rollback sono utilizzati principalmente per le transazioni MySQL.

• Quando una transazione riuscita è completata, il comando COMMIT dovrebbe essere emesso in modo che le modifiche a tutte le tabelle coinvolte abbiano effetto.

• Se si verifica un errore, è necessario eseguire un comando ROLLBACK per riportare ogni tabella a cui si fa riferimento nella transazione allo stato precedente.

È possibile controllare il comportamento di una transazione impostando la variabile di sessione chiamata AUTOCOMMIT. Se AUTOCOMMIT è impostato su 1 (impostazione predefinita), ogni istruzione SQL (all'interno di una transazione o meno) viene considerata una transazione completa e sottoposta a commit per impostazione predefinita al termine.

Quando AUTOCOMMIT è impostato su 0, emettendo il SET AUTOCOMMIT = 0 comando, la serie successiva di istruzioni agisce come una transazione e nessuna attività viene sottoposta a commit finché non viene emessa un'istruzione COMMIT esplicita.

È possibile eseguire questi comandi SQL in PHP utilizzando il mysql_query() funzione.

Un esempio generico sulla transazione

Questa sequenza di eventi è indipendente dal linguaggio di programmazione utilizzato. Il percorso logico può essere creato nella lingua utilizzata per creare l'applicazione.

È possibile eseguire questi comandi SQL in PHP utilizzando il mysql_query() funzione.

• Inizia la transazione immettendo il comando SQL BEGIN WORK.

• Emetti uno o più comandi SQL come SELECT, INSERT, UPDATE o DELETE.

• Controlla se non ci sono errori e tutto è conforme alle tue esigenze.

• In caso di errore, eseguire un comando ROLLBACK, altrimenti eseguire un comando COMMIT.

Tipi di tabelle sicuri per le transazioni in MySQL

Non è possibile utilizzare le transazioni direttamente, ma per alcune eccezioni è possibile. Tuttavia, non sono sicuri e garantiti. Se prevedi di utilizzare le transazioni nella tua programmazione MySQL, devi creare le tue tabelle in un modo speciale. Esistono molti tipi di tabelle che supportano le transazioni, ma la più popolare èInnoDB.

Il supporto per le tabelle InnoDB richiede un parametro di compilazione specifico durante la compilazione di MySQL dal sorgente. Se la tua versione di MySQL non supporta InnoDB, chiedi al tuo provider di servizi Internet di creare una versione di MySQL con supporto per i tipi di tabelle InnoDB o scarica e installa ilMySQL-Max Binary Distribution per Windows o Linux / UNIX e lavorare con il tipo di tabella in un ambiente di sviluppo.

Se la tua installazione MySQL supporta le tabelle InnoDB, aggiungi semplicemente un file TYPE = InnoDB definizione all'istruzione di creazione della tabella.

Ad esempio, il codice seguente crea una tabella InnoDB chiamata tcount_tbl -

root@host# mysql -u root -p password;
Enter password:*******

mysql> use TUTORIALS;
Database changed

mysql> create table tcount_tbl
   -> (
   -> tutorial_author varchar(40) NOT NULL,
   -> tutorial_count  INT
   -> ) TYPE = InnoDB;
Query OK, 0 rows affected (0.05 sec)

Per maggiori dettagli su InnoDB, puoi fare clic sul seguente link - InnoDB

Puoi usare altri tipi di tabella come GEMINI o BDB, ma dipende dalla tua installazione, che supporti o meno questi due tipi di tabella.

Il MySQL ALTER Il comando è molto utile quando si desidera modificare un nome della tabella, qualsiasi campo della tabella o se si desidera aggiungere o eliminare una colonna esistente in una tabella.

Cominciamo con la creazione di una tabella chiamata testalter_tbl.

root@host# mysql -u root -p password;
Enter password:*******

mysql> use TUTORIALS;
Database changed

mysql> create table testalter_tbl
   -> (
   -> i INT,
   -> c CHAR(1)
   -> );
Query OK, 0 rows affected (0.05 sec)
mysql> SHOW COLUMNS FROM testalter_tbl;
+-------+---------+------+-----+---------+-------+
| Field |  Type   | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
|   i   | int(11) | YES  |     |   NULL  |       |
|   c   | char(1) | YES  |     |   NULL  |       |
+-------+---------+------+-----+---------+-------+
2 rows in set (0.00 sec)

Rilascio, aggiunta o riposizionamento di una colonna

Se desideri eliminare una colonna i esistente dalla tabella MySQL sopra, utilizzerai l'estensione DROP clausola insieme alla ALTER comando come mostrato di seguito -

mysql> ALTER TABLE testalter_tbl  DROP i;

UN DROP la clausola non funzionerà se la colonna è l'unica rimasta nella tabella.

Per aggiungere una colonna, utilizzare AGGIUNGI e specificare la definizione della colonna. La seguente istruzione ripristina il filei colonna al testalter_tbl -

mysql> ALTER TABLE testalter_tbl ADD i INT;

Dopo aver emesso questa dichiarazione, testalter conterrà le stesse due colonne che aveva quando hai creato la tabella per la prima volta, ma non avrà la stessa struttura. Questo perché ci sono nuove colonne che vengono aggiunte alla fine della tabella per impostazione predefinita. Quindi anche sei originariamente era la prima colonna in mytbl, ora è l'ultima.

mysql> SHOW COLUMNS FROM testalter_tbl;
+-------+---------+------+-----+---------+-------+
| Field |  Type   | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
|   c   | char(1) | YES  |     |   NULL  |       |
|   i   | int(11) | YES  |     |   NULL  |       |
+-------+---------+------+-----+---------+-------+
2 rows in set (0.00 sec)

Per indicare che desideri una colonna in una posizione specifica all'interno della tabella, usa FIRST per renderla la prima colonna o AFTER col_name per indicare che la nuova colonna deve essere posizionata dopo col_name.

Prova quanto segue ALTER TABLE dichiarazioni, utilizzando SHOW COLUMNS dopo ognuno per vedere quale effetto ha ciascuno -

ALTER TABLE testalter_tbl DROP i;
ALTER TABLE testalter_tbl ADD i INT FIRST;
ALTER TABLE testalter_tbl DROP i;
ALTER TABLE testalter_tbl ADD i INT AFTER c;

Gli specificatori FIRST e AFTER funzionano solo con la clausola ADD. Ciò significa che se vuoi riposizionare una colonna esistente all'interno di una tabella, devi prima farloDROP e poi ADD nella nuova posizione.

Alterare (cambiare) una definizione di colonna o un nome

Per modificare la definizione di una colonna, utilizzare MODIFY o CHANGE clausola insieme al comando ALTER.

Ad esempio, per cambiare colonna c da CHAR (1) a CHAR (10), puoi usare il seguente comando:

mysql> ALTER TABLE testalter_tbl MODIFY c CHAR(10);

Con CHANGE, la sintassi è leggermente diversa. Dopo la parola chiave CHANGE, assegna un nome alla colonna che desideri modificare, quindi specifica la nuova definizione, che include il nuovo nome.

Prova il seguente esempio:

mysql> ALTER TABLE testalter_tbl CHANGE i j BIGINT;

Se ora usi CHANGE per convertire j a partire dal BIGINT torna a INT senza modificare il nome della colonna, l'istruzione sarà come mostrato di seguito -

mysql> ALTER TABLE testalter_tbl CHANGE j j INT;

The Effect of ALTER TABLE on Null and Default Value Attributes- Quando MODIFICATE o CAMBIATE una colonna, potete anche specificare se la colonna può contenere valori NULL e qual è il suo valore predefinito. Infatti, se non lo fai, MySQL assegna automaticamente i valori per questi attributi.

Il seguente blocco di codice è un esempio, dove il NOT NULL per impostazione predefinita, la colonna avrà il valore 100.

mysql> ALTER TABLE testalter_tbl 
   -> MODIFY j BIGINT NOT NULL DEFAULT 100;

Se non usi il comando precedente, MySQL riempirà i valori NULL in tutte le colonne.

Alterare (cambiare) il valore predefinito di una colonna

È possibile modificare un valore predefinito per qualsiasi colonna utilizzando il ALTER comando.

Prova il seguente esempio.

mysql> ALTER TABLE testalter_tbl ALTER i SET DEFAULT 1000;
mysql> SHOW COLUMNS FROM testalter_tbl;
+-------+---------+------+-----+---------+-------+
| Field |  Type   | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
|   c   | char(1) | YES  |     |   NULL  |       |
|   i   | int(11) | YES  |     |   1000  |       |
+-------+---------+------+-----+---------+-------+
2 rows in set (0.00 sec)

È possibile rimuovere il vincolo predefinito da qualsiasi colonna utilizzando la clausola DROP insieme al ALTER comando.

mysql> ALTER TABLE testalter_tbl ALTER i DROP DEFAULT;
mysql> SHOW COLUMNS FROM testalter_tbl;
+-------+---------+------+-----+---------+-------+
| Field |  Type   | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
|   c   | char(1) | YES  |     |   NULL  |       |
|   i   | int(11) | YES  |     |   NULL  |       |
+-------+---------+------+-----+---------+-------+
2 rows in set (0.00 sec)

Alterare (cambiare) un tipo di tabella

È possibile utilizzare un tipo di tabella utilizzando il TYPEclausola insieme al comando ALTER. Prova il seguente esempio per modificare il filetestalter_tbl per MYISAM tipo di tabella.

Per scoprire il tipo corrente di una tabella, utilizzare il SHOW TABLE STATUS dichiarazione.

mysql> ALTER TABLE testalter_tbl TYPE = MYISAM;
mysql>  SHOW TABLE STATUS LIKE 'testalter_tbl'\G
*************************** 1. row ****************
           Name: testalter_tbl
           Type: MyISAM
     Row_format: Fixed
           Rows: 0
 Avg_row_length: 0
    Data_length: 0
Max_data_length: 25769803775
   Index_length: 1024
      Data_free: 0
 Auto_increment: NULL
    Create_time: 2007-06-03 08:04:36
    Update_time: 2007-06-03 08:04:36
     Check_time: NULL
 Create_options:
        Comment:
1 row in set (0.00 sec)

Rinominare (alterare) una tabella

Per rinominare una tabella, usa il RENAME opzione di ALTER TABLE dichiarazione.

Prova il seguente esempio per rinominare testalter_tbl per alter_tbl.

mysql> ALTER TABLE testalter_tbl RENAME TO alter_tbl;

È possibile utilizzare il comando ALTER per creare e rilasciare il comando INDEX su un file MySQL. Discuteremo in dettaglio di questo comando nel prossimo capitolo.

Un indice di database è una struttura di dati che migliora la velocità delle operazioni in una tabella. Gli indici possono essere creati utilizzando una o più colonne, fornendo la base sia per rapide ricerche casuali che per un efficiente ordinamento dell'accesso ai record.

Durante la creazione dell'indice, è necessario prendere in considerazione quali colonne verranno utilizzate per eseguire query SQL e creare uno o più indici su tali colonne.

In pratica, gli indici sono anche un tipo di tabelle, che mantengono la chiave primaria o il campo indice e un puntatore a ciascun record nella tabella effettiva.

Gli utenti non possono vedere gli indici, vengono utilizzati solo per velocizzare le query e verranno utilizzati dal Motore di ricerca database per individuare i record molto velocemente.

Le istruzioni INSERT e UPDATE richiedono più tempo sulle tabelle con indici, mentre le istruzioni SELECT diventano veloci su quelle tabelle. Il motivo è che durante l'inserimento o l'aggiornamento, un database deve inserire o aggiornare anche i valori dell'indice.

Indice semplice e unico

Puoi creare un indice univoco su una tabella. Un indice univoco significa che due righe non possono avere lo stesso valore di indice. Ecco la sintassi per creare un indice su una tabella.

CREATE UNIQUE INDEX index_name ON table_name ( column1, column2,...);

È possibile utilizzare una o più colonne per creare un indice.

Ad esempio, possiamo creare un indice su tutorials_tbl utilizzando tutorial_author.

CREATE UNIQUE INDEX AUTHOR_INDEX ON tutorials_tbl (tutorial_author)

Puoi creare un semplice indice su una tabella. Basta omettere il fileUNIQUEparola chiave dalla query per creare un semplice indice. Un indice semplice consente valori duplicati in una tabella.

Se vuoi indicizzare i valori in una colonna in ordine decrescente, puoi aggiungere la parola riservata DESC dopo il nome della colonna.

mysql> CREATE UNIQUE INDEX AUTHOR_INDEX ON tutorials_tbl (tutorial_author DESC)

Comando ALTER per aggiungere e rilasciare INDEX

Esistono quattro tipi di istruzioni per l'aggiunta di indici a una tabella:

• ALTER TABLE tbl_name ADD PRIMARY KEY (column_list) - Questa dichiarazione aggiunge un file PRIMARY KEY, il che significa che i valori indicizzati devono essere univoci e non possono essere NULL.

• ALTER TABLE tbl_name ADD UNIQUE index_name (column_list) - Questa istruzione crea un indice per il quale i valori devono essere univoci (ad eccezione dei valori NULL, che possono apparire più volte).

• ALTER TABLE tbl_name ADD INDEX index_name (column_list) - Questo aggiunge un indice ordinario in cui qualsiasi valore può apparire più di una volta.

• ALTER TABLE tbl_name ADD FULLTEXT index_name (column_list) - Questo crea uno speciale indice FULLTEXT che viene utilizzato per scopi di ricerca di testo.

Il seguente blocco di codice è un esempio per aggiungere un indice in una tabella esistente.

mysql> ALTER TABLE testalter_tbl ADD INDEX (c);

Puoi eliminare qualsiasi INDICE utilizzando il file DROP clausola insieme al comando ALTER.

Prova il seguente esempio per eliminare l'indice creato sopra.

mysql> ALTER TABLE testalter_tbl DROP INDEX (c);

È possibile eliminare qualsiasi INDICE utilizzando la clausola DROP insieme al comando ALTER.

ALTER Comando per aggiungere e rilasciare la CHIAVE PRIMARIA

Puoi anche aggiungere una chiave primaria allo stesso modo. Ma assicurati che la chiave primaria funzioni su colonne, che NON sono NULL.

Il seguente blocco di codice è un esempio per aggiungere la chiave primaria in una tabella esistente. Questo renderà prima una colonna NOT NULL e poi la aggiungerà come chiave primaria.

mysql> ALTER TABLE testalter_tbl MODIFY i INT NOT NULL;
mysql> ALTER TABLE testalter_tbl ADD PRIMARY KEY (i);

È possibile utilizzare il comando ALTER per rilasciare una chiave primaria come segue:

mysql> ALTER TABLE testalter_tbl DROP PRIMARY KEY;

Per eliminare un indice che non è una CHIAVE PRIMARIA, è necessario specificare il nome dell'indice.

Visualizzazione delle informazioni INDICE

Puoi usare il file SHOW INDEXcomando per elencare tutti gli indici associati a una tabella. L'output in formato verticale (specificato da \ G) è spesso utile con questa istruzione, per evitare un wraparound di riga lunga -

Prova il seguente esempio:

mysql> SHOW INDEX FROM table_name\G
........

Le tabelle temporanee potrebbero essere molto utili in alcuni casi per conservare i dati temporanei. La cosa più importante che dovrebbe essere nota per le tabelle temporanee è che verranno eliminate al termine della sessione client corrente.

Cosa sono le tabelle temporanee?

Le tabelle temporanee sono state aggiunte nella versione 3.23 di MySQL. Se usi una versione di MySQL precedente alla 3.23, non puoi usare le tabelle temporanee, ma puoi usareHeap Tables.

Come affermato in precedenza, le tabelle temporanee dureranno solo finché la sessione è attiva. Se esegui il codice in uno script PHP, la tabella temporanea verrà distrutta automaticamente al termine dell'esecuzione dello script. Se sei connesso al server di database MySQL tramite il programma client MySQL, la tabella temporanea esisterà fino a quando non chiuderai il client o distruggerai manualmente la tabella.

Esempio

Il seguente programma è un esempio che mostra l'utilizzo della tabella temporanea. Lo stesso codice può essere utilizzato negli script PHP utilizzando l'estensionemysql_query() funzione.

mysql> CREATE TEMPORARY TABLE SalesSummary (
   -> product_name VARCHAR(50) NOT NULL
   -> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
   -> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   -> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO SalesSummary
   -> (product_name, total_sales, avg_unit_price, total_units_sold)
   -> VALUES
   -> ('cucumber', 100.25, 90, 2);

mysql> SELECT * FROM SalesSummary;
+--------------+-------------+----------------+------------------+
| product_name | total_sales | avg_unit_price | total_units_sold |
+--------------+-------------+----------------+------------------+
|   cucumber   |   100.25    |     90.00      |         2        |
+--------------+-------------+----------------+------------------+
1 row in set (0.00 sec)

Quando emetti un file SHOW TABLEScomando, la tua tabella temporanea non sarà elencata nell'elenco. Ora, se ti disconnetti dalla sessione MySQL e poi emetti un fileSELECTcomando, quindi non troverai dati disponibili nel database. Anche la tua tabella temporanea non esisterà.

Eliminazione di tabelle temporanee

Per impostazione predefinita, tutte le tabelle temporanee vengono eliminate da MySQL quando la connessione al database viene terminata. Tuttavia, se desideri eliminarli nel mezzo, lo fai emettendo ilDROP TABLE comando.

Il seguente programma è un esempio su come eliminare una tabella temporanea:

mysql> CREATE TEMPORARY TABLE SalesSummary (
   -> product_name VARCHAR(50) NOT NULL
   -> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
   -> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   -> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO SalesSummary
   -> (product_name, total_sales, avg_unit_price, total_units_sold)
   -> VALUES
   -> ('cucumber', 100.25, 90, 2);

mysql> SELECT * FROM SalesSummary;
+--------------+-------------+----------------+------------------+
| product_name | total_sales | avg_unit_price | total_units_sold |
+--------------+-------------+----------------+------------------+
|   cucumber   |   100.25    |     90.00      |         2        |
+--------------+-------------+----------------+------------------+
1 row in set (0.00 sec)
mysql> DROP TABLE SalesSummary;
mysql>  SELECT * FROM SalesSummary;
ERROR 1146: Table 'TUTORIALS.SalesSummary' doesn't exist

Potrebbe esserci una situazione in cui è necessaria una copia esatta di una tabella e CREATE TABLE ... SELECT non è adatto ai tuoi scopi perché la copia deve includere gli stessi indici, valori predefiniti e così via.

Puoi gestire questa situazione seguendo i passaggi indicati di seguito:

• Utilizzare SHOW CREATE TABLE per ottenere un'istruzione CREATE TABLE che specifica la struttura, gli indici e tutto il resto della tabella di origine.

• Modificare l'istruzione per cambiare il nome della tabella in quello della tabella clone ed eseguire l'istruzione. In questo modo, avrai la tabella esatta dei cloni.

• Facoltativamente, se è necessario copiare anche il contenuto della tabella, emettere anche un'istruzione INSERT INTO ... SELECT.

Esempio

Prova il seguente esempio per creare una tabella clone per tutorials_tbl.

Step 1 - Ottieni la struttura completa del tavolo.

mysql> SHOW CREATE TABLE tutorials_tbl \G;
*************************** 1. row ***************************
      Table: tutorials_tbl
Create Table: CREATE TABLE `tutorials_tbl` (
   `tutorial_id` int(11) NOT NULL auto_increment,
   `tutorial_title` varchar(100) NOT NULL default '',
   `tutorial_author` varchar(40) NOT NULL default '',
   `submission_date` date default NULL,
   PRIMARY KEY  (`tutorial_id`),
   UNIQUE KEY `AUTHOR_INDEX` (`tutorial_author`)
) TYPE = MyISAM
1 row in set (0.00 sec)

ERROR:
No query specified

Step 2 - Rinomina questa tabella e crea un'altra tabella.

mysql> CREATE TABLE clone_tbl (
   -> tutorial_id int(11) NOT NULL auto_increment,
   -> tutorial_title varchar(100) NOT NULL default '',
   -> tutorial_author varchar(40) NOT NULL default '',
   -> submission_date date default NULL,
   -> PRIMARY KEY  (tutorial_id),
   -> UNIQUE KEY AUTHOR_INDEX (tutorial_author)
-> ) TYPE = MyISAM;
Query OK, 0 rows affected (1.80 sec)

Step 3- Dopo aver eseguito il passaggio 2, creerai una tabella clone nel tuo database. Se si desidera copiare i dati dalla vecchia tabella, è possibile farlo utilizzando l'istruzione INSERT INTO ... SELECT.

mysql> INSERT INTO clone_tbl (tutorial_id,
   -> tutorial_title,
   -> tutorial_author,
   -> submission_date)
   
   -> SELECT tutorial_id,tutorial_title,
   -> tutorial_author,submission_date
   -> FROM tutorials_tbl;
Query OK, 3 rows affected (0.07 sec)
Records: 3  Duplicates: 0  Warnings: 0

Infine, avrai una tabella di clonazione esatta come volevi.

Ottenere e utilizzare i metadati di MySQL

Ci sono tre tipi di informazioni, che vorresti avere da MySQL.

• Information about the result of queries - Questo include il numero di record interessati da qualsiasi istruzione SELECT, UPDATE o DELETE.

• Information about the tables and databases - Ciò include le informazioni relative alla struttura delle tabelle e dei database.

• Information about the MySQL server - Ciò include lo stato del server del database, il numero di versione, ecc.

È molto facile ottenere tutte queste informazioni al prompt di MySQL, ma mentre si utilizzano API PERL o PHP, è necessario chiamare esplicitamente varie API per ottenere tutte queste informazioni.

Ottenere il numero di righe interessate da una query

Vediamo ora come ottenere queste informazioni.

Esempio PERL

Negli script DBI, il conteggio delle righe interessate viene restituito da do( ) o dal execute( ) comando, a seconda di come si esegue la query.

# Method 1
# execute $query using do( )
my $count = $dbh->do ($query); # report 0 rows if an error occurred printf "%d rows were affected\n", (defined ($count) ? $count : 0); # Method 2 # execute query using prepare( ) plus execute( ) my $sth = $dbh->prepare ($query);
my $count = $sth->execute ( );
printf "%d rows were affected\n", (defined ($count) ? $count : 0);

Esempio PHP

In PHP, invoca il mysql_affected_rows( ) funzione per scoprire quante righe è stata modificata una query.

$result_id = mysql_query ($query, $conn_id); # report 0 rows if the query failed $count = ($result_id ? mysql_affected_rows ($conn_id) : 0);
print ("$count rows were affected\n");

Elenco di tabelle e database

È molto facile elencare tutti i database e le tabelle disponibili con un server di database. Il tuo risultato potrebbe esserenull se non disponi dei privilegi sufficienti.

Oltre al metodo mostrato nel seguente blocco di codice, puoi usare SHOW TABLES o SHOW DATABASES query per ottenere l'elenco di tabelle o database in PHP o in PERL.

Esempio PERL

# Get all the tables available in current database.
my @tables = $dbh->tables ( );

foreach $table (@tables ){ print "Table Name $table\n";
}

Esempio PHP

<?php
   $con = mysql_connect("localhost", "userid", "password"); if (!$con) {
      die('Could not connect: ' . mysql_error());
   }
   $db_list = mysql_list_dbs($con);

   while ($db = mysql_fetch_object($db_list)) {
      echo $db->Database . "<br />"; } mysql_close($con);
?>

Recupero dei metadati del server

Ci sono alcuni comandi importanti in MySQL che possono essere eseguiti al prompt di MySQL o utilizzando qualsiasi script come PHP per ottenere varie informazioni importanti sul server del database.

Sr.No.	Comando e descrizione
1	SELECT VERSION( ) Stringa della versione del server
2	SELECT DATABASE( ) Nome database corrente (vuoto se nessuno)
3	SELECT USER( ) Nome utente corrente
4	SHOW STATUS Indicatori di stato del server
5	SHOW VARIABLES Variabili di configurazione del server

Una sequenza è un insieme di numeri interi 1, 2, 3, ... che vengono generati in ordine su una specifica richiesta. Le sequenze vengono utilizzate frequentemente nei database perché molte applicazioni richiedono che ogni riga di una tabella contenga un valore univoco e le sequenze forniscono un modo semplice per generarle.

Questo capitolo descrive come usare le sequenze in MySQL.

Utilizzo della colonna AUTO_INCREMENT

Il modo più semplice in MySQL per utilizzare le sequenze è definire una colonna come AUTO_INCREMENT e lascia che le cose rimanenti si occupino di MySQL.

Esempio

Prova il seguente esempio. Questo creerà una tabella e successivamente inserirà alcune righe in questa tabella in cui non è necessario fornire l'ID del record perché viene incrementato automaticamente da MySQL.

mysql> CREATE TABLE insect
   -> (
   -> id INT UNSIGNED NOT NULL AUTO_INCREMENT,
   -> PRIMARY KEY (id),
   -> name VARCHAR(30) NOT NULL, # type of insect
   -> date DATE NOT NULL, # date collected
   -> origin VARCHAR(30) NOT NULL # where collected
);
Query OK, 0 rows affected (0.02 sec)
mysql> INSERT INTO insect (id,name,date,origin) VALUES
   -> (NULL,'housefly','2001-09-10','kitchen'),
   -> (NULL,'millipede','2001-09-10','driveway'),
   -> (NULL,'grasshopper','2001-09-10','front yard');
Query OK, 3 rows affected (0.02 sec)
Records: 3  Duplicates: 0  Warnings: 0
mysql> SELECT * FROM insect ORDER BY id;
+----+-------------+------------+------------+
| id |    name     |    date    |   origin   |
+----+-------------+------------+------------+
|  1 |  housefly   | 2001-09-10 |   kitchen  |
|  2 |  millipede  | 2001-09-10 |  driveway  |
|  3 | grasshopper | 2001-09-10 | front yard |
+----+-------------+------------+------------+
3 rows in set (0.00 sec)

Ottieni valori AUTO_INCREMENT

Il LAST_INSERT_ID( )è una funzione SQL, quindi puoi usarla da qualsiasi client che capisca come emettere istruzioni SQL. Altrimenti, gli script PERL e PHP forniscono funzioni esclusive per recuperare il valore incrementato automaticamente dell'ultimo record.

Esempio PERL

Utilizzare il mysql_insertid attributo per ottenere il AUTO_INCREMENTvalore generato da una query. Questo attributo è accessibile tramite un handle di database o un handle di istruzione, a seconda di come si invia la query.

L'esempio seguente fa riferimento a esso tramite l'handle del database.

$dbh->do ("INSERT INTO insect (name,date,origin) VALUES('moth','2001-09-14','windowsill')"); my $seq = $dbh->{mysql_insertid};

Esempio PHP

Dopo aver inviato una query che genera un valore AUTO_INCREMENT, recuperare il valore chiamando il mysql_insert_id( ) comando.

mysql_query ("INSERT INTO insect (name,date,origin)
VALUES('moth','2001-09-14','windowsill')", $conn_id);
$seq = mysql_insert_id ($conn_id);

Rinumerare una sequenza esistente

Potrebbe verificarsi un caso in cui sono stati eliminati molti record da una tabella e si desidera ripetere la sequenza di tutti i record. Questo può essere fatto usando un semplice trucco, ma dovresti stare molto attento a farlo se il tuo tavolo si unisce con l'altro tavolo.

Se si determina che il risequenziamento di una colonna AUTO_INCREMENT è inevitabile, il modo per farlo è eliminare la colonna dalla tabella, quindi aggiungerla di nuovo.

L'esempio seguente mostra come rinumerare il file id values nella tabella utilizzando questa tecnica.

mysql> ALTER TABLE insect DROP id;
mysql> ALTER TABLE insect
   -> ADD id INT UNSIGNED NOT NULL AUTO_INCREMENT FIRST,
   -> ADD PRIMARY KEY (id);

Avvio di una sequenza a un valore particolare

Per impostazione predefinita, MySQL inizierà la sequenza da 1, ma puoi specificare anche qualsiasi altro numero al momento della creazione della tabella.

Il seguente programma è un esempio che mostra come MySQL inizierà la sequenza da 100.

mysql> CREATE TABLE insect
   -> (
   -> id INT UNSIGNED NOT NULL AUTO_INCREMENT = 100,
   -> PRIMARY KEY (id),
   -> name VARCHAR(30) NOT NULL, # type of insect
   -> date DATE NOT NULL, # date collected
   -> origin VARCHAR(30) NOT NULL # where collected
);

In alternativa, puoi creare la tabella e quindi impostare il valore della sequenza iniziale con il ALTER TABLE comando.

mysql> ALTER TABLE t AUTO_INCREMENT = 100;

In genere, tabelle o set di risultati a volte contengono record duplicati. La maggior parte delle volte è consentito, ma a volte è necessario interrompere i record duplicati. È necessario identificare i record duplicati e rimuoverli dalla tabella. Questo capitolo descriverà come prevenire il verificarsi di record duplicati in una tabella e come rimuovere i record duplicati già esistenti.

Prevenire la presenza di duplicati in una tabella

Puoi usare un file PRIMARY KEY o a UNIQUE Indice su una tabella con i campi appropriati per interrompere i record duplicati.

Facciamo un esempio: la tabella seguente non contiene tale indice o chiave primaria, quindi consentirebbe record duplicati per first_name e last_name.

CREATE TABLE person_tbl (
   first_name CHAR(20),
   last_name CHAR(20),
   sex CHAR(10)
);

Per evitare che più record con gli stessi valori di nome e cognome vengano creati in questa tabella, aggiungi un file PRIMARY KEYalla sua definizione. Quando si esegue questa operazione, è anche necessario dichiarare che le colonne indicizzate sianoNOT NULL, perché a PRIMARY KEY non permette NULL valori -

CREATE TABLE person_tbl (
   first_name CHAR(20) NOT NULL,
   last_name CHAR(20) NOT NULL,
   sex CHAR(10),
   PRIMARY KEY (last_name, first_name)
);

La presenza di un indice univoco in una tabella normalmente causa un errore se si inserisce un record nella tabella che duplica un record esistente nella colonna o nelle colonne che definiscono l'indice.

Utilizzare il INSERT IGNORE comando piuttosto che il INSERTcomando. Se un record non duplica un record esistente, MySQL lo inserisce come al solito. Se il record è un duplicato, il fileIGNORE parola chiave dice a MySQL di scartarlo silenziosamente senza generare un errore.

L'esempio seguente non presenta errori e allo stesso tempo non inserirà anche record duplicati.

mysql> INSERT IGNORE INTO person_tbl (last_name, first_name)
   -> VALUES( 'Jay', 'Thomas');
Query OK, 1 row affected (0.00 sec)

mysql> INSERT IGNORE INTO person_tbl (last_name, first_name)
   -> VALUES( 'Jay', 'Thomas');
Query OK, 0 rows affected (0.00 sec)

Utilizzare il REPLACEcomando piuttosto che il comando INSERT. Se il record è nuovo, viene inserito come con INSERT. Se è un duplicato, il nuovo record sostituisce quello vecchio.

mysql> REPLACE INTO person_tbl (last_name, first_name)
   -> VALUES( 'Ajay', 'Kumar');
Query OK, 1 row affected (0.00 sec)

mysql> REPLACE INTO person_tbl (last_name, first_name)
   -> VALUES( 'Ajay', 'Kumar');
Query OK, 2 rows affected (0.00 sec)

I comandi INSERT IGNORE e REPLACE devono essere scelti in base al comportamento di gestione dei duplicati che si desidera applicare. Il comando INSERT IGNORE conserva il primo set di record duplicati e scarta i restanti. Il comando REPLACE mantiene l'ultimo set di duplicati e cancella quelli precedenti.

Un altro modo per rafforzare l'unicità è aggiungere un file UNIQUE indice piuttosto che una CHIAVE PRIMARIA a una tabella.

CREATE TABLE person_tbl (
   first_name CHAR(20) NOT NULL,
   last_name CHAR(20) NOT NULL,
   sex CHAR(10)
   UNIQUE (last_name, first_name)
);

Conteggio e identificazione dei duplicati

Di seguito è riportata la query per contare i record duplicati con first_name e last_name in una tabella.

mysql> SELECT COUNT(*) as repetitions, last_name, first_name
   -> FROM person_tbl
   -> GROUP BY last_name, first_name
   -> HAVING repetitions > 1;

Questa query restituirà un elenco di tutti i record duplicati nella tabella person_tbl. In generale, per identificare gli insiemi di valori duplicati, seguire i passaggi indicati di seguito.

• Determina quali colonne contengono i valori che possono essere duplicati.

• Elenca quelle colonne nell'elenco di selezione delle colonne, insieme al file COUNT(*).

• Elenca le colonne nel file GROUP BY clausola pure.

• Aggiungere un HAVING clausola che elimina i valori univoci richiedendo che i conteggi del gruppo siano maggiori di uno.

Eliminazione dei duplicati dal risultato di una query

Puoi usare il file DISTINCT insieme all'istruzione SELECT per scoprire i record univoci disponibili in una tabella.

mysql> SELECT DISTINCT last_name, first_name
   -> FROM person_tbl
   -> ORDER BY last_name;

Un'alternativa al comando DISTINCT consiste nell'aggiungere una clausola GROUP BY che denomina le colonne che si stanno selezionando. Ciò ha l'effetto di rimuovere i duplicati e selezionare solo le combinazioni univoche di valori nelle colonne specificate.

mysql> SELECT last_name, first_name
   -> FROM person_tbl
   -> GROUP BY (last_name, first_name);

Rimozione dei duplicati utilizzando la sostituzione della tabella

Se hai record duplicati in una tabella e desideri rimuovere tutti i record duplicati da quella tabella, segui la procedura indicata di seguito.

mysql> CREATE TABLE tmp SELECT last_name, first_name, sex
   -> FROM person_tbl;
   -> GROUP BY (last_name, first_name);

mysql> DROP TABLE person_tbl;
mysql> ALTER TABLE tmp RENAME TO person_tbl;

Un modo semplice per rimuovere i record duplicati da una tabella consiste nell'aggiungere un INDICE o una CHIAVE PRIMARIA a quella tabella. Anche se questa tabella è già disponibile, puoi utilizzare questa tecnica per rimuovere i record duplicati e sarai al sicuro anche in futuro.

mysql> ALTER IGNORE TABLE person_tbl
   -> ADD PRIMARY KEY (last_name, first_name);

Se prendi l'input dell'utente attraverso una pagina web e lo inserisci in un database MySQL, c'è la possibilità che ti sei lasciato aperto per un problema di sicurezza noto come SQL Injection. Questo capitolo ti insegnerà come evitare che ciò accada e ti aiuterà a proteggere i tuoi script e le istruzioni MySQL.

L'SQL Injection di solito si verifica quando chiedi un input a un utente, come il suo nome e invece di un nome ti danno un'istruzione MySQL che eseguirai inconsapevolmente sul tuo database.

Non fidarti mai dei dati forniti da un utente, elabora questi dati solo dopo la convalida; di regola, questo viene fatto dalla corrispondenza del modello. Nell'esempio seguente, il nome utente è limitato a caratteri alfanumerici più trattino basso e una lunghezza compresa tra 8 e 20 caratteri: modificare queste regole secondo necessità.

if (preg_match("/^\w{8,20}$/", $_GET['username'], $matches)) { $result = mysql_query("SELECT * FROM users WHERE username = $matches[0]");
} else  {
   echo "username not accepted";
}

Per dimostrare questo problema, considera il seguente estratto.

// supposed input
$name = "Qadir'; DELETE FROM users;";
mysql_query("SELECT * FROM users WHERE name = '{$name}'");

La chiamata alla funzione dovrebbe recuperare un record dalla tabella degli utenti, dove la colonna del nome corrisponde al nome specificato dall'utente. In circostanze normali, $ name conterrebbe solo caratteri alfanumerici e forse spazi. Ma qui, aggiungendo una query completamente nuova a$name, la chiamata al database si trasforma in un disastro. La query DELETE inserita rimuove tutti i record dagli utenti.

Fortunatamente, se usi MySQL, il file mysql_query()funzione non consente lo stacking di query o l'esecuzione di più query in una singola chiamata di funzione. Se si tenta di impilare le query, la chiamata non riesce.

Tuttavia, altre estensioni di database PHP, come SQLite e PostgreSQL, esegue felicemente query impilate, eseguendo tutte le query fornite in una stringa e creando un serio problema di sicurezza.

Prevenire SQL Injection

Puoi gestire tutti i caratteri di escape in modo intelligente nei linguaggi di scripting come PERL e PHP. L'estensione MySQL per PHP fornisce la funzionemysql_real_escape_string() per sfuggire ai caratteri di input che sono speciali per MySQL.

if (get_magic_quotes_gpc()) {
   $name = stripslashes($name); } $name = mysql_real_escape_string($name); mysql_query("SELECT * FROM users WHERE name = '{$name}'");

Il dilemma LIKE

Per risolvere il dilemma LIKE, un meccanismo di escape personalizzato deve convertire i caratteri% e _ forniti dall'utente in letterali. Usoaddcslashes(), una funzione che consente di specificare un intervallo di caratteri di cui eseguire l'escape.

$sub = addcslashes(mysql_real_escape_string("%something_"), "%_"); // $sub == \%something\_
mysql_query("SELECT * FROM messages WHERE subject LIKE '{$sub}%'");

Il modo più semplice per esportare i dati di una tabella in un file di testo è utilizzare l'estensione SELECT...INTO OUTFILE istruzione che esporta il risultato di una query direttamente in un file sull'host del server.

Esportazione di dati con l'istruzione SELECT ... INTO OUTFILE

La sintassi per questa istruzione combina un normale SELECT comando con INTO OUTFILE filenamealla fine. Il formato di output predefinito è lo stesso del comando LOAD DATA. Quindi, la seguente istruzione esporta il filetutorials_tbl tabella in /tmp/tutorials.txt come un file delimitato da tabulazioni, con interruzione di riga.

mysql> SELECT * FROM tutorials_tbl 
   -> INTO OUTFILE '/tmp/tutorials.txt';

È possibile modificare il formato di output utilizzando varie opzioni per indicare come citare e delimitare colonne e record. Per esportare la tabella tutorial_tbl in un formato CSV con righe con terminazione CRLF, utilizzare il codice seguente.

mysql> SELECT * FROM passwd INTO OUTFILE '/tmp/tutorials.txt'
   -> FIELDS TERMINATED BY ',' ENCLOSED BY '"'
   -> LINES TERMINATED BY '\r\n';

Il SELECT ... INTO OUTFILE ha le seguenti proprietà:

• Il file di output viene creato direttamente dal server MySQL, quindi il nome del file dovrebbe indicare dove si desidera che il file venga scritto sull'host del server. Non esiste una versione LOCALE dell'istruzione analoga aLOCAL versione di LOAD DATA.

• Devi avere il file MySQL FILE privilegio per eseguire il SELECT ... INTO dichiarazione.

• Il file di output non deve esistere già. Ciò impedisce a MySQL di distruggere file che potrebbero essere importanti.

• Dovresti avere un account di accesso sull'host del server o un modo per recuperare il file da quell'host. Altrimenti, il fileSELECT ... INTO OUTFILE molto probabilmente non avrà alcun valore per te.

• In UNIX, il file viene creato world readableed è di proprietà del server MySQL. Ciò significa che anche se sarai in grado di leggere il file, potresti non essere in grado di eliminarlo.

Esportazione di tabelle come dati grezzi

Il mysqldumpviene utilizzato per copiare o eseguire il backup di tabelle e database. Può scrivere l'output della tabella come fileRaw Datafile o come un insieme di INSERT istruzioni che ricreano i record nella tabella.

Per eseguire il dump di una tabella come file di dati, è necessario specificare un file --tab opzione che indica la directory in cui desideri che il server MySQL scriva il file.

Ad esempio, per scaricare il file tutorials_tbl tabella dal TUTORIALS database in un file in /tmp directory, utilizzare un comando come mostrato di seguito.

$ mysqldump -u root -p --no-create-info \
   --tab=/tmp tutorials tutorials_tbl
password ******

Esportazione del contenuto della tabella o delle definizioni in formato SQL

Per esportare una tabella in formato SQL in un file, utilizzare il comando mostrato di seguito.

$ mysqldump -u root -p TUTORIALS tutorials_tbl > dump.txt
password ******

Questo creerà un file con contenuto come mostrato di seguito.

-- MySQL dump 8.23
--
-- Host: localhost    Database: TUTORIALS
---------------------------------------------------------
-- Server version       3.23.58

--
-- Table structure for table `tutorials_tbl`
--

CREATE TABLE tutorials_tbl (
   tutorial_id int(11) NOT NULL auto_increment,
   tutorial_title varchar(100) NOT NULL default '',
   tutorial_author varchar(40) NOT NULL default '',
   submission_date date default NULL,
   PRIMARY KEY  (tutorial_id),
   UNIQUE KEY AUTHOR_INDEX (tutorial_author)
) TYPE = MyISAM;

--
-- Dumping data for table `tutorials_tbl`
--

INSERT INTO tutorials_tbl 
   VALUES (1,'Learn PHP','John Poul','2007-05-24');
INSERT INTO tutorials_tbl 
   VALUES (2,'Learn MySQL','Abdul S','2007-05-24');
INSERT INTO tutorials_tbl 
   VALUES (3,'JAVA Tutorial','Sanjay','2007-05-06');

Per eseguire il dump di più tabelle, denominarle tutte seguito dall'argomento del nome del database. Per eseguire il dump di un intero database, non denominare alcuna tabella dopo il database come mostrato nel seguente blocco di codice.

$ mysqldump -u root -p TUTORIALS > database_dump.txt
password ******

Per eseguire il backup di tutti i database disponibili sull'host, utilizzare il codice seguente.

$ mysqldump -u root -p --all-databases > database_dump.txt
password ******

L'opzione --all-databases è disponibile nella versione MySQL 3.23.12. Questo metodo può essere utilizzato per implementare una strategia di backup del database.

Copia di tabelle o database su un altro host

Se desideri copiare tabelle o database da un server MySQL a un altro, utilizza l'estensione mysqldump con nome database e nome tabella.

Esegui il seguente comando sull'host di origine. Questo scaricherà il database completo indump.txt file.

$ mysqldump -u root -p database_name table_name > dump.txt
password *****

È possibile copiare il database completo senza utilizzare un nome di tabella particolare come spiegato sopra.

Ora, ftp dump.txt file su un altro host e utilizzare il seguente comando. Prima di eseguire questo comando, assicurati di aver creato database_name sul server di destinazione.

$ mysql -u root -p database_name < dump.txt
password *****

Un altro modo per ottenere ciò senza utilizzare un file intermedio è inviare l'output di mysqldump direttamente sulla rete al server MySQL remoto. Se è possibile connettersi a entrambi i server dall'host in cui risiede il database di origine, utilizzare il comando seguente (assicurarsi di avere accesso su entrambi i server).

$ mysqldump -u root -p database_name \
   | mysql -h other-host.com database_name

In mysqldump, metà del comando si connette al server locale e scrive l'output del dump sulla pipe. La restante metà del comando si connette al server MySQL remoto su other-host.com. Legge la pipe per l'input e invia ogni istruzione al server other-host.com.

Ci sono due semplici modi in MySQL per caricare i dati nel database MySQL da un file precedentemente sottoposto a backup.

Importazione di dati con LOAD DATA

MySQL fornisce un'istruzione LOAD DATA che funge da caricatore di dati di massa. Ecco un'istruzione di esempio che legge un filedump.txt dalla directory corrente e lo carica nella tabella mytbl nel database corrente.

mysql> LOAD DATA LOCAL INFILE 'dump.txt' INTO TABLE mytbl;

• Se la LOCAL la parola chiave non è presente, MySQL cerca il file di dati sull'host del server utilizzando l'estensione looking into absolute pathname, che specifica completamente la posizione del file, a partire dalla radice del filesystem. MySQL legge il file dalla posizione specificata.

• Per impostazione predefinita, LOAD DATA presume che i file di dati contengano righe terminate da avanzamenti riga (newline) e che i valori dei dati all'interno di una riga siano separati da tabulazioni.

• Per specificare un formato di file in modo esplicito, utilizzare un file FIELDS clausola per descrivere le caratteristiche dei campi all'interno di una riga e a LINESclausola per specificare la sequenza di fine riga. Il seguenteLOAD DATA L'istruzione specifica che il file di dati contiene valori separati da due punti e righe terminate da ritorni a capo e nuovo carattere di riga.

mysql> LOAD DATA LOCAL INFILE 'dump.txt' INTO TABLE mytbl
   -> FIELDS TERMINATED BY ':'
   -> LINES TERMINATED BY '\r\n';

• Il comando LOAD DATA presuppone che le colonne nel file di dati abbiano lo stesso ordine delle colonne nella tabella. Se ciò non è vero, è possibile specificare un elenco per indicare in quali colonne della tabella devono essere caricate le colonne del file di dati. Supponi che la tua tabella abbia le colonne a, be c, ma le colonne successive nel file di dati corrispondano alle colonne b, c e a.

È possibile caricare il file come mostrato nel seguente blocco di codice.

mysql> LOAD DATA LOCAL INFILE 'dump.txt' 
   -> INTO TABLE mytbl (b, c, a);

Importazione di dati con mysqlimport

MySQL include anche un programma di utilità denominato mysqlimport che funge da wrapper attorno a LOAD DATA, in modo da poter caricare i file di input direttamente dalla riga di comando.

Per caricare i dati da dump.txt in mytbl, utilizzare il seguente comando al prompt di UNIX.

$ mysqlimport -u root -p --local database_name dump.txt
password *****

Se usi mysqlimport, le opzioni della riga di comando forniscono gli specificatori di formato. Ilmysqlimport comandi che corrispondono ai due precedenti LOAD DATA le istruzioni hanno l'aspetto mostrato nel seguente blocco di codice.

$ mysqlimport -u root -p --local --fields-terminated-by = ":" \
   --lines-terminated-by = "\r\n"  database_name dump.txt
password *****

L'ordine in cui specifichi le opzioni non ha importanza per mysqlimport, tranne per il fatto che dovrebbero precedere tutte il nome del database.

Il mysqlimport l'istruzione utilizza l'estensione --columns opzione per specificare l'ordine delle colonne -

$ mysqlimport -u root -p --local --columns=b,c,a \
   database_name dump.txt
password *****

Gestione di citazioni e caratteri speciali

La clausola FIELDS può inoltre specificare altre opzioni di formato TERMINATED BY. Per impostazione predefinita, LOAD DATA presuppone che i valori non siano quotati e interpreta la barra rovesciata (\) come un carattere di escape per i caratteri speciali. Per indicare esplicitamente il carattere di citazione del valore, utilizzare ilENCLOSED BYcomando. MySQL eliminerà quel carattere dalle estremità dei valori dei dati durante l'elaborazione dell'input. Per modificare il carattere di escape predefinito, utilizzareESCAPED BY.

Quando si specifica ENCLOSED BY per indicare che le virgolette devono essere rimosse dai valori dei dati, è possibile includere le virgolette letteralmente all'interno dei valori dei dati raddoppiandole o precedendole con il carattere di escape.

Ad esempio, se le virgolette e i caratteri di escape sono "e \, il valore di input "a""b\"c" sarà interpretato come a"b"c.

Per mysqlimport, le opzioni della riga di comando corrispondenti per specificare i valori di virgolette e di escape sono --fields-enclosed-by e --fields-escaped-by.