Weergaven in SQL begrijpen

Door Manoj Debnath

Tabellen in een SQL-database kunnen enorme hoeveelheden gegevens bevatten, maar ze zijn niet altijd in een bruikbaar formaat om direct te gebruiken. De hoeveelheid gegevens moet worden gefilterd op basis van een aantal gespecificeerde criteria voor efficiënt gebruik. Om veiligheidsredenen willen we mogelijk slechts een bepaalde hoeveelheid gegevens openbaar maken, terwijl de rest mogelijk toegankelijk is voor bevoorrechte gebruikers. De SQL DML-bewerkingen zijn uitbreidbaar en worden gebruikt om door een of meer tabellen te filteren met behulp van complexe query-expressies. Door gebruik te maken van het idee, kunnen we virtuele tabellen maken van persistente basistabellen met behulp van SQL die de exacte gegevens bevatten die we nodig hebben. Dit is de reden waarom de SQL:2006-standaard het gebruik van weergavetabellen of weergaven heeft geïntroduceerd. De definitie van een weergave of een virtuele tabel bestaat als een schemaobject. Dit artikel introduceert het concept van views in SQL, hoe het werkt en laat zien hoe het wordt geïmplementeerd met enkele voorbeelden.

Inleiding tot SQL-weergaven

SQL-views zijn niets anders dan virtuele tabellen die zich in het geheugen bevinden dat is afgeleid van een of meer basistabellen. Virtuele tabellen betekenen dat de tuples in views geen fysiek bestaan ​​hebben en niet in de database worden opgeslagen. De tuples zijn als tijdelijke gegevens die zijn gemaakt als resultaat van de SQL-query die doorgaans gefilterde gegevens uit een of meer basistabellen haalt. Als gevolg hiervan is er een beperking op het type bewerking dat op een weergavetabel kan worden toegepast. De update-bewerking kan bijvoorbeeld niet worden toegepast op alle typen weergaven, maar er zijn geen beperkingen voor het toepassen van SQL-query's erop.

Onderstaande voorbeelden zijn getest met de MySQL database. Begin met het maken van een paar tabellen:

mijn_bedrijf databank:

CREATE DATABASE my_company;

CREATE TABLE Employee(
    empId INT(11) UNSIGNED CHECK (empId > 0),
    empName VARCHAR(20),
    birthDate DATE,
    address TEXT(128),
    gender VARCHAR(1),
    salary DECIMAL(15,2),
    managerId INT(11) UNSIGNED,
    deptId INT(11) UNSIGNED,
    PRIMARY KEY(empId)
);
 
CREATE TABLE Department(
    deptId INT(11) UNSIGNED CHECK (empId > 0),
    deptName VARCHAR(20),
    deptMgrId INT(11) UNSIGNED,
    mgrStartDate DATE,
    PRIMARY KEY(deptId)
);

CREATE TABLE Project(
    projId INT(11) UNSIGNED CHECK (empId > 0),
    projName VARCHAR(20),
    projLocation TEXT(128),
    deptId INT(11) UNSIGNED,
    PRIMARY KEY(projId)
);
 
CREATE TABLE EmpWorksOnProj(
    empId INT(11) UNSIGNED,
    projId INT(11) UNSIGNED,
    hoursWorked DECIMAL(4,2)
);  
 
ALTER TABLE Employee ADD CONSTRAINT fk_emp_mgr FOREIGN KEY(managerId) REFERENCES Employee(empId);
ALTER TABLE Employee ADD CONSTRAINT fk_emp_dept FOREIGN KEY(deptId) REFERENCES Department(deptId);
ALTER TABLE Department ADD CONSTRAINT fk_dept_mgr FOREIGN KEY(deptMgrId) REFERENCES Employee(empId);
ALTER TABLE Project ADD CONSTRAINT fk_proj_dept FOREIGN KEY(deptId) REFERENCES Department(deptId);

De weergaven kunnen worden gezien als een referentietabel en we kunnen deze zo vaak gebruiken als we willen, hoewel deze fysiek misschien niet bestaat. We moeten bijvoorbeeld vaak verwijzen naar de mijn_bedrijf database en zoek Werknemer en Project informatie. Merk op dat er veel op veel relaties zijn tussen Werknemer en Project aangezien één persoon aan veel projecten kan werken en ook één project veel werknemers heeft. Daarom, in plaats van de samenvoeging van drie tabellen op te geven:Werknemer , EmpWorksOnProj , en Project elke keer dat we informatie over samenwerking nodig hebben en een query uitvoeren, definiëren we een weergave die wordt gespecificeerd als het resultaat van de samenvoeging tussen deze tabellen. De weergave vormt de virtuele tabel die is gemaakt op basis van het resultaat van de query. Het voordeel is dat de query nu kan worden opgehaald uit een enkele resulterende tabel in plaats van te moeten ophalen uit drie samengevoegde tabellen. De verzameling tabellen:Medewerker , Project , Afdeling enz. vormen dus de basistabellen of definiërende tabel van de weergave.

Laten we enkele weergaven maken op basis van het bovenstaande schema.

CREATE VIEW V1
AS
SELECT
   empName, projName, hoursWorked
FROM
   Employee, Project, EmpWorksOnProj
WHERE
   Employee.empId=EmpWorksOnProj.empId
AND
   Project.projId=EmpWorksOnProj.projId;
 

