Relationele Databases en SQL Basisprincipes

• Relatie databases zijn gebaseerd op wiskundige principes, waarbij een tabel een relatie vertegenwoordigt.
• Belangrijke concepten in relationele databases zijn onder meer databases, tabellen, rijen (records/tuples), velden (attributen), primaire sleutels (PK) en externe sleutels (FK).
• Relaties tussen tabellen worden gecreëerd via primaire sleutels en externe sleutels.

Achtergrond SQL (Structured Query Language)

• SQL is een declaratieve taal, gebaseerd op het relationele model, ontwikkeld in 1974, met de nieuwste versie uitgebracht in 2016.
• SQL kan worden onderverdeeld in Data Definition Language (DDL) voor structuurcreatie (bijv. CREATE TABLE), Data Manipulation Language (DML) voor datamanipulatie (bijv. SELECT, INSERT, UPDATE, DELETE) en Data Control Language (DCL) voor toegangsbeheer (bijv. GRANT).

CRUD-operaties in SQL

• CREATE (INSERT) operaties voegen gegevens toe aan een tabel.
• READ (SELECT) operaties halen gegevens op uit een tabel.
• UPDATE operaties wijzigen bestaande gegevens.
• DELETE operaties verwijderen gegevens uit een tabel.

Voorbeelddatabase: Fabriek

• Een bestelapplicatie stelt medewerkers in staat om bestellingen in te voeren en de voorraad te controleren
• Een Entiteiten Relatie Diagram (ERD) visualiseert de databasestructuur.
• Primaire sleutels (PK) kunnen enkelvoudig of samengesteld zijn.

SQL Queries

• SELECT * FROM tabel; haalt alle kolommen op.
• SELECT kolom1, kolom2 FROM tabel; haalt specifieke kolommen op.
• WHERE-clause filtert rijen op basis van een specifieke conditie, bijvoorbeeld WHERE naam = 'Staal';.
• DISTINCT toont alleen unieke waarden.
• LIKE wordt gebruikt voor patroonherkenning, bijvoorbeeld LIKE 'A%' om records te vinden die beginnen met 'A'.
• ORDER BY sorteert resultaten, ASC voor oplopend en DESC voor aflopend.
• LIMIT beperkt het aantal geretourneerde resultaten, bijvoorbeeld LIMIT 5.

Data Bewerken

• INSERT INTO voegt nieuwe records toe.
• UPDATE wijzigt records met SET kolom = waarde WHERE conditie.
• DELETE FROM verwijdert records met DELETE FROM tabel WHERE conditie.

Java-programma opzetten

• Om een nieuw Java-project in IntelliJ op te zetten zijn de volgende stappen nodig:
• Een nieuw project aanmaken in IntelliJ
• Selecteren van Java en de juiste SDK-versie
• Geen template gebruiken en een naam geven aan het project
• Een package (nl.hu.dp) en een klasse (Main) aanmaken
• Een main()-functie toevoegen en een bericht printen in de console

Wat is JDBC (Java Database Connectivity)

• JDBC is een Java API die de verbinding met databases beheert
• JDBC biedt een gestandaardiseerde manier om:
  • Verbinding te maken met databases
  • SQL-query's en commando's uit te voeren
  • Resultaten op te halen en te verwerken
• Iedere databaseleverancier (PostgreSQL, MySQL, MSSQL, etc.) biedt zijn eigen JDBC-driver
• Als ontwikkelaar is het voldoende om de API te kennen, niet de interne implementatie.
• Belangrijke JDBC-commando's:
  • getConnection(url) maakt een databaseverbinding.
  • close() sluit de verbinding
  • prepareStatement(query) bereidt SQL-query's voor.
  • executeQuery() voert een query uit en geeft resultaten terug.

JDBC driver toevoegen aan een Java project

• JDBC-drivers kunnen worden gedownload als JAR bestanden
• Een efficiëntere methode is het gebruik van Maven, een tool voor het beheren van dependencies
• Maven-configuratie voor PostgreSQL:
  • Ga naar de Maven Repository
  • Kopieer de dependency-code en voeg deze toe aan het pom.xml bestand:
• Sluit de XML tag af
• Reload het project via Maven > Reload project

Verbinden met een database

• De JDBC-methode getConnection() wordt gebruikt om een verbinding te kunnen maken met de database
• Er staat een code voorbeeld in Java voor hoe je een database verbinding opzet (zie originele tekst)

Verbinding sluiten

