Chapter 9: Building an Information Architecture (continued_2)

Retrieving Information: SQL

→ Aanleren hoe je een databank moet ondervragen

- SQL = Structured Query Language
- SQL is a relational database language
 DDL: Data Definition Language
→ Defining tables, specifying integrity rules
 DML: Data Manipulation Language
→ Not only for retrieving data but also for inserting, updating and removing data
 DCL: Data Control Language
→ Granting and revoking authorization privileges (security) and for defining
transaction boundaries
- SQL consists of only a few keywords
→ 3 groepen van commando's

SQL

- Some keywords from the relational database model:

 Table
 Column
 Row
 Integrity rule (or constraint)
 Primary key
 Foreign key (or referential key)

SQL: Northwind Example

Zie apart blad

→ Examen!!! (structuur databank zelf opmaken)
- Orders → belangrijke tabel
- ShipVia → transportmiddel, vervoersmaatschappij
 ShipperID
- Als je primary 20 lang is, dan moet je foreign key ook 20 lang zijn
Bv primary = Autonumber foreign = Number- Field Size Long Integer
- Unit Price
 In Products: actuele verkoopprijs
 In Order Details: verkoopprijs aan het einde van het order

SELECT

→ Informatie die je op het examen krijgt

Alles tussen haakjes → opties die je kan gebruiken (moet dus niet)
2 verplichte: field 1 en table 1
Volgorde moet juist zijn

- SELECT field 1 [, field 2, ...]

FROM table 1 [, table 2, ...]
[WHERE condition]
[GROUP BY GroupField 1, GroupField 2, ...]
[HAVING condition]
[ORDER BY SortField 1, SortField 2, ...]

SELECT Kolommen → Velden

→ Berekeningen
FROM Tabellen (tabelnaam.veldnaam)
WHERE Selectie Records
GROUP BY Groepstotalen (bij SELECT staat er dan bv SUM, COUNT, MIN,
MAX, AVG (average), ...)
 HAVING Selectie op groepstotalen
ORDER BY Sorteren

Structured Query Language

- Five questions to create a select query:

 What is the output (columns) you want to see?
 What are the constraints on the data?
 Which tables are involved?
 Do you need to summarize information?
 Do you need selections on summarized data?

Voorbeeld

Geef een overzicht van alle werknemers

SELECT *
→ elementen selecteren uit tabellen
→ * = alle velden selecteren in een tabel
FROM Employees

Geef alle namen van alle werknemers

SELECT LastName, FirstName
FROM Employees

Geef de namen (als 1 tekst) van alle werknemers

SELECT LastName & FirstName
→ '&' = aaneenrijgen van teksten  zet nooit een spatie tussen 2 namen (FullerAndrew),
heeft ook geen duidelijke naam
FROM Employees
 Dus:
SELECT LastName & “ “ & FirstName AS Werknemer
→ “ “ = spatie tussen 2 aanhalingstekens geeft een spatie
→ AS = om naam te geven
FROM Employees

In Access:
Niet de Query Wizard maar Query Design gebruiken

Geef alle werknemers die in dienst zijn getreden na 1 januari 1994

SELECT LastName & “ “ & FirstName AS Werknemer
FROM Employees
WHERE HireDate >= #1/1/1994#
→ selectie op recordniveau
→ datums tussen #

Products → Discontinued = ja / neen veld

True Ja 1
False 0
Uitkomst van vergelijking moet true of false opleveren.
True wordt geselecteerd en getoond bij gebruiker

Geef alle producten die niet meer geproduceerd worden

SELECT ProductName
FROM Products
WHERE Discontinued

Geef alle producten die nog steeds geproduceerd worden

SELECT ProductName
FROM Products
WHERE Not Discontinued

Geef alle namen van klanten die in België of Frankrijk wonen (geef alle Belgische en
Franse klanten)
SELECT CompanyName
FROM Customers
WHERE Country = “Belgium” or Country = “France”

Geef alle klanten die geen fax hebben

SELECT CompanyName
FROM Customers
WHERE Fax Is Null

Geef alle klanten die wel een fax hebben

SELECT CompanyName
FROM Customers
WHERE Fax Is Not Null

Geef mij alle Belgische klanten die een fax hebben

SELECT CompanyName
FROM Customers
WHERE Fax Is Not Null AND Country = “Belgium”

Geef alle klanten samen met de ordernummers en data van hun bestellingen
SELECT CompanyName, OrderID, OrderDate
FROM Customers INNER JOIN Orders ON Customers.CustomerID = Orders.CustomerID
→ 'INNER JOIN' om een relatie aan te duiden tussen 2 tabellen
→ 'ON' = gemeenschappelijke velden aanduiden tussen die 2 tabellen
→ Customers.CustomerID = Veld CustomerID in tabel Customers

OF
SELECT CompanyName, OrderID, OrderDate
FROM Orders INNER JOIN Customers ON Customers.CustomerID = Orders.CustomerID

