Come utilizzare le viste in un database MySQL

Una vista in MySQL è una query denominata che può essere attivata per visualizzare i dati archiviati in altre tabelle. In altre parole, le viste sono tabelle virtuali definite dall'utente. Le visualizzazioni possono essere utilizzate per:

Migliora la sicurezza del database. Se il database contiene informazioni riservate che devono essere protette, l'utilizzo di una vista consente di isolare i dati. È possibile creare una vista con un set di risultati predefinito e concedere agli utenti l'accesso solo a quella vista, anziché alla tabella che contiene informazioni riservate.
Sposta la logica aziendale complessa sul server del database. Invece di codificare la logica software utilizzata di frequente in client diversi, uno sviluppatore può spostare la logica a livello di database utilizzando una vista. Ad esempio, è possibile creare una vista per visualizzare le classificazioni dei clienti in base alle loro vendite totali.
Riduci la distrazione dei dati. Una vista può combinare risultati di tabelle diverse e visualizzare solo le colonne pertinenti quando viene richiamata.

In questa guida imparerai:

Come è strutturata la sintassi di una vista MySQL.
Come creare una vista MySQL.
Come richiamare una vista MySQL.
Come eliminare una vista in MySQL.

Prima di iniziare

Per seguire questa guida, assicurati di avere quanto segue:

Un Linode, su cui esegui il software MySQL. Puoi seguire la guida introduttiva a Linode per eseguire il provisioning di un Linode.
Il software del server MySQL (o MariaDB) installato sul tuo Linode. Fare riferimento alla sezione MySQL, che contiene guide che descrivono come installare MySQL su diverse distribuzioni Linux.

Preparazione del database

Prima di creare le tue viste MySQL, crea un database di esempio, definisci alcune tabelle e popolale prima con alcuni dati:

SSH al tuo Linode. Quindi, inserisci questo comando per accedere a MySQL come utente root:
```
mysql -u root -p
```
Quando richiesto, inserisci la password di root del tuo server MySQL e premi Invio per continuare.
Nota
Se la tua password non viene accettata, potresti dover eseguire il comando precedente con sudo :
```
sudo mysql -u root -p
```
Se la tua password viene accettata, dovresti vedere il prompt di MySQL:
```
mysql >
```
Nota
Se stai usando MariaDB, potresti invece visualizzare un messaggio come il seguente:
```
MariaDB [(none)]>
```
Quindi, esegui questo comando SQL per creare un database di esempio denominato sample_database :
```
CREATE DATABASE sample_database;
```
Dovresti vedere questo output, che conferma che il database è stato creato correttamente:
```
Query OK, 1 row affected (0.02 sec)
```
Seleziona il sample_database banca dati:
```
USE sample_database;
```
Dovresti vedere questo output:
```
Database changed
```

Esegui questo comando per creare un customers tabella:

 CREATE TABLE customers
 (
 customer_id BIGINT PRIMARY KEY AUTO_INCREMENT,
 customer_name VARCHAR(50)
 ) ENGINE = InnoDB;

Dovresti vedere questo output:


Query OK, 0 rows affected (0.07 sec)

Successivamente, compila i customers tabella con tre record. Esegui il seguente INSERT comandi uno per uno:

INSERT INTO customers (customer_name) VALUES ('Leslie');
INSERT INTO customers (customer_name) VALUES ('Andy');
INSERT INTO customers (customer_name) VALUES ('Ben');

L'output seguente viene mostrato dopo l'inserimento di ogni record:


Query OK, 1 row affected (0.08 sec)
...

Assicurati che i record di esempio siano stati inseriti nel database eseguendo questo SELECT comando:

SELECT * FROM customers;

Viene visualizzato questo output, che conferma che i dati sono stati inseriti correttamente nel passaggio precedente:


+-------------+---------------+
| customer_id | customer_name |
+-------------+---------------+
|           1 | Leslie        |
|           2 | Andy          |
|           3 | Ben           |
+-------------+---------------+
3 rows in set (0.01 sec)

