Kwaliteitsregeltaal

Een formele, leesbare taal voor het beschrijven van kwaliteitsregels voor gegevens

Inleidingbewerken

De Kwaliteitsregeltaal (KRT) is een gestructureerde, formele taal waarmee je regels kunt opstellen om de kwaliteit van gegevens te toetsen. Het doel is om zowel voor mensen als machines begrijpelijk te zijn: iemand zonder technische kennis kan regels lezen, schrijven en begrijpen en softwaresystemen kunnen de regels automatisch uitvoeren. Het doel is om de kloof tussen de wereld van de business en de wereld van de techniek te overbruggen. Kwaliteitsregels moeten eenvoudig uitgedrukt en begrepen kunnen worden.

KRT fungeert als een contract: een formele afspraak over hoe data eruit moet zien, opgeschreven in begrijpelijke taal. De taal is een vereenvoudiging van talen zoals SPARQL, SHACL en SQL. KRT is zelf alleen bedoeld om beperkingsregels te beschrijven en is dus géén querytaal. De taal biedt een minimale set aan krachtige concepten die de belangrijkste soorten kwaliteitsregels kunnen beschrijven.

Een regel in KRT beschrijft aan welke voorwaarden gegevens moeten voldoen. Een softwaresysteem voert die regel daarna uit voor elk object in de dataset. Slaagt een object niet voor de regel, dan is er een mogelijk kwaliteitsprobleem gedetecteerd. In een deel van de gevallen zijn dit echt fouten en zou je de gegevens liefst al eerder hebben afgewezen bij registratie. Andere gevallen zijn meer een indicatie van een mogelijke fout en duiden op een inplausibele waarde.

KRT is bedoeld om regels expliciet te maken van de gegevenselementen van een dataset die expliciet worden gecontroleerd op hun kwaliteit. Daarbij ligt de focus op de belangrijkste regels en de belangrijkste gegevenselementen (kritieke gegevenselementen).

In gegevensmodellen en schema's worden ook regels gedefinieerd. Deze regels kunnen grotendeels ook met KRT worden beschreven. Dat is relevant als deze modellen en schema's ontbreken of onvolledig zijn. Daarnaast is het mogelijk om in KRT regels uit te drukken die niet standaard onderdeel zijn van dit soort modellen of schema's. Denk daarbij vooral aan regels die uitspraken doen over de relaties tussen gegevens of over het geheel van gegevens. KRT is daardoor ook een goede aanvulling op bijvoorbeeld het Metamodel Informatie Modellering, dat vrij laat hoe beperkingsregels precies worden vastgelegd.

KRT is een aanvulling op het NORA Raamwerk gegevenskwaliteit dat beschrijft welke aspecten van kwaliteit kunnen worden gemeten. Het is ook mogelijk om een regel in KRT direct te relateren aan een kwaliteitsmetriek in het NORA raamwerk. Tools kunnen hieruit ook de van toepassing zijnde kwaliteitdimensie en kwaliteitsattribuut afleiden. In kwaliteitsrapportages conform het NORA raamwerk kan ook worden verwezen naar regels in KRT.

De basis van KRT is taalonafhankelijk en kan gebruikt worden voor elke vorm van gegevenskwaliteitscontrole. Voor projecten die werken met geo-informatie biedt KRT een optionele ruimtelijke extensie.

Er is een vertalertool ontwikkeld die regels die zijn opgesteld in KRT kan vertalen naar (Geo)SPARQL en SQL. Deze applicatie is bedoeld als demonstrator voor de taal. Er is ook een demonstrator van een validatietool beschikbaar, die ondersteuning biedt voor het valideren van de kern van de taal (zonder ruimtelijke extensie) op SPARQL endpoints. Beide tools zijn beschikbaar op de GitLab omgeving van het Federatief Datastelsel.

KRT is opgesteld door Danny Greefhorst vanuit zijn rol bij Bureau Architectuur Digitale Overheid van het ministerie van Binnenlandse zaken. De standaard heeft geen formele status.

Basisstructuurbewerken

Elke KRT-regel richt zich primair op instanties van objecttypes, zoals persoon of adres. De regel wordt niet op de klasse als geheel toegepast, maar op elk afzonderlijk object. Vanuit dat object verwijs je naar haar kenmerken via een pad: een punt-gescheiden reeks van namen (identifiers) die door de datastructuur navigeert. Het is echter ook mogelijk om controles uit te voeren op de gehele populatie van een objecttype.

De regels worden gebruikt om controles uit te voeren en ze bevatten expressies die leiden tot een WAAR of ONWAAR uitkomst. Expressies bestaan uit operatoren en operanden. Een operator kun je zien als een soort functie, die invoerparameters (operanden) krijgt en tot een resultaat leidt. Operanden zijn attributen van objecten, van paden of van vaste waarden (literals). Je kunt expressies met logische operatoren zoals EN en OF samenvoegen tot een grotere expressie.

De algemene structuur van een regel ziet er als volgt uit:

REGEL Identifier VOOR [ POPULATIE ] ObjectType [ METRIEK MetricIdentifier ] : RegelBody