• Er staat een code voorbeeld in Java hoe je een verbinding sluit (zie originele tekst)

Testen van de verbinding

• Er staat een code voorbeeld in Java om de database verbinding te testen (zie originele tekst)

Conclusie

• JDBC is een krachtige API die een standaard biedt om met databases te werken
• Door het gebruik van Maven is het eenvoudig een JDBC driver toe te voegen en een verbinding aan te maken met een database.

Ontwerpprincipes in object-georiënteerd programmeren en Single Responsibility Principle (SRP)

• Een klasse moet maar één verantwoordelijkheid hebben en maar 1 reden om te veranderen
• Een voorbeeld: Kaartspel
  • Je wilt een versie met een maximum aantal spelers → Aanpassing in spelregels.
  • Je wilt een versie met een andere puntentelling → Aanpassing in scoreberekening.
  • Je wilt het leaderboard opslaan in een bestand i.p.v. op het scherm → Aanpassing in data-opslag.
• De oplossing is dus: Splits klassen op zodat elke klasse een unieke verantwoordelijkheid heeft.
• De voordelen van SRP zijn
  • Kleinere, beter begrijpbare klassen.
  • Makkelijker om wijzigingen door te voeren.
  • Code is beter herbruikbaar.
  • Eenheidstest (unit testing) wordt eenvoudiger.

Persistentie als aparte verantwoordelijkheid

• Het opslaan van objecten introduceert extra redenen om een klasse te wijzigen, zoals:
  • Veranderen van databaseplatform (bv. van MySQL naar PostgreSQL).
  • Andere opslagmethode (bv. van bestandssysteem naar database).
  • Extra of redundante opslag (bv. hoofd- en mirrordatabase).
• Persistentie moet behandeld worden als een aparte verantwoordelijkheid.

Data Access Object (DAO) Design Pattern

• Het DAO-pattern zorgt ervoor dat de opslag (persistentie) losstaat van de businesslogica.

Werking

• Voor elke klasse die moet worden opgeslagen, wordt een DAO-klasse gemaakt.
• Deze DAO is verantwoordelijk voor:
• Create (toevoegen van data)
• Read (uitlezen van data)
• Update (aanpassen van data)
• Delete (verwijderen van data)

Structuur van het DAO design pattern

• Applicatiedomein Bevat de businesslogica en gebruikt de DAO.
• DAO-laag Bevat DAO-klassen die interactie met de database verzorgen.
• Persistentie Bevat de daadwerkelijke databaseverbinding en opslag.

Implementatie met relationele databases (JDBC)

• Bij het gebruik van relationele databases werkt een DAO-klasse vaak met twee interfaces:
• DAO-interface: Definieert de CRUD-operaties voor de entiteit.
• JDBC-interface: Verzorgt de database-interactie (elk databaseplatform heeft zijn eigen JDBC-implementatie).
• Het DAO Design Pattern helpt bij het scheiden van businesslogica en databasebeheer. Hiedoor wordt de code flexibeler, onderhoudsvriendelijker en testbaar.

Creëer een Java project

• Gebruik IntelliJ IDEA om een nieuw Java-project te starten
• Installeer Maven om dependencies zoals de JDBC-driver te beheren.

JDBC installeren en configureren

• Om verbinding te maken met databases moet je JDBC (Java Database Connectivity) installeren, een API
• Elke database (PostgreSQL, MySQL, MSSQL) heeft een eigen JDBC-driver.
• Voeg de PostgreSQL JDBC-driver toe via Maven

Verbinding maken met de database

• Het is mogelijk en noodzakelijk een database verbinding op te zetten via DriverManager.getConnection()
• Sluit de verbinding correct met closeConnection()

Werken met SQL-statements in Java

• Gebruik PreparedStatements voor veilige SQL-uitvoering en bescherming tegen SQL-injectie.

Data Access Object (DAO) patroon

• Het DAO scheidt de database-logica van de applicatielogica (volgens de Single Responsibility Principle).
• Een DAO-interface definieert de CRUD-operaties

CRUD-functionaliteit implementeren

• Hier staat een code voorbeeld van een save() methode in DAO (zie originele tekst)

Conclusie

• JDBC maakt het mogelijk om Java-applicaties met databases te verbinden.
• Gebruik Maven om dependencies te beheren.
• PreparedStatements zijn veiliger dan gewone SQL-statements.
• Het DAO-patroon scheidt de database-logica en maakt de code onderhoudbaar.
• CRUD-operaties worden via een DAO-klasse geïmplementeerd.