Quindi, crea un sales tavolo. Esegui questo comando:

 CREATE TABLE sales
 (
 customer_id BIGINT PRIMARY KEY AUTO_INCREMENT,
 monthly_sales DECIMAL(17,2)
 ) ENGINE = InnoDB;

Viene visualizzato questo output:


Query OK, 0 rows affected (0.07 sec)

Quindi, aggiungi alcuni dati alle sales tavolo. Esegui questi comandi uno per uno:

INSERT INTO sales (customer_id, monthly_sales) VALUES ('1','500.27');
INSERT INTO sales (customer_id, monthly_sales) VALUES ('2','7600.32');
INSERT INTO sales (customer_id, monthly_sales) VALUES ('3', '25879.63');

Dopo aver inserito ogni record di vendita, viene visualizzato questo output:


Query OK, 1 row affected (0.01 sec)
...

Quindi, esegui un SELECT query per verificare che i dati di vendita siano stati inseriti nella tabella:

SELECT * FROM sales;

Viene visualizzato questo output, che conferma che i dati di vendita sono stati inseriti correttamente nel passaggio precedente:




+-------------+---------------+
| customer_id | monthly_sales |
+-------------+---------------+
|           1 |        500.27 |
|           2 |       7600.32 |
|           3 |      25879.63 |
+-------------+---------------+
3 rows in set (0.00 sec)

Hai definito il database e le tabelle su cui lavorare. La sezione successiva descrive la sintassi di una vista MySQL.

La sintassi di MySQL View

Questa è una versione semplificata della sintassi della vista MySQL:

    CREATE
    VIEW view_name
    AS select_statement

view_name :Il nome della vista MySQL deve essere definito qui. Si consiglia di utilizzare un nome descrittivo in modo da poter ricordare in seguito la funzione della vista.
select_statement :questa è la query SQL associata alla vista definita. Quando viene richiamata la vista, MySQL esegue questa query per restituire un recordset.

Creazione di una vista MySQL

Questa sezione presenta un esempio di vista MySQL. Questa visualizzazione viene utilizzata per classificare i clienti dal database di esempio, in base al numero di vendite mensili.

Assicurati di aver effettuato l'accesso al tuo server MySQL. Quindi, esegui il comando seguente per creare un customers_membership visualizza:

CREATE
VIEW customers_membership
AS SELECT sales.customer_id,
customer_name,
(IF(sales.monthly_sales >= 5000, 'PREMIUM', 'BASIC')) as membership
FROM sales
LEFT JOIN customers
ON sales.customer_id = customers.customer_id;

Se la vista viene creata correttamente, dovresti vedere l'output mostrato di seguito:


Query OK, 0 rows affected (0.01 sec)

Il comando MySQL sopra crea una vista denominata customers_membership che si unisce ai customers e sales tabella con la PRIMARY KEY customer_id . La logica IF(expression, value_if_true, value_if_false) la logica di istruzione viene utilizzata per determinare l'appartenenza del cliente dalle sue vendite mensili:

Se le vendite di un cliente sono uguali o superiori a 5.000, la vista classifica il cliente come PREMIUM membro.
Altrimenti (se le vendite sono inferiori a 5,000 ), il cliente è classificato come BASIC membro.

Il customers_membership la vista è ora salvata nel database. La sezione successiva mostra come chiamare una vista MySQL e visualizzare un recordset senza interrogare direttamente le tabelle di base.

Invocare una vista MySQL

Questa sezione mostra come richiamare la vista MySQL che hai creato sopra e confermare che funzioni come previsto. Una volta creata, una vista è visibile come oggetto di database e può essere richiamata utilizzando il SELECT dichiarazione.

