Weergaven gebruiken in een MySQL-database

Een weergave in MySQL is een benoemde query die kan worden geactiveerd om gegevens weer te geven die in andere tabellen zijn opgeslagen. Met andere woorden, views zijn door de gebruiker gedefinieerde virtuele tabellen. Weergaven kunnen worden gebruikt om:

Verbeter databasebeveiliging. Als uw database gevoelige informatie bevat die moet worden beveiligd, helpt het gebruik van een weergave u om de gegevens te isoleren. Er kan een weergave worden gemaakt met een vooraf gedefinieerde resultatenset en u kunt gebruikers alleen toegang verlenen tot die weergave, in plaats van de tabel die gevoelige informatie bevat.
Verplaats complexe bedrijfslogica naar de databaseserver. In plaats van veelgebruikte softwarelogica in verschillende clients te coderen, kan een ontwikkelaar de logica met behulp van een view naar het databaseniveau verplaatsen. Er kan bijvoorbeeld een weergave worden gemaakt om klantclassificaties weer te geven, afhankelijk van hun totale verkoop.
Verminder afleiding door gegevens. Een weergave kan resultaten uit verschillende tabellen combineren en alleen de relevante kolommen weergeven wanneer ze worden aangeroepen.

In deze gids leer je:

Hoe de syntaxis van een MySQL-weergave is gestructureerd.
Een MySQL-weergave maken.
Een MySQL-weergave oproepen.
Een weergave in MySQL neerzetten.

Voordat u begint

Zorg ervoor dat u over het volgende beschikt om deze handleiding te volgen:

Een Linode, waarop u de MySQL-software uitvoert. U kunt de handleiding Aan de slag met Linode volgen om een Linode in te richten.
De MySQL-serversoftware (of MariaDB) die op uw Linode is geïnstalleerd. Raadpleeg de sectie MySQL, die handleidingen bevat die beschrijven hoe MySQL op verschillende Linux-distributies moet worden geïnstalleerd.

De database voorbereiden

Voordat u uw MySQL-weergaven maakt, maakt u een voorbeelddatabase, definieert u een paar tabellen en vult u deze eerst met wat gegevens:

SSH naar uw Linode. Voer vervolgens deze opdracht in om in te loggen op MySQL als rootgebruiker:
```
mysql -u root -p
```
Voer desgevraagd het root-wachtwoord van uw MySQL-server in en druk op Enter om door te gaan.
Opmerking
Als uw wachtwoord niet wordt geaccepteerd, moet u mogelijk de vorige opdracht uitvoeren met sudo :
```
sudo mysql -u root -p
```
Als uw wachtwoord is geaccepteerd, zou u de MySQL-prompt moeten zien:
```
mysql >
```
Opmerking
Als u MariaDB gebruikt, ziet u in plaats daarvan mogelijk een prompt zoals de volgende:
```
MariaDB [(none)]>
```
Voer vervolgens deze SQL-opdracht uit om een voorbeelddatabase te maken met de naam sample_database :
```
CREATE DATABASE sample_database;
```
U zou deze uitvoer moeten zien, die bevestigt dat de database met succes is gemaakt:
```
Query OK, 1 row affected (0.02 sec)
```
Selecteer de sample_database databank:
```
USE sample_database;
```
Je zou deze uitvoer moeten zien:
```
Database changed
```

Voer deze opdracht uit om een customers . aan te maken tafel:

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

Je zou deze uitvoer moeten zien:


Query OK, 0 rows affected (0.07 sec)

Vul vervolgens de customers . in tabel met drie records. Voer de onderstaande INSERT . uit commando's een voor een:

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

De output hieronder wordt getoond nadat elke record is ingevoegd:


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

Zorg ervoor dat de voorbeeldrecords in de database zijn ingevoegd door deze SELECT . uit te voeren commando:

SELECT * FROM customers;

Deze uitvoer verschijnt, die bevestigt dat de gegevens in de vorige stap met succes zijn ingevoerd:


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

Maak vervolgens een sales tafel. Voer deze opdracht uit:

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

Deze uitvoer verschijnt:


Query OK, 0 rows affected (0.07 sec)

Voeg vervolgens wat gegevens toe aan de sales tafel. Voer deze opdrachten een voor een uit:

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');

Na het invoegen van elk verkooprecord verschijnt deze uitvoer:


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

Voer vervolgens een SELECT . uit vraag om te controleren of de verkoopgegevens in de tabel zijn ingevoegd:

SELECT * FROM sales;

Deze uitvoer verschijnt, die bevestigt dat de verkoopgegevens in de vorige stap met succes zijn ingevoerd:




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

U hebt de database en de tabellen gedefinieerd om aan te werken. De volgende sectie beschrijft de syntaxis van een MySQL-weergave.

De MySQL View-syntaxis

Dit is een vereenvoudigde versie van de syntaxis van de MySQL-weergave:

    CREATE
    VIEW view_name
    AS select_statement

view_name :De naam van de MySQL-view moet hier worden gedefinieerd. Het is raadzaam om een beschrijvende naam te gebruiken, zodat u zich later de functie van de weergave kunt herinneren.
select_statement :Dit is de SQL-query die is gekoppeld aan de gedefinieerde weergave. Wanneer de weergave wordt aangeroepen, voert MySQL deze query uit om een recordset te retourneren.

Een MySQL-weergave maken

Deze sectie geeft een voorbeeld van een MySQL-weergave. Deze weergave wordt gebruikt om klanten uit uw voorbeelddatabase te classificeren, afhankelijk van hun aantal maandelijkse verkopen.