Onderdeel	Betekenis	Voorbeelden
`REGEL`	Sleutelwoord dat de start van een regel aangeeft	`REGEL`
`Identifier`	Een unieke, beschrijvende naam voor de regel	`PostcodeVerplicht`
`VOOR [ POPULATIE ] ObjectType`	De eenheid waarop de regel van toepassing is.	`VOOR Adres` of `VOOR POPULATIE Gebouw`
`[ METRIEK MetricIdentifier ]`	Optionele verwijzing naar een kwaliteitsmetriek uit een kwaliteitsraamwerk.	`METRIEK AttribuutCompleetheidMetric`
`RegelBody`	De eigenlijke validatielogica	`postcode IS NIET LEEG`

Een KRT regel start altijd op een nieuwe tekstregel. Regeleinden en spaties hebben geen betekenis in KRT. KRT regels kunnen dus over meerdere tekstregels heen gedefinieerd worden. Commentaar kan tussen "(*" en "*)" op willekeurige plaatsen in de regeltekst worden geplaatst.

Een voorbeeld van een regel voor individuele objecten is:

(* Deze regel stelt dat personen een naam moeten hebben *)
REGEL persoon_heeft_naam VOOR Persoon:
    HEEFT naam

Een voorbeeld van een regel die van toepassing is op een populatie van objecten is:

(* Deze regel stelt er minimaal 100 gebouwen moeten zijn *)
REGEL minimum_aantal_gebouwen VOOR POPULATIE Gebouw:
    HEEFT AANTAL >= 100

Een populatie kan worden beperkt met een filter met de vorm ALS ... DAN .... De expressie achter ALS bepaalt welke instanties worden meegenomen in de populatie-analyse; de controle achter DAN is het filter dat over de gehele populatie heen wordt gehaald. Zie bijvoorbeeld de volgende regel:

(* Deze stelt dat er minimaal 100 gebouwen met bouwjaar later dan 2000 moeten zijn *)
REGEL minimum_aantal_gebouwen VOOR POPULATIE Gebouw:
    ALS bouwjaar > 2000 
    DAN HEEFT AANTAL >= 100

Er kan dus het sleutelwoord METRIEK een verwijzing naar een kwaliteitsmetriek in een kwaliteitsraamwerk worden gemaakt. Er is in KRT een voorkeur voor het gebruik van het NORA raamwerk gegevenskwaliteit en de standaard kwaliteitsmetrieken uit dat raamwerk worden daarom ook herkend. Hiervoor is geen prefix noodzakelijk, maar kan gewoon de naam van de metriek zelf als identifier worden gebruikt zoals ThematischeJuistheidMetric. Tools kunnen op basis van de relatie naar de kwaliteitsmetriek ook de bovenliggende kwaliteitsattribuut en kwaliteitsdimensie achterhalen.

Waarden en datatypesbewerken

Een expressie in KRT bestaat uit operatoren en operanden. Een operator kun je zien als een functie, die op basis van bepaalde invoerparameters (de operanden) tot een bepaalde waarde komt. Een expressie leidt daarbij tot het resultaat WAAR of ONWAAR. Operanden zijn dus de parameters van de operatoren. Dat kunnen concrete waarden zijn, zoals een getal of een tekst. Dergelijke concrete waarden heten literals. Het kunnen ook verwijzingen zijn naar gegevens in de vorm van identifiers of paden (zie verderop). KRT hanteert een strikt typesysteem om semantische fouten te voorkomen.

De volgende datatypes worden door KRT onderscheiden.

Type	Notatie	Omschrijving	Voorbeeld
`TEKST`	Dubbele aanhalingstekens	Alfanumerieke reeksen	`"Amsterdam"`, `"Actief"`
`GETAL`	Punt als decimaalscheiding	Hele of decimale getallen	`18`, `52.37`
`BOOLEAN`	Verplicht in hoofdletters	Waar/onwaar-waarden	`WAAR`, `ONWAAR`
`DATUM`	`DD-MM-JJJJ` of dynamisch	Harde datums of relatieve waarden	`31-12-1972`, `VANDAAG`
`TIJD`	`UU:MM:SS` of dynamisch	Tijdstippen of relatieve waarden	`14:30:00`, `NU`
`URI`	Punthaakjes `<...>`	Web-verwijzingen naar concepten of bronnen	`<https://data.overheid.nl/id/concept/adres>`
`GEOMETRIE`	Zie ruimtelijke extensie

Merk op dat er in KRT geen onderscheid wordt gemaakt tussen gehele getallen en getallen met een komma. Er is in KRT een speciale operator (HEEFT PRECISIE) waarmee het aantal getallen achter de komma expliciet wordt gemaakt. Een geheel getal is dan een getal met een precisie van 0 getallen achter de komma.

Identifiersbewerken