Kies duidelijke namen

• Namen voor variabelen, methoden en klassen moeten betekenis hebben
• Gebruik werkwoorden voor methoden: ❌ is sqlExceptionHandler() ✅ is handleSqlException()
• Gebruik zelfstandig naamwoorden voor klassen: ❌ is ManageReiziger ✅ is Reiziger
• Gebruik correct enkelvoud/meervoud: ❌ digit = new int[]{0, 1, 2, 3} ✅ digits = new int[]{0, 1, 2, 3};
• Gebruik langere namen voor variabelen met grote scope: ❌ is pNum ✅ is productNumber
• Gebruik korte namen voor variabelen met kleine scope ❌ is loopIndex ✅ is I

Gebruik vaste voorvoegsels voor bepaalde typen variabelen

• Boolean flags moeten de prefix is gebruiken ❌ is active, member ✅ is isActive, hasMember Vermijd afkortingen tenzij ze heel duidelijk zijn: ❌ is cn ✅ is conn (voor een databaseverbinding)

Exception Handling

• Goed omgaan met fouten voorkomt onverwachte crashes en bugs:
• Vermijd het onderdrukken van fouten:
• Goede aanpak: Exception oplossen of loggen en opnieuw gooien.

Haal niet meer data op dan nodig

• Optimaliseer databasequery’s om onnodig dataverkeer te vermijden: ❌ is SELECT * ✅ is SELECT kolom1, FROM reizigers reiziger_id = ?
• Efficiënte queries besparen veel dataverkeer en verhogen de prestaties.

✅ Gebruik betekenisvolle namen voor variabelen, methoden en klassen. ✅ Vermijd afkortingen en kies vaste naamconventies. ✅ Zorg voor goede exception handling: fouten niet negeren, maar loggen en (indien nodig) doorgeven. ✅ Optimaliseer databasequery’s door alleen de benodigde data op te halen.

Object-Relational Mapping (ORM)

• ORM vertaalt Java-objecten naar databasegegevens (relationele tabellen).
• Dit gebeurt bij CRUD-operaties, waarmee objecten persistent worden opgeslagen.

Handmatige persistentie vs. ORM-frameworks

• Nadelen van handmatige persistentie:
  • Veel herhalend werk.
  • Risico op fouten in SQL-query’s.
  • Afhankelijk van SQL-dialecten.
• Voordelen van een ORM-framework (zoals Hibernate):
  • Automatiseert de persistentie.
  • Genereert SQL-query’s in het juiste dialect.
  • Kan database-schema’s genereren.

Java Persistence API (JPA)

• JPA is een specificatie voor ORM in Java.
• Belangrijke JPA-componenten:
  • Entity: Een Java-object dat overeenkomt met een database-tabel.
  • EntityManager: Beheert de persistentiecontext.
  • EntityQuery: Queries uitvoeren via JPQL of de Criteria API.

Hibernate als ORM-framework

• Hibernate is een implementatie van JPA en wordt breed gebruikt.
• Belangrijke Hibernate-componenten:
• Configuratiebestand: Bevat de databaseverbinding en te persisteren entiteiten.
• Mapping metadata: Kan via XML of annotations worden gedefinieerd.
• Belangrijke klassen:
  • Configuration (voor instellingen).
  • SessionFactory en Session (voor database-interactie).
  • Transaction (voor databasebewerkingen).

Hibernate Annotations

• Hibernate gebruikt annotaties om Java-klassen te koppelen aan database-tabellen
• @Entity Geeft aan dat een klasse een database-entiteit is.
• @Table(name="tabelnaam") → Specificeert de naam van de database-tabel.
• @Id → Markeert de primaire sleutel
• @GeneratedValue → Geeft aan dat de primaire sleutel automatisch wordt gegenereerd.
• @Column(name="kolomnaam") → Specificeert de kolomnaam in de database.
• Zie originele tekst voor Java code voorbeeld van @Entity, @Table, @Id etc

Relaties in Hibernate

• Er zijn verschillende soorten relaties in Hibernate
• @OneToOne → Eén-op-één-relatie
• @OneToMany → Eén-op-veel-relatie
• @ManyToOne → Veel-op-één-relatie
• @ManyToMany → Veel-op-veel-relatie
• Zie originele tekst voor java code voorbeeld @OneToMany

Cascade-functionaliteit