Per invocare il customers_membership visualizza, esegui:
```
SELECT * FROM customers_membership;
```
Se la visualizzazione funziona come previsto, ora dovresti vedere un elenco di clienti con la loro membership generata valori in base alle loro vendite. Da Leslie le vendite del cliente erano inferiori a 5000 (500,27), la vista mostra l'appartenenza del cliente come BASIC . Andy e Ben le vendite di 7600.32 e 25879.63 sono state rispettivamente di 7600.32 e 25879.63 e questo le rende PREMIUM membri:
```
+-------------+---------------+------------+
| customer_id | customer_name | membership |
+-------------+---------------+------------+
|           1 | Leslie        | BASIC      |
|           2 | Andy          | PREMIUM    |
|           3 | Ben           | PREMIUM    |
+-------------+---------------+------------+
3 rows in set (0.00 sec)
```
Una volta aggiornati i dati di una tabella di base e richiamata una vista MySQL, dovresti vedere le informazioni più recenti. Le viste estraggono informazioni dalle loro tabelle di base e non memorizzano i dati. Per dimostrare come una vista estrae informazioni aggiornate dalle tabelle di base, aggiungi un altro cliente denominato Rajie ai customers tabella:
```
INSERT INTO customers (customer_name) VALUES ('Rajie');
```
Viene visualizzato questo output:
```
Query OK, 1 row affected (0.01 sec)
```
Quindi, aggiungi le informazioni sulle vendite mensili del cliente alla tabella delle vendite:
```
INSERT INTO sales (customer_id, monthly_sales) VALUES ('4', '147.41');
```
Viene visualizzato questo output:
```
Query OK, 1 row affected (0.01 sec)
```

Quindi, invoca customers_membership guarda di nuovo:

SELECT * FROM customers_membership;

Viene visualizzato l'output di seguito, che conferma che la vista è in grado di raccogliere le modifiche e recuperare le informazioni sui nuovi clienti come previsto:


+-------------+---------------+------------+
| customer_id | customer_name | membership |
+-------------+---------------+------------+
|           1 | Leslie        | BASIC      |
|           2 | Andy          | PREMIUM    |
|           3 | Ben           | PREMIUM    |
|           4 | Rajie         | BASIC      |
+-------------+---------------+------------+
4 rows in set (0.00 sec)

Come puoi vedere nel recordset della vista sopra, ora hai un nuovo cliente chiamato Rajie con un BASIC appartenenza.

Eliminazione di una vista MySQL

Proprio come altri oggetti di database, puoi eliminare le viste se non ne hai più bisogno. Questa è la sintassi di base per eliminare una vista MySQL:

    DROP VIEW IF EXISTS view_name;

Prima di eliminare una vista MySQL, identificane il nome eseguendo il comando seguente:

SHOW FULL TABLES WHERE TABLE_TYPE LIKE 'VIEW';

Viene visualizzato un elenco di tutte le viste nel database attualmente selezionato:


+---------------------------+------------+
| Tables_in_sample_database | Table_type |
+---------------------------+------------+
| customers_membership      | VIEW       |
+---------------------------+------------+
1 row in set (0.01 sec)

In questo caso, il nome della vista che vuoi eliminare è customers_membership . Quindi, per eliminarlo, esegui:
```
DROP VIEW IF EXISTS customers_membership;
```
Assicurati che l'output di seguito venga visualizzato dopo che la vista è stata eliminata dal database:
```
Query OK, 0 rows affected (0.01 sec)
```
Nota Nota, se tenti di eliminare una vista MySQL che non esiste senza utilizzare IF EXISTS parola chiave, MySQL genera un errore.
Quando il comando del passaggio 1 viene eseguito di nuovo, ora non dovrebbero esserci risultati:
```
SHOW FULL TABLES WHERE TABLE_TYPE LIKE 'VIEW';
```
```
Empty set (0.000 sec)
```

Maggiori informazioni

Si consiglia di consultare le seguenti risorse per ulteriori informazioni su questo argomento. Sebbene questi siano forniti nella speranza che possano essere utili, tieni presente che non possiamo garantire l'accuratezza o la tempestività dei materiali ospitati esternamente.

MySQL - Utilizzo delle viste