Er wordt naar gegevens verwezen met identifiers en paden. Een identifier is een unieke naam van een bepaald soort gegeven, zoals een objecttype of een attribuut. Een objecttype is de typering van een groep objecten die binnen een domein relevant zijn en als gelijksoortig worden beschouwd. Een attribuut (ook wel: attribuutsoort) is de typering van gelijksoortige gegevens die voor een objecttype van toepassing is. Een voorbeeld van een objecttype is persoon. Een voorbeeld van een attribuut is naam.

Identifiers bestaan meestal uit een verzameling letters, zonder spaties. In KRT zijn identifiers algemener gedefinieerd zodat ook Uniform Resource Identifiers (URI's) als identifier kunnen worden gebruikt. Dit soort identifiers starten typisch met "https://...". Hierdoor is het mogelijk om wereldwijd unieke namen toe te kennen. Het sluit ook goed aan op de context van Linked Data, waarbij alle gegevens voorzien zijn van een dergelijke URI.

Er kan ook gebruik worden gemaakt van prefixes in identifiers. Een prefix is een standaard voorvoegsel dat voor een naam wordt geplaatst. In de context van Linked Data verwijst dit typisch naar een weblocatie voor een bepaald gegeven en is het dus een URI-prefix. De prefix wordt gescheiden van de naam middels een dubbele punt (:). Het gebruik van prefixen is optioneel en vooral relevant als de regels worden gebruikt in de context van Linked Data. De inhoud van de prefixes kunnen niet in KRT worden uitgedrukt, en moeten later in de keten worden toegevoegd. Identifiers die niet zijn voorzien van een specifieke prefix kunnen daarbij automatisch een standaard prefix krijgen.

Het is mogelijk om in expressies te verwijzen naar het huidige object. Een voorbeeld hiervan is het uitsluiten van reflexiviteit: een concept of object mag in een taxonomie of hiërarchie nooit naar zichzelf verwijzen. Hiervoor wordt gebruik gemaakt van het sleutelwoord id. Dit sleutelwoord mag uitsluitend worden gebruikt als rechterlid binnen een vergelijking. Het mag niet gebruikt worden als functienaam of als onderdeel van een genest relatiepad.

Een voorbeeld van het gebruik van dit sleutelwoord is:

REGEL broader_niet_reflexief VOOR Concept:
  broader <> id

Padenbewerken

Om bij gegevens te komen waarvoor door de gegevensstructuur heen moet worden genavigeerd, maakt KRT gebruik van paden. Een pad is een manier om door de gegevensstructuur heen gaan door het volgen van een verzameling van identifiers. De eerste identifier in een pad verwijst typisch naar een relatie. De volgende identifier verwijst naar een specifiek attribuut of naar een andere relatie. Paden bestaan uit een verzameling identifiers gescheiden door een punt (.). Het softwaresysteem dat KRT interpreteert zal deze paden vertalen naar verbindingen tussen objecten, zoals JOIN's in de context van SQL.

Een voorbeeld van een pad is:

heeftRijstrook.maaktDeelUitVanWegas.geometrie

Het is ook mogelijk gegevens te spiegelen aan de rest van de dataset. Dat is bijvoorbeeld handig voor het detecteren van uitbijters. Hiervoor wordt gebruik gemaakt van het sleutelwoord "POPULATIE" als eerste deel van een pad. Voorafgaand aan dat sleutelwoord kan respectievelijk "SOM VAN", "MIN VAN ", "MAX VAN" of "GEMIDDELDE VAN" staan om aan te geven welke berekening op de populatie moet worden gedaan.

Een voorbeeld van het gebruik van deze constructie is:

prijs <= (GEMIDDELDE VAN POPULATIE.prijs) * 1.20

Deze constructie stelt dat de prijs niet meer dan 20% boven het gemiddelde mag liggen.

Een andere constructie die hier dicht tegen aan ligt is als identifiers in een pad verwijzen naar dingen waarvan er meerdere instanties zijn. In dat geval kan ook de som, minimum, maximum of gemiddelde worden bepaald. De structuur en formulering wijkt echter af van voorgaande, maar volgt die van de manier waarop regels worden geformuleerd die over de populatie als geheel gaan.

Logische operatorenbewerken

Condities kun je met elkaar combineren via logische operatoren. Om dubbelzinnigheid te voorkomen, hanteert KRT een strikte prioriteitsvolgorde (precedentie). Operatoren die hoger in de lijst staan, worden als eerste verwerkt. Je kunt altijd ronde haakjes ( ) gebruiken om de standaardvolgorde handmatig aan te passen of als je twijfelt aan de evaluatievolgorde.

De standaard prioriteitsvolgorde van logische operatoren is:

Operator	Precedentie	Betekenis
`ALS ... DAN ... ANDERS`	1 (hoogste)	Conditionele vertakking. Als de conditie achter `ALS` waar is, moet de expressie achter `DAN` slagen. Is de conditie onwaar, dan moet de expressie achter `ANDERS` slagen.
`OF`	2	Inclusieve disjunctie: de regel slaagt als minstens één van de deelcondities waar is.
`XOR`	3	Exclusieve disjunctie: de regel slaagt als exact één van beide deelcondities waar is en de andere onwaar. `A XOR B` is semantisch gelijk aan `(A EN NIET B) OF (NIET A EN B)`.
`EN`	4	Conjunctie: alle deelcondities moeten gelijktijdig waar zijn.
`NIET`	5 (laagste)	Unaire negatie: keert een ware conditie om naar onwaar en vice versa.

Vergelijkingsoperatorenbewerken

Een vergelijking toetst twee expressies aan elkaar met een vergelijkingsoperator. Het resultaat is altijd WAAR of ONWAAR.

Operator	Betekenis
`=`	Gelijk aan
`<>`	Niet gelijk aan
`<`	Kleiner dan
`>`	Groter dan
`<=`	Kleiner dan of gelijk aan
`>=`	Groter dan of gelijk aan

Numerieke operatorenbewerken

Wanneer operanden van het type GETAL zijn, kunnen ze gekoppeld worden met +, -, * en / voor reguliere wiskundige berekeningen.

Er is een speciale operator gedefinieerd om de precisie van een getal expliciet te maken. Hiermee kun je ook uitdrukken dat een getal altijd een geheel getal moet zijn (deze heeft dan een precisie van 0). Een vergelijkingsoperator zoals = of <> is daarbij optioneel.

Syntax	Werking
`Pad HEEFT PRECISIE [VergelijkingsOperator] GetalLiteral`	Valideert het maximale aantal toegestane decimalen achter de komma.

Tekstoperatoren en functiesbewerken

Binnen KRT is het mogelijk om tekstfragmenten samen te voegen met behulp van het + teken. Een voorbeeld daarvan is:

adres.straatnaam + " " + adres.huisnummer = "Kerkstraat 12"

Er is een functie beschikbaar om een deel van een tekst te selecteren.

SUBSTRING(Pad, startpositie, lengte)

De volgende expressie controleert of de eerste 7 tekens van de lokale ID overeenkomen met de IMRO-prefix.

SUBSTRING(identificatie.lokaalID, 1, 7) = "NL.IMRO"

Er zijn verder in KRT operatoren gedefinieerd waarmee je eigenschappen van teksten kunt controleren.

Syntax	Werking
`Pad START MET StringLiteral`	Controleert of een tekst begint met het opgegeven tekstfragment.
`Pad EINDIGT OP StringLiteral`	Controleert of een tekst eindigt met het opgegeven tekstfragment.
`Pad BEVAT StringLiteral`	Controleert of het opgegeven tekstfragment ergens in een tekst voorkomt.
`Pad HEEFT LENGTE GetalLiteral`	Telt het exacte aantal tekens van een tekst.
`Pad HEEFT TAAL StringLiteral`	Geeft het label van de taal van de tekst.
`VOLGT PATROON StringLiteral`	Controleert of een tekst voldoet aan een bepaalde reguliere expressie.

De taal wordt uitgedrukt in termen van de IANA Subtags zoals "nl", "en" of "de".

naam HEEFT TAAL "nl"

Een voorbeeld van de toepassing van de VOLGT PATROON operator is:

postcode VOLGT PATROON "^[1-9][0-9]{3}[A-Z]{2}$"

Bestaan, leegte en typesbewerken

Om te controleren of gegevens technisch correct zijn aangeleverd, kent KRT drie afzonderlijke constructies.

Constructie	Wat wordt gecontroleerd
`HEEFT Pad`	Controleert of de eigenschap of relatie aanwezig is ongeacht de inhoud ervan.
`Pad IS [NIET] LEEG`	Controleert de inhoudelijke vulling. Een veld is leeg als het bestaat maar een lege tekst `""` of een NULL-waarde bevat.
`Pad IS BasisType`	Controleert runtime of het datatype van de waarde overeenkomt met het verwachte datatype.

Voorbeelden:

HEEFT adresseerbaarObject.postcode

tijdstipRegistratie IS NIET LEEG

volledigeNaam IS TEKST

Waardelijstenbewerken

Pad IN { Operand, Operand, ... }

Controleert of een waarde voorkomt in een statische opsomming van toegestane waarden. Het gecontroleerde pad en alle opgesomde waarden moeten van een identiek datatype zijn.

Een voorbeeld hiervan is:

status IN { "nieuw", "actief", "vervallen" }

Operatoren op verzamelingenbewerken

Er zijn drie situaties waarbij operatoren op verzamelingen van gegevens werken:

Situatie 1. Als er in de regel zelf, direct na het sleutelwoord "VOOR" het sleutelwoord "POPULATIE" staat. In dit geval gaat de regel over de verzameling van alle gegevens van een bepaald objecttype.

Bijvoorbeeld:

REGEL minimum_aantal_gebouwen VOOR POPULATIE Gebouw:
    HEEFT AANTAL >= 100

Situatie 2. Als het pad in een expressie start met het sleutelwoord "POPULATIE". In dit geval wordt een operator toegepast op alle waarden van een bepaalde eigenschap in de gehele dataset. Dit heet een aggregaatberekening.

Bijvoorbeeld:

REGEL minimum_bouwjaar_gebouwen VOOR Gebouw:
    MIN VAN POPULATIE.bouwjaar > 1950

Situatie 3. Als het pad in een expressie verwijst naar iets waar meerdere instanties van zijn. In dit geval heeft een relatie of attribuut een kardinaliteit groter dan 1 en kan een operator worden gekoppeld aan alle instanties.

Bijvoorbeeld:

REGEL minimaal_1_deur_in_gebouw VOOR Gebouw:
    deur HEEFT MIN > 1

Voor alle drie de situaties zijn er operatoren beschikbaar voor het bepalen van de optelsom, het maximum, het minimum of het gemiddelde van alle gegevens. De eerste en derde situatie zijn vergelijkbaar in de wijze waarop ze worden behandeld. Zij kennen een soortgelijke formulering (HEEFT SOM/MAX/MIN/GEMIDDELDE) en kennen ook beiden een operator voor het bepalen van het aantal gegevens (HEEFT AANTAL).

De tweede situatie (aggregaatberekening) kent een wat andere structuur. Het begint met de naam van een functie (SOM/MAX/MIN/GEMIDDELDE) gevolgd door "VAN POPULATIE" en een identifier. Deze vorm kent ook niet een operator voor het bepalen van het aantal gegevens.

Voor de eerste en derde situatie gelden de volgende operatoren:

Syntax	Werking
`HEEFT AANTAL [VergelijkingsOperator] GetalLiteral`	Telt het aantal gekoppelde objecten of waarden
`Pad HEEFT SOM [VergelijkingsOperator] WaardeExpressie`	Telt alle getallen op
`Pad HEEFT MAX [VergelijkingsOperator] WaardeExpressie`	Neemt de hoogste waarde
`Pad HEEFT MIN [VergelijkingsOperator] WaardeExpressie`	Neemt de laagste waarde
`Pad HEEFT GEMIDDELDE [VergelijkingsOperator] WaardeExpressie`	Berekent het gemiddelde

Voor de derde situatie waarin een pad verwijst naar iets waar meerdere instanties van zijn, zijn er operatoren beschikbaar voor universele kwantificering (VOOR ELK) en existentiële kwantificering (ER IS).

VOOR ELK ElementVar IN Pad : Conditie

Universele kwantificering betekent dat een conditie moet gelden voor elke instantie. Een voorbeeld hiervan is:

VOOR ELK doel IN bevatPlandoel: doel.status = "vastgesteld"

Existentiële kwantificering betekent dat een conditie voor minimaal 1 element moet gelden.

ER IS ElementVar IN Pad : Conditie

Een voorbeeld van existentiële kwantificering is:

ER IS appendant IN heeftAppendant: appendant.heeftBeheerder IS NIET LEEG

Uniciteit en relatie-integriteitbewerken

Om de samenhang en exclusiviteit van gegevens over een dataset te bewaken, kent KRT de volgende operatoren.

Operator	Werking
`UNIEK AttribuutLijst`	Werkt als een primaire sleutel. Dwingt af dat de waarde (of de combinatie van waarden) van de opgegeven attributen in de gehele dataset maar één keer mag voorkomen.
`UNIEK AttribuutLijst PER GroepsAttribuut`	Introduceert lokale groepsuniciteit. De waarde hoeft niet uniek te zijn in de hele dataset, maar mag geen duplicaten bevatten binnen de subset van objecten die hetzelfde groepsattribuut delen.
`Pad BESTAAT IN ObjectType.Identifier`	Handhaaft referentiële integriteit. De waarde van het pad moet als geldige identificatie of sleutel bestaan binnen de vermelde doelklasse — vergelijkbaar met een foreign key-constraint.
`Pad IS SYMMETRISCH`	Exclusief voor relaties tussen objecten. Dwingt af dat als Object A via deze relatie naar Object B verwijst, Object B verplicht via exact dezelfde relatiestructuur terugverwijst naar Object A.
`Pad IS INVERSE VAN Pad`	Dwingt af dat de relatie de inverse is van een tweede relatie. Als Object A via het eerste pad naar Object B verwijst, dan moet Object B verplicht via het tweede pad terugverwijzen naar Object A. Dit is de asymmetrische tegenhanger van `IS SYMMETRISCH`: twee verschillende relaties worden als inversen van elkaar gedefinieerd.

Voorbeelden:

UNIEK burgerservicenummer

UNIEK afdelingsnaam PER maaktDeelUitVanOrganisatie

heeftGemeentecode BESTAAT IN Gemeente.code

heeftPartner IS SYMMETRISCH

broader IS INVERSE VAN narrower

Ruimtelijke extensiebewerken

Deze bijlage beschrijft de optionele ruimtelijke extensie van KRT voor geografische gegevens. Deze extensie is gebaseerd op GeoSPARQL. Alle operatoren vereisen dat het pad aan de linkerkant van het type GEOMETRIE is.

Optioneel: Deze extensie is niet verplicht om te implementeren. Alle andere onderdelen van KRT werken volledig zonder deze functionaliteit.

Basistypen voor geografische gegevensbewerken

Type	Notatie	Omschrijving	Voorbeeld
`GEOMETRIE`	WKT-formaat in aanhalingstekens	Algemene ruimtelijke vorm	`"POINT(4.89 52.37)"`
`PUNT`	WKT POINT	Eendimensionale positie in ruimte	`"POINT(4.89 52.37)"`
`LIJN`	WKT LINESTRING	Eendimensionale lijn (pad)	`"LINESTRING(4.89 52.37, 5.0 52.4)"`
`VLAK`	WKT POLYGON	Tweedimensionale veelhoek (synoniem voor POLYGOON)	`"POLYGON((4.89 52.37, 5.0 52.4, 5.0 52.3, 4.89 52.37))"`

Topologische relatiesbewerken

Deze operatoren leggen een topologische relatie tussen twee geometrieën. Het linkerpad en de rechter operand moeten beide van het type GEOMETRIE zijn. De operatoren zijn één-op-één vertaald naar de corresponderende GeoSPARQL Simple Features-functies.

Syntax	GeoSPARQL Functie	Werking
`Pad LIGT BINNEN Operand`	sfWithin	De geometrie van het pad valt volledig binnen de geometrie van de operand.
`Pad RAAKT Operand`	sfTouches	De geometrieën raken elkaar in ten minste één punt maar overlappen niet.
`Pad OVERLAPT Operand`	sfOverlaps	De geometrieën overlappen gedeeltelijk (zelfde dimensie).
`Pad KRUIST Operand`	sfCrosses	De geometrieën kruisen elkaar (verschillende dimensies).
`Pad DEELT GRENS MET Operand`	relate	De geometrieën delen een gemeenschappelijke grens (buren).
`Pad CONGRUENT Operand`	sfEquals	De geometrieën zijn topologisch gelijk (vorm en positie).
`Pad BEVAT Operand`	sfContains	De geometrie van het pad bevat de geometrie van de operand volledig.
`Pad DISJUNCT Operand`	sfDisjoint	De geometrieën hebben geen enkel punt gemeenschappelijk.

Voorbeelden:

perceel.geometrie LIGT BINNEN gemeente.geometrie

perceel.geometrie DEELT GRENS MET aangrenzendPerceel.geometrie

weg.geometrie KRUIST waterweg.geometrie

Meetoperatorenbewerken

Voor afstandsmetingen en fysieke dimensies sluit KRT aan bij de meetfuncties van GeoSPARQL. De maateenheden zijn gebaseerd op de QUDT standaard. Om de taal optimaal leesbaar en compact te houden wordt de QUDT URI-prefix volledig weggelaten. De gewenste maateenheid (zoals M, KiloM, of M2) wordt direct achter de getalwaarde gezet.

Syntax	GeoSPARQL Functie	Werking
`Pad HEEFT AFSTAND Operand VergelijkingsOperator GetalLiteral Identifier`	distance	Berekent de kortste afstand tussen twee geografische vormen.
`Pad HEEFT OPPERVLAKTE VergelijkingsOperator GetalLiteral Identifier`	area	Berekent de tweedimensionale grootte van een polygoon.
`Pad HEEFT LENGTE VergelijkingsOperator GetalLiteral Identifier`	length	Berekent de eendimensionale lengte van een lijn.
`Pad HEEFT OMTREK VergelijkingsOperator GetalLiteral Identifier`	length	Berekent de totale lengte van de buitenrand van een polygoon.

Voorbeelden:

geografischeLigging.geometrie HEEFT AFSTAND heeftWegas.geometrie <= 500 M

provinciegebied.geometrie HEEFT OPPERVLAKTE >= 1250.50 M2

traject.geometrie HEEFT LENGTE < 15 KiloM

perceel.geometrie HEEFT OMTREK <= 2500 M

Formele grammaticabewerken

In deze paragraaf staat de formele specificatie van de taal in EBNF-grammatica (Extended Backus–Naur Form). Dit is een standaard notatie om de grammatica van een formele taal te beschrijven. Elke regel legt vast welke constructies geldig zijn. Ronde haakjes groeperen, | staat voor 'of', * betekent 'nul of meer keer' en [ ] betekent 'optioneel'. Sleutelwoorden zijn dikgedrukt en tussen enkele aanhalingstekens weergegeven.

Volledige EBNF-grammatica
Regel	Definitie
▷ Basisstructuur
Regel	'REGEL' Identifier 'VOOR' ['POPULATIE'] ObjectType ['METRIEK' MetricIdentifier] ':' RegelBody
RegelBody	Expressie
▷ Logica
Expressie	AlsDanAndersExpressie \| LogischeOfExpressie
AlsDanAndersExpressie	'ALS' Expressie 'DAN' Expressie 'ANDERS' Expressie \| PopulatieFilter
PopulatieFilter	'ALS' Expressie 'DAN' PopulatieCheck
LogischeOfExpressie	LogischeXorExpressie ( 'OF' LogischeXorExpressie )*
LogischeXorExpressie	LogischeEnExpressie ( 'XOR' LogischeEnExpressie )*
LogischeEnExpressie	NietExpressie ( 'EN' NietExpressie )*
NietExpressie	[ 'NIET' ] PrimaireExpressie
PrimaireExpressie	Vergelijking \| BestaanControle \| PatroonControle \| WaardelijstControle \| TypeControle \| UniciteitControle \| RelatieControle \| OperatorControle \| KwantificeringControle \| SubstringExpressie \| '(' Expressie ')'
Vergelijking	WaardeExpressie VergelijkingsOperator VergelijkingValue
▷ WaardeExpressies
WaardeExpressie	EvaluatieOperand ( AlgebraïscheOperator EvaluatieOperand )*
EvaluatieOperand	Pad \| Literal \| AggregaatBerekening \| '(' WaardeExpressie ')'
AlgebraïscheOperator	'+' \| '-' \| '*' \| '/'
BestaanControle	'HEEFT' Pad \| Pad 'IS' [ 'NIET' ] 'LEEG'
PatroonControle	Pad 'VOLGT PATROON' StringLiteral
WaardelijstControle	Pad 'IN' '{' Operand ( ',' Operand )* '}'
TypeControle	Pad 'IS' BasisType
UniciteitControle	'UNIEK' AttribuutLijst [ 'PER' GroepsAttribuut ]
RelatieControle	Pad 'BESTAAT IN' ObjectType '.' Identifier \| Pad 'IS SYMMETRISCH' \| Pad 'IS INVERSE VAN' Pad
KwantificeringControle	'VOOR' 'ELK' Identifier 'IN' Pad ':' [ '(' ] Expressie [ ')' ] \| 'ER' 'IS' Identifier 'IN' Pad ':' '(' Expressie ')'
SubstringExpressie	SubstringFunctie VergelijkingsOperator VergelijkingValue
SubstringFunctie	'SUBSTRING' '(' Pad ',' GetalLiteral ',' GetalLiteral ')'
AggregaatBerekening	AggregaatFunctie 'VAN POPULATIE' '.' Identifier
AggregaatFunctie	'SOM' \| 'MAX' \| 'MIN' \| 'GEMIDDELDE'
▷ Operatorcontroles voor tekst, getallen en kardinaliteit
OperatorControle	Pad 'START MET' StringLiteral \| Pad 'EINDIGT OP' StringLiteral \| Pad 'BEVAT' StringLiteral \| Pad 'HEEFT LENGTE' [ VergelijkingsOperator ] GetalLiteral \| Pad 'HEEFT AANTAL' [ VergelijkingsOperator ] GetalLiteral \| Pad 'HEEFT TAAL' [ VergelijkingsOperator ] StringLiteral \| Pad 'HEEFT PRECISIE' [ VergelijkingsOperator ] GetalLiteral \| Pad 'HEEFT SOM' [ VergelijkingsOperator ] WaardeExpressie \| Pad 'HEEFT MAX' [ VergelijkingsOperator ] WaardeExpressie \| Pad 'HEEFT MIN' [ VergelijkingsOperator ] WaardeExpressie \| Pad 'HEEFT GEMIDDELDE' [ VergelijkingsOperator ] WaardeExpressie \| GeoControle \| PopulatieCheck
PopulatieCheck	'HEEFT AANTAL' VergelijkingsOperator GetalLiteral \| Pad 'HEEFT SOM' VergelijkingsOperator WaardeExpressie \| Pad 'HEEFT GEMIDDELDE' VergelijkingsOperator WaardeExpressie \| Pad 'HEEFT MAX' VergelijkingsOperator WaardeExpressie \| Pad 'HEEFT MIN' VergelijkingsOperator WaardeExpressie
▷ Ruimtelijke operatoren
GeoControle	Pad TopologischeOperator Operand \| Pad 'HEEFT AFSTAND' Operand VergelijkingsOperator GetalLiteral Eenheid \| Pad 'HEEFT OPPERVLAKTE' VergelijkingsOperator GetalLiteral Eenheid \| Pad 'HEEFT LENGTE' VergelijkingsOperator GetalLiteral Eenheid \| Pad 'HEEFT OMTREK' VergelijkingsOperator GetalLiteral Eenheid
Eenheid	Identifier
TopologischeOperator	'LIGT BINNEN' \| 'RAAKT' \| 'OVERLAPT' \| 'KRUIST' \| 'DEELT GRENS MET' \| 'CONGRUENT' \| 'BEVAT' \| 'DISJUNCT'
▷ Operanden, Literals en Waarden
VergelijkingValue	WaardeExpressie \| 'id'
Operand	Pad \| Literal \| WaardeExpressie
Literal	StringLiteral \| GetalLiteral \| BooleanLiteral \| DatumLiteral \| TijdLiteral \| UriLiteral
▷ Basiselementen
VergelijkingsOperator	'=' \| '<>' \| '<' \| '>' \| '<=' \| '>='
BasisType	'TEKST' \| 'GETAL' \| 'DATUM' \| 'TIJD' \| 'BOOLEAN' \| 'URI' \| 'GEOMETRIE' \| 'PUNT' \| 'LIJN' \| 'VLAK'
BooleanLiteral	'WAAR' \| 'ONWAAR'
▷ Temporele literals
DatumLiteral	'VANDAAG' \| 'NU' \| Dag '-' Maand '-' Jaar
Dag	'0' [1-9] \| [1-2] [0-9] \| '3' [0-1]
Maand	'0' [1-9] \| '1' [0-2]
Jaar	[0-9] [0-9] [0-9] [0-9]
TijdLiteral	'NU' \| Uur ':' Minuut ( ':' Seconde )*
Uur	'0' [0-9] \| '1' [0-9] \| '2' [0-3]
Minuut	[0-5] [0-9]
Seconde	[0-5] [0-9]
UriLiteral	'<' UriKarakters* '>'
▷ Padnotatie en Flexibele Identifier grammatica
AttribuutLijst	Pad ( ',' Pad )*
Pad	Identifier ( '.' Identifier )*
GroepsAttribuut	Identifier
ObjectType	Identifier
MetricIdentifier	Identifier
Identifier	( Alfanumeriek \| SpeciaalUriTeken )+
StringLiteral	'"' [^"\]* '"'
GetalLiteral	[0-9]+ ( '.' [0-9]+ )*
▷ Karakters
Alfanumeriek	[a-zA-Z0-9]
SpeciaalUriTeken	'-' \| '.' \| '_' \| '~' \| ':' \| '/' \| '?' \| '#' \| '[' \| ']' \| '@' \| '!' \| '$' \| '&' \| "'" \| '(' \| ')' \| '*' \| '+' \| ',' \| ';' \| '='
UriKarakters	Alfanumeriek \| SpeciaalUriTeken \| '%' [0-9a-fA-F] [0-9a-fA-F]

Voorbeeldbewerken

Deze paragraaf geeft een voorbeeld van een verzameling van kwaliteitsregels voor het controleren van de kwaliteit van een begrippenkader. De regels zijn gedestilleerd uit beschrijvingen van het tool Skosify voor het controleren van een SKOS-gebaseerde vocabulaire.

REGEL pref_label_verplicht VOOR Concept:
    prefLabel IS NIET LEEG


REGEL uniek_pref_label_per_schema VOOR Concept:
    UNIEK prefLabel PER inScheme


REGEL labels_disjunct VOOR Concept:
    (prefLabel <> altLabel) EN 
    (prefLabel <> hiddenLabel) EN 
    (altLabel <> hiddenLabel)


REGEL hierarchie_inverse VOOR Concept:
    broader IS INVERSE VAN narrower


REGEL hierarchie_niet_reflexief VOOR Concept:
    (broader <> id) EN (narrower <> id)


REGEL related_is_symmetrisch VOOR Concept:
    related IS SYMMETRISCH


REGEL gerelateerd_en_hierarchisch_disjunct VOOR Concept:
    (related <> broader) EN (related <> narrower)


REGEL top_concept_is_inverse VOOR Concept:
    topConceptOf IS INVERSE VAN hasTopConcept


REGEL top_concept_in_schema VOOR Concept:
    ALS HEEFT topConceptOf
    DAN topConceptOf = inScheme


REGEL skos_strict_datatypes VOOR Concept:
    (prefLabel IS TEKST) EN 
    (altLabel IS TEKST) EN 
    (hiddenLabel IS TEKST) EN 
    (broader IS URI) EN 
    (narrower IS URI) EN 
    (related IS URI) EN 
    (inScheme IS URI)


REGEL pref_label_taal_tag_verplicht VOOR Concept:
    prefLabel HEEFT TAAL <> ""


REGEL concept_moet_in_schema VOOR Concept:
    inScheme IS NIET LEEG


REGEL collection_heeft_members VOOR Collection:
    member IS NIET LEEG


REGEL top_concept_heeft_geen_broader VOOR Concept:
    ALS HEEFT topConceptOf
    DAN broader IS LEEG


REGEL schema_moet_top_concept_hebben VOOR ConceptScheme:
    hasTopConcept IS NIET LEEG


REGEL geen_directe_lus_broader VOOR Concept:
    ALS HEEFT broader
    DAN broader.broader <> id


REGEL geen_directe_lus_narrower VOOR Concept:
    ALS HEEFT narrower
    DAN narrower.narrower <> id


REGEL geen_indirecte_lus_broader_3_stappen VOOR Concept:
    ALS HEEFT broader.broader
    DAN broader.broader.broader <> id

Op deze pagina

Kwaliteitsregeltaal

Inleidingbewerken

Basisstructuurbewerken

Waarden en datatypesbewerken

Identifiersbewerken

Padenbewerken

Logische operatorenbewerken

Vergelijkingsoperatorenbewerken

Numerieke operatorenbewerken

Tekstoperatoren en functiesbewerken

Bestaan, leegte en typesbewerken

Waardelijstenbewerken

Operatoren op verzamelingenbewerken

Uniciteit en relatie-integriteitbewerken

Ruimtelijke extensiebewerken

Basistypen voor geografische gegevensbewerken

Topologische relatiesbewerken

Meetoperatorenbewerken

Formele grammaticabewerken

Voorbeeldbewerken