Geef een overzicht van alle orders samen met de producten die besteld werden
(Gegeven: OrderID, OrderDatum, ProductName, Aantal stuks besteld)
SELECT Orders.OrderID, OrderDate, ProductName, Quantity
FROM (Orders INNER JOIN [Order Details] ON Orders.OrderID = [OrderDetails].OrderID)
INNER JOIN Products ON [Order Details].ProductID = Products.ProductID
→ 2 relaties tussen 3 tabellen beschrijven
→ Indien in je tabelnaam een spatie staat moet je er rechte haken rond zetten om aan te
duiden dat dat 1 tabelnaam is
→ Ronde haakjes duidt aan dat dat een aparte tabel is (?)

Dezelfde vraag maar gesorteerd op Productnaam

SELECT Orders.OrderID, OrderDate, ProductName, Quantity
FROM (Orders INNER JOIN [Order Details] ON Orders.OrderID = [OrderDetails].OrderID)
INNER JOIN Products ON [Order Details].ProductID = Products.ProductID
ORDER BY ProductName

Dezelfde vraag maar gesorteerd op Productnaam, vervolgens op OrderDate

SELECT Orders.OrderID, OrderDate, ProductName, Quantity
FROM (Orders INNER JOIN [Order Details] ON Orders.OrderID = [OrderDetails].OrderID)
INNER JOIN Products ON [Order Details].ProductID = Products.ProductID
ORDER BY ProductName, OrderDate

Vorige vraag maar dalend gesorteerd op orderdatum

SELECT Orders.OrderID, OrderDate, ProductName, Quantity
FROM (Orders INNER JOIN [Order Details] ON Orders.OrderID = [OrderDetails].OrderID)
INNER JOIN Products ON [Order Details].ProductID = Products.ProductID
ORDER BY ProductName, OrderDate Desc

Overzciht van alle bestelde producten te samen met de prijs die de klant moet
betalen
(Gewenste output: OrderID, ProductName, Quantity, ProductPrice, Totaal dat de klant
betaald)
SELECT OrderID, ProductName, Quantity, [Order Details].UnitPrice, Quantity * [Order
Details].UnitPrice AS ProductTotal
FROM [Order Details] INNER JOIN Products ON [Order Details].ProductID =
Products.ProductID
ORDER BY OrderID

Bereken het factuurtotaal voor elk order

SELECT Orders.OrderID, OrderDate, Sum(Quantity * UnitPrice) AS FactuurTotal
FROM Orders INNER JOIN [Order Details] ON Orders.OrderID = [Order Details].OrderID
GROUP BY Orders.OrderID, OrderDate

Bereken het factuurtotaal van alle orders uit 1997

-> Selectie op recordniveau
SELECT Orders.OrderID, OrderDate, Sum(Quantity * UnitPrice) AS FactuurTotal
FROM Orders INNER JOIN [Order Details] ON Orders.OrderID = [Order Details].OrderID
WHERE YEAR(OrderDate) = 1997
GROUP BY Orders.OrderID, OrderDate

Bereken de omzet per maand in 1997

SELECT Month(OrderDate) AS MonthNumber, SUM(Quantity * UnitPrice) AS
MonthRevenue
FROM Orders INNER JOIN [Order Details] ON Orders.OrdersID = [Order Details].OrderID
WHERE Year(OrderDate) = 1997
GROUP BY Month(OrderDate)

Hoeveel producten hebben we per categorie?

SELECT CategorieName, Count(ProductID) AS Totaal
-> Count (of algemener: als je wil tellen) best altijd op een primary key
FROM Categories INNER JOIN Products ON Categories.CategoryID =
Products.CategoryID
GROUP BY CategoryName
→ Group by = automatische sortering op de records

Welke categoriën hebben meer dan 10 producten?

SELECT CategorieName, Count(ProductID) AS Totaal
FROM Categories INNER JOIN Products ON Categories.CategoryID =
Products.CategoryID
GROUP BY CategoryName
HAVING Count(ProductID) >= 10

Wat zijn de minimum en maximum prijzen per categorie?

→ In output moet je nu 3 kolommen zien
SELECT CategoryName, Min(UnitPrice) AS MinPrice, Max(UnitPrice) AS MaxPrice
→ Niet gewoon minimum en maximum gebruiken omdat dit als een functie kan worden
gezien
FROM Categories INNER JOIN Products ON Categories.CategoryID =
Producs.CategoryID
GROUP BY CategoryName
→ Reinforce differential integrity => extra controle CustomerID in de tabel CustomerID

Customers Orders
1 100 2
2 101 1
3 102 2
4 103 5
5 104 1
Lijst alle Klanten = Hoofdquery
-
Lijst CustomersID in Orders = Subquery

Welke klanten hebben geen orders?