Zorg ervoor dat u bent ingelogd op uw MySQL-server. Voer vervolgens de onderstaande opdracht uit om een customers_membership aan te maken bekijken:

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;

Als de weergave met succes is gemaakt, zou u de onderstaande uitvoer moeten zien:


Query OK, 0 rows affected (0.01 sec)

De bovenstaande MySQL-opdracht maakt een weergave met de naam customers_membership die zich aansluit bij de customers en sales tabel met de PRIMARY KEY customer_id . De logische IF(expression, value_if_true, value_if_false) verklaringslogica wordt gebruikt om het lidmaatschap van de klant te bepalen op basis van hun maandelijkse verkopen:

Als de verkoop van een klant gelijk is aan of hoger is dan 5.000, classificeert de weergave de klant als een PREMIUM lid.
Anders (als de verkopen lager zijn dan 5,000 ), wordt de klant geclassificeerd als een BASIC lid.

Het customers_membership weergave is nu opgeslagen in de database. Het volgende gedeelte laat zien hoe u een MySQL-weergave kunt aanroepen en een recordset kunt weergeven zonder rechtstreeks de basistabellen op te vragen.

Een MySQL-weergave oproepen

Deze sectie laat zien hoe u de MySQL-weergave die u hierboven hebt gemaakt kunt oproepen en kunt bevestigen dat deze werkt zoals verwacht. Zodra een weergave is gemaakt, is deze zichtbaar als een database-object en kan worden aangeroepen met de SELECT verklaring.

Om de customers_membership . aan te roepen bekijken, uitvoeren:
```
SELECT * FROM customers_membership;
```
Als de weergave werkt zoals verwacht, ziet u nu een lijst met klanten met hun gegenereerde membership waarden op basis van hun verkopen. Sinds Leslie ’s verkopen waren minder dan 5000 (500,27), de weergave geeft het lidmaatschap van de klant weer als BASIC . Andy en Ben ’s verkopen waren respectievelijk 7600.32 en 25879.63 en dit maakt ze PREMIUM leden:
```
+-------------+---------------+------------+
| customer_id | customer_name | membership |
+-------------+---------------+------------+
|           1 | Leslie        | BASIC      |
|           2 | Andy          | PREMIUM    |
|           3 | Ben           | PREMIUM    |
+-------------+---------------+------------+
3 rows in set (0.00 sec)
```
Zodra een basistabelgegevens zijn bijgewerkt en u opnieuw een MySQL-weergave oproept, zou u de nieuwste informatie moeten zien. Weergaven halen informatie uit hun basistabellen en slaan de gegevens niet op. Om te demonstreren hoe een weergave bijgewerkte informatie uit de basistabellen haalt, voegt u een andere klant toe met de naam Rajie aan de customers tafel:
```
INSERT INTO customers (customer_name) VALUES ('Rajie');
```
Deze uitvoer verschijnt:
```
Query OK, 1 row affected (0.01 sec)
```

Voeg vervolgens de maandelijkse verkoopinformatie van de klant toe aan de verkooptabel:

INSERT INTO sales (customer_id, monthly_sales) VALUES ('4', '147.41');

Deze uitvoer verschijnt:


Query OK, 1 row affected (0.01 sec)

Roep vervolgens de customers_membership . op opnieuw bekijken:

SELECT * FROM customers_membership;

De onderstaande uitvoer verschijnt, wat bevestigt dat de weergave wijzigingen kan oppikken en de informatie van nieuwe klanten kan ophalen zoals verwacht:


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

Zoals je kunt zien in de recordset hierboven, heb je nu een nieuwe klant genaamd Rajie met een BASIC lidmaatschap.

Een MySQL-weergave verwijderen

Net als andere database-objecten kunt u weergaven verwijderen als u ze niet langer nodig hebt. Dit is de basissyntaxis voor het verwijderen van een MySQL-weergave:

    DROP VIEW IF EXISTS view_name;

Voordat u een MySQL-weergave verwijdert, moet u eerst de naam identificeren door de onderstaande opdracht uit te voeren:

SHOW FULL TABLES WHERE TABLE_TYPE LIKE 'VIEW';

Er verschijnt een lijst met alle weergaven in de momenteel geselecteerde database:


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

In dit geval is de naam van de weergave die u wilt verwijderen customers_membership . Dus om het te verwijderen, voer je uit:
```
DROP VIEW IF EXISTS customers_membership;
```
Zorg ervoor dat de onderstaande uitvoer wordt weergegeven nadat de weergave uit de database is verwijderd:
```
Query OK, 0 rows affected (0.01 sec)
```
Opmerking Let op, als u probeert een MySQL-weergave te verwijderen die niet bestaat zonder de IF EXISTS te gebruiken zoekwoord, geeft MySQL een fout.
Wanneer de opdracht uit stap 1 opnieuw wordt uitgevoerd, zouden er nu geen resultaten moeten zijn:
```
SHOW FULL TABLES WHERE TABLE_TYPE LIKE 'VIEW';
```
```
Empty set (0.000 sec)
```

Meer informatie

U kunt de volgende bronnen raadplegen voor aanvullende informatie over dit onderwerp. Hoewel deze worden verstrekt in de hoop dat ze nuttig zullen zijn, houd er rekening mee dat we niet kunnen instaan voor de nauwkeurigheid of tijdigheid van extern gehost materiaal.

MySQL - Weergaven gebruiken