• Cascade bepaalt de werking van ouder objecten (parent) naar een kindobject (child).
• CascadeType.PERSIST → Slaat het kindobject automatisch op het moment dat de ouder wordt opgeslagen
• CascadeType.MERGE → Houdt de staat van het kind gelijk aan de ouder.
• CascadeType.REMOVE → Verwijdert het kind als de ouder wordt verwijderd.
• CascadeType.REFRESH → Herlaadt het kind als de ouder wordt herladen.
• CascadeType.DETACH → Verwijdert het kind uit de persistentiecontext als de ouder wordt verwijderd
• CascadeType.ALL → Combineert alle bovenstaande acties.

mappedBy en orphanRemoval

• mappedBy → Geeft aan welke kant van de relatie eigenaar is (bij bidirectionele relaties).
• orphanRemoval → Verwijdert verweesde child objecten wanneer de parent wordt verwijderd

Fetch Types (Lazy vs. Eager)

• FetchType.LAZY → Data wordt pas geladen als het nodig is (voorkomt onnodige queries).
• FetchType.EAGER → Data wordt direct geladen (kan prestaties beïnvloeden).
• In de originele tekst zie je java code voorbeelden

Conclusie

• Hibernate automatiseert database-interacties en voorkomt handmatige SQL-query's.
• Annotations definiëren hoe objecten worden omgezet naar database-tabellen.
• Relaties tussen objecten worden beheerd via OneToOne, OneToMany, ManyToOne, ManyToMany.
• Cascade-opties en orphanRemoval helpen bij het beheren van afhankelijkheden.
• Lazy loading is efficiënter dan eager loading in veel gevallen.

Inleiding

• Dit college gaat over one-to-one relaties en hoe deze opgeslagen kunnen worden in en database binnen en object-georiënteerde programmeer omgeving

One-to-One Relaties

• Een one-to-one relatie betekent dat één instantie van een klasse gerelateerd is aan
• Slechts één instantie van een andere klasse. Voorbeeld daarvan is: Er is één User die maar één ProfilePicture heeft

Persisting One-to-One Relaties

• In databases worden one-to-one relaties bewaard door elke klasse een eigen tabel te geven
• De relatie wordt tot stand gebracht met foreign keys.

Voorbeeld database structuur: tableA primary key (id) tableB foreign key (tableA_id) de tableB ID vewijst naar de primaire sleutel van de tableA

One-to-One Relatie in Java Code

• Twee klassen refereren naar elkaar als attribuut
• Er staan code voorbeelden in de originele tekst

Implementatie van DAO en Database Mapping

• DAO (Data Access Object) wordt gebruikt voor interactie met de database en scheiding van businesslogica en databaseoperaties.
• DAO verantwoordelijkheden: ClassA_DAO slaat ClassA op en roept ClassB_DAO.save() aan.
• ClassB_DAO beheert de foreign key-relatie. -In de originele tekst staan meer details rondom deze code voorbeelden
• CRUD Operaties en Relaties
• Create (save()) → Verantwoordelijke DAO slaat de foreign key op.
• Read (findBy()) → DAO moet het kind-object ook correct laden.
• Update → Zorg ervoor dat de relatie niet verloren gaat.
• Delete → Verwijder eerst het kind-object om referentiële integriteit te behouden.

Conclusie

• Elke klasse krijgt een eigen tabel.
• Foreign keys bewaren de relaties. DAO's werken samen om gegevens correct te beheren.
• CRUD operaties moeten de relatie respecteren.

Database Begrippen & SQL JOINS - Basisbegrippen van Databases

• Database: Een verzameling gestructureerde gegevens.
• Tabel: Een structuur in de database waarin gegevens worden opgeslagen.
• Rijen (Records/Tuples): Een enkele invoer in een tabel, bestaande uit meerdere velden.
• Veld (Attribuut/Kenmerk): Een kolom in een tabel die gelijksoortige informatie bevat.
• Primary Key (PK): Een unieke identificerende kolom of combinatie van kolommen in een tabel.
• Foreign Key (FK): Een kolom die verwijst naar een Primary Key in een andere tabel, waardoor een relatie tussen tabellen ontstaat.

Relaties tussen Tabellen

• Een foreign key verwijst naar een primary key van een andere tabel. Dit zorgt ervoor dat gegevens correct aan elkaar gekoppeld worden.
  • Orders(OrdersID) is gekoppeld aan Products (ProductID) via een foreign key

SQL JOINS – Gegevens uit Meerdere Tabellen Combineren

• Joins worden gebruikt om gegevens uit verschillende tabellen te combineren.

Hoe werkt een JOIN?