SELECT CompanyName
FROM Customers
WHERE CustomerID NOT IN
(SELECT CustomerID
FROM Order)
→ Tussen haakjes = subquery
→ Hoofdquery en subquery samenvoegen door het gebruik van 'NOT IN'

Welke klanten hebben in 1997 geen orders besteld?

SELECT CompanyName
FROM Customers
WHERE CustomerID NOT IN
(SELECT CustomerID
FROM Orders
WHERE Year(OrderDate)=1997)

Wie is de oudste werknemer?

SELECT LastName & “ “ & FirstName AS Werknemer, BirthDate
FROM Employees
WHERE BirthDate <= ALL
(SELECT BirthDate
FROM Employees)

Andere oplossing:
SELECT LastName & “ “ & FirstName AS Werknemer, BirthDate
FROM Employees
WHERE BirthDate =
(SELECT Min(BirthDate)
FROM Employees)
→ Subquery kan 1 getal of een hele reeks getallen berekenen

Wat is het gemiddelde factuurtotaal van alle orders uit 1998?

→ Access berekent eerst subquery dus daarom mag er wel een naam in de select staan
en is de berekening van factuurtotaal gekend
SELECT AVG(FactuurTotaal)
FROM
(SELECT Sum(Quantity * UnitPrice) AS FactuurTotaal
FROM Orders INNER JOIN [Order Details] ON Orders.OrderID = [Order Details].OrderID
WHERE Year(OrderDate) = 1998
GROUP BY Orders.OrderID)
→ Group by moet er hier bij omdat je anders gewoon de som berekent en dus maar 1
getal krijgt terwijl je een tabel nodig hebt

Van welke landen zijn onze klanten afkomstig?

SELECT DISTINCT Country, Region
→ Distinct erachter zetten omdat je alleen de namen van de landen wilt weten, elk land
maar 1 keer voorkomend en niet elke keer per klant
Bv ipv 5 keer Germany (5 klanten daar) willen we maar 1 keer Germany hebben staan
→ Distinct is van toepassing op alles wat er achter staat (dus zowel voor country als
region)
→ Distinct kan alleen achter select staan en nergens anders
FROM Customers

Welke producten levert elke leverancier?

→ Tonen in de output: Productnaam, leverancier
SELECT ProductName, CompanyName
FROM Products INNER JOIN Suppliers ON Suppliers.SupplierID = Products.SupplierID
ORDER BY CompanyName, ProductName
→ Bij groepstotalen niet te veel details opnemen

Hoeveel producten levert elke leverancier?

SELECT CompanyName, Count(ProductID) AS Aantal
→ In de select-component alleen het hoogst noodzakelijke zetten
FROM Products INNER JOIN Suppliers ON Suppliers.SupplierID = Products.SupplierID
GROUP BY CompanyName

Welke maandomzet heeft elke verkoper gerealiseerd in 1998?

 In de output wensen we welke kolommen te zien? Naam van de verkoper (werknemer →
Employees), maandomzet (Sum(FactuurTotaal) = Quantity * UnitPrice → Order Details
van Orders), en de maand (Month(OrderDate))  3 kolommen
→ Record Selectie: 1998
SELECT FirstName & “ “ & LastName AS Verkoper, Sum(Quantity * [Order
Details].UnitPrce) AS Maandomzet, Month(OrderDate) AS MaandNr
→ Select is de eerste component die je moet schrijven maar die als laatste wordt
uitgevoerd
FROM (Employees INNER JOIN Orders ON Employees.EmployeeID =
Orders.Employee.ID) INNER JOIN [Order Details] ON Orders.OrderID = [Order
Details].OrderID
WHERE Year(OrderDate) = 1998
GROUP BY FirstName & “ “ & LastName, Month(OrderDate)

Zijn er categoriën die geen actieve producten (discontinued) meer hebben? (Zijn er
categoriën waarvan alle producten uit productie zijn genomen?)
→ “Geen” duidt op een hoofd- en subquery
SELECT CategoryName
FROM Categories
WHERE Category NOT IN
(SELECT CategoryID
FROM Products
WHERE Discontinued = False)

Geef een lijst van de leveranciers die een website hebben, tesamen met het adres
van de website
SELECT CompanyName, HomePage
FROM Suppliers
WHERE HomePage IS NOT NULL

Welke klanten hebben in 1997 meer dan 10 orders afgesloten?

Bord (schematisch):
SELECT CompanyName, AantalOrders
Klant Count(OrderID)
FROM Customers, Orders
WHERE Orders uit 1997
GROUP BY door Count(OrderID)
HAVING Count(...) >= 10

Oplossing:
SELECT CompanyName, Count(OrderID) AS AantalOrders
FROM Customers INNER JOIN Orders ON Customers.CustomerID = Orders.CustomerID
WHERE Year(OrderDate) = 1997
GROUP BY CompanyName
HAVING Count(OrderID) >= 10