De manier om SQL-query's in de weergave of virtuele tabel op te geven, is hetzelfde als het specificeren van query's met basistabellen. U kunt SQL SELECT op views gebruiken om de gegevens als volgt te verkrijgen:

KIES * VANUIT V1;

Het volgende creëert een tweede weergave:

MAAK VIEW V2 AS SELECT deptName, COUNT(*), SUM(salary) FROM Department, Employee WHERE Employee.deptId=Department.deptId GROUP BY deptName;

De SQL SELECT resulteert in

SELECT * FROM V1;

Merk op dat in view V1 de attribuutnamen zijn afgeleid van de basistabel. In V2 worden nieuwe attribuutnamen expliciet gespecificeerd met behulp van één-op-één correspondentie tussen de gespecificeerde attributen van de CREATE VIEW-clausule en die gespecificeerd in de SELECT-clausule. De SELECT-clausule met de view is bepalend voor de definitie van de view.

De getoonde informatie moet altijd up-to-date zijn. Dat betekent dat het altijd de wijzigingen moet weerspiegelen die zijn aangebracht in de basistabellen waarop het is gedefinieerd. Dit is interessant, omdat het betekent dat de weergave niet daadwerkelijk wordt gerealiseerd op het moment dat deze wordt gedefinieerd, maar later wanneer er een query op wordt gespecificeerd. Het databasebeheersysteem op de achtergrond is verantwoordelijk voor het up-to-date houden van de weergave.

UPDATE, INSERT en DELETE op weergaven

In SQL is het mogelijk om bijwerkbare weergaven te maken die kunnen worden gebruikt om bestaande gegevens te wijzigen of nieuwe rijen in de weergave in te voegen, die op hun beurt het record in de basistabel invoegen of wijzigen . Een weergave kan worden bijgewerkt of niet, wordt bepaald door de SELECT-instructie die is gedefinieerd in de weergavedefinitie. Er is geen speciale clausule om aan te geven dat een weergave kan worden bijgewerkt. De weergavedefinitie moet doorgaans eenvoudig zijn en mag geen samengevoegde functies bevatten, zoals SUM, AVG, MAX, MIN, COUNT. Elke vorm van groepering of DISTINCT- of JOIN-clausule zorgt er ook voor dat de weergave niet kan worden bijgewerkt. Raadpleeg de relevante databasehandleiding van het specifieke RDBMS voor wat een weergave niet-updatebaar maakt.

Laten we een weergave maken die kan worden bijgewerkt:

CREATE VIEW v3_ch_dept_name
AS
SELECT
   deptId, deptName, deptMgrId, mgrStartDate
FROM
   Department;

De SELECT-query die wordt weergegeven:

SELECT * FROM v3_ch_dept_name;

Werk nu de weergave bij door de afdelingsnaam (deptName) te wijzigen.

UPDATE
   v3_ch_dept_name
SET
   deptName = 'Security'
WHERE
   deptId = 5;

Een rij kan als volgt in de weergave worden ingevoegd:

INSERT
   INTO v3_ch_dept_name
VALUES (7,'Logistics',666884444,'1982-07-07');

We kunnen ook als volgt een rij uit de weergave VERWIJDEREN:

DELETE FROM v3_ch_dept_name WHERE deptId = 7;

In MySQL kunt u eenvoudig de weergaven in een database vinden die kunnen worden bijgewerkt of die niet kunnen worden bijgewerkt met het volgende SELECT-commando.

SELECT
   table_name
FROM
   information_schema.views
WHERE
   is_updatable like 'YES'
AND
   table_schema like 'my_company';

DROP-weergaven uit de database

Een weergave kan altijd worden verwijderd met DROP VIEW commando.

DROP VIEW V1;

Merk op dat wanneer we de opdracht drop view uitvoeren, de weergavedefinitie wordt verwijderd. De onderliggende gegevens die zijn opgeslagen in de basistabellen waaruit deze weergave is afgeleid, blijven ongewijzigd. Een weergave die eenmaal is verwijderd, kan opnieuw worden gemaakt met dezelfde naam.

De ALTER VIEW-instructie

Views zijn over het algemeen onveranderlijk volgens de SQL:2006-standaard, wat betekent dat het ALTER VIEW-statement niet werkt met views. Er zijn echter RDBMS's zoals MySQL of SQL Server die dit soort instructies ondersteunen. Het Orakel gelooft in het eerst laten vallen van het uitzicht en het dan opnieuw creëren in plaats van het te veranderen. Daarom variëren de functionaliteiten die door RDBMS worden ondersteund op weergaven van product tot product.

Conclusie

De SQL-weergaven zijn ook een handig hulpmiddel om toegang te krijgen tot meerdere gegevenstypen. Complexe query's kunnen worden opgeslagen binnen de weergavedefinitie. Dit maakt gebruik van hergebruik omdat we de weergave kunnen aanroepen in plaats van de query's elke keer dat we ze nodig hebben opnieuw te maken. Het is een handige manier om informatie aan de gebruiker te presenteren die veel informatie verbergt die we niet aan iedereen willen blootgeven. Dit is ook belangrijk vanuit het oogpunt van beveiliging. Complexe structuren kunnen worden gesynthetiseerd en gepresenteerd in een eenvoudig formaat voor de eindgebruiker.

Referenties:

Elmasri, Ramez en Shamkant B. Navathe. Fundamenten van databasesystemen . Pearson Onderwijs.