• In de originele tekst vind je code voorbeelden
• INNER JOIN: Geeft de resultaten van de overeenkomende rijen weer
• LEFT (OUTER) JOIN: Alle rijen uit de linker tabel en matchende rijen uit de rechter tabel RIGHT (OUTER) JOIN: Alle rijen uit de rechter tabel en matchende rijen uit de linker tabel
• FULL (OUTER) JOIN: Alle rijen uit beide tabellen, zelfs als er geen match is
• LEFT (OUTER) JOIN met exclusie: Rijen uit de linker tabel die geen match hebben in de rechter tabel

Waarde mismatch

• Niet alle waardes in de ene tabel zullen een overeenkomst hebben in de andere tabel
• Verschillende JOIN-types helpen om deze mismatches correct af te handelen

SQL JOINS zijn essentieel voor het combineren van gegevens uit meerdere tabellen en bieden flexibele manieren om relaties in databases te beheren.

SQL en JOIN syntax

• JOIN Syntax:

Er zijn 2 varianten - ANSI JOIN Syntax is de aanbevolen SQL-standaard voor joins. - Code Voorbeelden zie originele tekst - Non-ANSI JOIN Syntax is een oudere, minder aanbevolen stijl. - Code Voorbeelden zie originele tekst

ANSI vs NON-ANSI JOIN

• De klassieke JOIN bestond al voor de SQL-standaard. Beide stijlen worden nog steeds gebruikt, maar het advies is om altijd de SQL-standaardvorm te gebruiken.

Mini-casus voor JOIN

• We gebruiken twee tabellen om een JOIN uit te leggen mdw en func

Gebruik van Ongelijkheid

• Je kunt ook testen op ongelijkheden, zoals of een salaris tussen bepaalde waarden ligt zie originele tekst voor code voorbeelden

Types van JOINS

• INNER JOIN: toont alleen overeenkomende rijen uit beide tabellen, voor de tabel voorbeelden zie je de originele tekst
• Zie originel tekst verder voor LEFT OUTER JOIN, FULL OUTER JOIN de codes

Kolomnaamconflict

• Probleem: Wanneer twee tabellen dezelfde kolomnamen hebben en je deze wilt combineren in een JOIN. Oplossingen: a.) Expliciete Naamgeving: Verwijs naar de kolommen met de tabelnaam. B.) Gebruik Aliassen: Wanneer je een tabel meerdere keren wilt JOINen, kun je aliassen gebruiken om conflicten te vermijden.

Code Kwaliteit - Algemene Adviezen

1. Schrijf code voor mensen:
   • Denk aan je collega's en jezelf als je code onderhoudt.
   • Zorg voor consistente opmaak (naamgeving, witruimte, hoofdlettergebruik).
2. Gebruik commentaar zorgvuldig: - Verklaar waarom je keuzes maakt, niet wat de code doet. - Zorg dat je code zelfverklarend is waar mogelijk.
3. Gebruik versiebeheer: - Commit vaak en gebruik branches.
4. Test je code: - Schrijf unit tests en automatiseer ze.
5. Organiseer je bestanden goed: - Gebruik logische mappen en consistente naamgeving.
6. Verdiep je in tools (bijv. IDE):
   • Leer debuggen, versiebeheer en dependency management.
7. Organiseer je code: Houd klassen en methoden klein en doelgericht (één ding goed).

Code Kwaliteit - Object Specifieke Adviezen

1. -a Naamgeving:

• Kies duidelijke namen die de bedoeling weergeven.
• Gebruik werkwoorden voor methoden en zelfstandig naamwoorden voor klassen.
• Vermijd afkortingen tenzij ze vanzelfsprekend zijn.
• Gebruik een lange naam voor variabelen met een grote scope. Exception handling:Los exceptions op of log ze en gooi ze opnieuw als nodig.

2. --Data ophalen: Haal niet meer data op dan nodig is, bijv. in SQL-query’s.

3. -Gebruik van SQL in Java: Vermijd SELECT * en kies expliciet welke kolommen je nodig hebt.

• Gebruik multiline strings voor overzichtelijkheid.

4. -Output Formatteren:Maak de uitvoer leesbaar door formattering te gebruiken (bijv. String.format). 5.-
5. -Commentaar op de 'Waarom':Leg niet alleen uit wat de code doet, maar ook waarom keuzes zijn gemaakt.
6. -SQL Code Netjes Opmaken:Zorg voor consistent gebruik van hoofdletters voor SQL-keywords.