Inleiding
Wanneer u MongoDB gebruikt, hebt u de mogelijkheid om flexibel te zijn met de structuur van uw gegevens. U zit niet vast aan het handhaven van een bepaald schema waarin al uw documenten moeten passen. Voor elk veld in een document kunt u elk van de beschikbare gegevenstypes gebruiken ondersteund door MongoDB. Ondanks deze standaard manier van werken, kunt u desgewenst een JSON Schema in MongoDB opleggen om validatie aan uw collecties toe te voegen. We zullen in deze handleiding niet ingaan op de details van het ontwerpen van schema's, maar het kan een effect hebben op het typen van gegevens als het wordt geïmplementeerd.
Gegevenstypen specificeren een algemeen patroon voor de gegevens die ze accepteren en opslaan. Het is van het grootste belang om te begrijpen wanneer u een bepaald gegevenstype moet kiezen boven een ander bij het plannen van uw database. Het gekozen type zal bepalen hoe u met uw gegevens kunt werken en hoe deze worden opgeslagen.
JSON en BSON
Voordat we ingaan op de details van specifieke gegevenstypen, is het belangrijk om te begrijpen hoe MongoDB gegevens opslaat. MongoDB en vele andere op documenten gebaseerde NoSQL-databases gebruiken JSON (JavaScript Object Notation) om gegevensrecords als documenten weer te geven.
Er zijn veel voordelen aan het gebruik van JSON om gegevens op te slaan. Sommigen van hen zijn:
- gemakkelijk te lezen, te leren en bekendheid onder ontwikkelaars
- flexibiliteit in formaat, of het nu schaars, hiërarchisch of diep genest is
- zelfbeschrijvend, waardoor applicaties eenvoudig kunnen werken met JSON-gegevens
- zorgt voor de focus op een minimaal aantal basistypen
JSON ondersteunt alle basisgegevenstypen zoals string, nummer, boolean, enz. MongoDB slaat gegevensrecords eigenlijk op als binair gecodeerde JSON-documenten (BSON). Net als JSON ondersteunt BSON het inbedden van documenten en arrays in andere documenten en arrays. BSON maakt aanvullende gegevenstypen mogelijk die niet beschikbaar zijn voor JSON.
Wat zijn de gegevenstypen in MongoDB?
Laten we, voordat we in detail treden, een algemeen beeld geven van welke gegevenstypen worden ondersteund in MongoDB.
MongoDB ondersteunt een reeks gegevenstypen die geschikt zijn voor verschillende soorten zowel eenvoudige als complexe gegevens. Deze omvatten:
Tekst
String
Numeriek
32-Bit Integer64-Bit IntegerDoubleDecimal128
Datum/Tijd
DateTimestamp
Andere
ObjectArrayBinary DataObjectIdBooleanNullRegular ExpressionJavaScriptMin KeyMax Key
In MongoDB heeft elk BSON-type zowel een geheel getal als een tekenreeks-ID. We zullen in deze handleiding dieper ingaan op de meest voorkomende hiervan.
Tekenreeksen
Het stringtype is het meest gebruikte MongoDB-gegevenstype. Elke waarde tussen dubbele aanhalingstekens "" in JSON is een tekenreekswaarde. Elke waarde die u als tekst wilt opslaan, kunt u het beste typen als een String . BSON-strings zijn UTF-8 en worden in MongoDB weergegeven als:
Type | Number | Alias | ------------------ | ------ | -------- | String | 2 | "string" |
Over het algemeen worden stuurprogramma's voor programmeertalen geconverteerd van het tekenreeksformaat van de taal naar UTF-8 bij het serialiseren en deserialiseren van BSON. Dit maakt BSON een aantrekkelijke methode om bijvoorbeeld gemakkelijk internationale karakters op te slaan.
Een document invoegen met een String gegevenstype ziet er ongeveer zo uit:
db.mytestcoll.insertOne({first_name: "Alex"}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d15")}
Als u de verzameling opvraagt, wordt het volgende geretourneerd:
db.mytestcoll.find().pretty(){ _id: ObjectId("614b37296a124db40ae74d15"), first_name: "Alex"}
De $type gebruiken telefoniste
Voordat u doorgaat naar ons volgende gegevenstype, is het belangrijk om te weten hoe u kunt typen, controleer de waarde voordat u iets invoegt. We gebruiken het vorige voorbeeld om te demonstreren met de $type operator in MongoDB.
Laten we zeggen dat het een tijdje geleden is dat we met de mytestcoll hebben gewerkt collectie van vroeger. We willen wat extra documenten aan de collectie toevoegen met de first_name veld. Om te controleren of we String . hebben gebruikt als het gegevenstype opgeslagen als een waarde van first_name oorspronkelijk kunnen we het volgende uitvoeren met behulp van de alias of getalwaarde van het gegevenstype:
db.mytestcoll.find( { "first_name": { $type: "string" } } )
Of
db.mytestcoll.find( { "first_name": { $type: 2 } } )
Beide query's retourneren een uitvoer van alle documenten met een String waarde opgeslagen voor first_name van de invoeging van onze vorige sectie:
[ { _id: ObjectId("614b37296a124db40ae74d15"), first_name: "Alex" } ]
Als u een type zoekt dat niet is opgeslagen in de first_name veld van een document, krijgt u geen resultaat. Dit geeft aan dat het een ander gegevenstype is dat is opgeslagen in first_name .
U kunt ook naar meerdere gegevenstypen tegelijk zoeken met de $type operator zoals het volgende:
db.mytestcoll.find( { "first_name": { $type: ["string", "null"] } } )
Omdat we geen Null . hebben ingevoegd typ waarden in onze verzameling, het resultaat zal hetzelfde zijn:
[ { _id: ObjectId("614b37296a124db40ae74d15"), first_name: "Alex" } ]
U kunt dezelfde methode gebruiken met alle volgende typen die we zullen bespreken.
Getallen en numerieke waarden
MongoDB bevat een reeks numerieke gegevenstypen die geschikt zijn voor verschillende scenario's. Bepalen welk type u wilt gebruiken, hangt af van de aard van de waarden die u wilt opslaan en uw gebruiksscenario's voor de gegevens. JSON noemt alles met nummers een Nummer . Dat dwingt het systeem om erachter te komen hoe het kan worden omgezet in het dichtstbijzijnde native datatype. We beginnen met het onderzoeken van gehele getallen en hoe ze werken in MongoDB.
Integer
De Integer gegevenstype wordt gebruikt om getallen op te slaan als gehele getallen zonder breuken of decimalen. Gehele getallen kunnen zowel positieve als negatieve waarden zijn. Er zijn twee typen in MongoDB, 32-Bit Integer en 64-Bit Integer . Ze kunnen worden weergegeven op de twee manieren die worden weergegeven in de onderstaande tabel, number en alias :
Integer type | number | alias | ------------ | ----- | ------------ | `32-bit integer`| 16 | "int" | `64-bit integer`| 18 | "long" |
De bereiken waarbinnen een waarde kan passen voor elk type zijn de volgende:
Integer type | Applicable signed range | Applicable unsigned range | ------------ | ------------------------------ | ------------------------------- | `32-bit integer`| -2,147,483,648 to 2,147,483,647| 0 to 4,294,967,295 | `64-bit integer`| -9,223,372,036,854,775,808 to | 0 to 18,446,744,073,709,551,615 9,223,372,036,854,775,807
De bovenstaande typen zijn beperkt door hun geldige bereik. Elke waarde buiten het bereik resulteert in een fout. Een Integer invoegen type in MongoDB ziet er als volgt uit:
db.mytestcoll.insertOne({age: 26}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d14")}
En het vinden van het resultaat levert het volgende op:
db.mytestcoll.find().pretty(){ _id: ObjectId("614b37296a124db40ae74d14"), age: 26}
Zoals de namen suggereren, een 32-Bit Integer heeft 32 bits integer-precisie, wat handig is voor kleinere integer-waarden die u niet wilt opslaan als een reeks cijfers. Als je groter wordt, kun je oplopen tot het 64-Bit Integer die 64 bits integer-precisie heeft en past in dezelfde use case als de eerste.
Dubbel
In BSON, de standaardvervanging voor JSON's Number is de Double data type. De Double gegevenstype wordt gebruikt om een drijvende-kommawaarde op te slaan en kan als volgt in MongoDB worden weergegeven:
Type | Number | Alias | ------------------ | ------ | -------- | Double | 1 | "double" |
Drijvende-kommagetallen zijn een andere manier om decimale getallen uit te drukken, maar zonder exacte, consistente precisie.
Drijvende-kommagetallen kunnen efficiënt werken met een groot aantal decimalen, maar niet altijd precies. Het volgende is een voorbeeld van het invoeren van een document met de Double typ in je verzameling:
db.mytestcoll.insertOne({testScore: 89.6}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d13")}
Er kunnen kleine verschillen zijn tussen invoer en uitvoer bij het rekenen met dubbels die mogelijk tot onverwacht gedrag kunnen leiden. Bij het uitvoeren van bewerkingen die exacte waarden vereisen, heeft MongoDB een nauwkeuriger type.
Decimal128
Als u werkt met zeer grote getallen met veel drijvende-kommabereik, dan is de Decimal128 Het BSON-gegevenstype is de beste optie. Dit is het meest bruikbare type voor waarden die veel precisie vereisen, zoals in use-cases met exacte monetaire bewerkingen. De Decimal128 type wordt weergegeven als:
Type | Number | Alias | ------------------ | ------ | --------- | Decimal128 | 19 | "decimal" |
Het BSON-type, Decimal128 , biedt 128 bits decimale weergave voor het opslaan van getallen waarbij het nauwkeurig afronden van decimalen belangrijk is. Decimal128 ondersteunt 34 decimale cijfers van precisie, of een sinificand met een bereik van -6143 tot +6144. Dit zorgt voor een hoge mate van precisie.
Een waarde invoegen met behulp van de Decimal128 gegevenstype vereist het gebruik van de NumberDecimal() constructor met uw nummer als een String om te voorkomen dat MongoDB het standaard numerieke type gebruikt, Double .
Hier demonstreren we dit:
db.mytestcoll.insertOne({price : NumberDecimal("5.099")}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d12")}
Wanneer u de collectie opvraagt, krijgt u het volgende resultaat:
db.mytestcoll.find().pretty(){ _id: ObjectId("614b37296a124db40ae74d12"), price: "5.099" }
De numerieke waarde behoudt zijn precisie, waardoor exacte bewerkingen mogelijk zijn. Om de Decimal128 te demonstreren type versus de Double , kunnen we de volgende oefening doen.
Hoe precisie verloren kan gaan op basis van gegevenstype
Stel dat we een getal met veel decimale waarden willen invoegen als een Double in MongoDB met het volgende:
db.mytestcoll.insertOne({ price: 9999999.4999999999 }){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d24")}
Wanneer we deze gegevens opvragen, krijgen we het volgende resultaat:
db.mytestcoll.find().pretty(){ _id: ObjectId("614b37296a124db40ae74d24"), price: 9999999.5}
Deze waarde rondt af op 9999999.5 , waardoor de exacte waarde waarmee we het hebben ingevoerd, verloren gaat. Dit maakt Double niet geschikt voor het opslaan van getallen met veel decimalen.
Het volgende voorbeeld laat zien waar precisie verloren gaat bij het passeren van een Double impliciet met Decimal128 in plaats van een String zoals in het vorige voorbeeld.
We beginnen met het invoegen van het volgende Double nogmaals maar met NumberDecimal() om er een Decimal128 van te maken typ:
db.mytestcoll.insertOne({ price: NumberDecimal( 9999999.4999999999 ) }){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d14")}
Opmerking :Bij het invoegen in de MongoDB-shell wordt het volgende waarschuwingsbericht weergegeven:
Warning: NumberDecimal: specifying a number as argument is deprecated and may lead to loss of precision, pass a string instead
Dit waarschuwingsbericht geeft aan dat het nummer dat u probeert door te geven mogelijk minder nauwkeurig is. Ze stellen voor om een String . te gebruiken met behulp van NumberDecimal() zodat u geen precisie verliest.
Als we de waarschuwing negeren en het document toch invoegen, wordt het verlies aan precisie zichtbaar in de queryresultaten door het naar boven afronden van de waarde:
db.mytestcoll.find().pretty(){ _id: ObjectId("614b37296a124db40ae74d14"), price: Decimal128("9999999.50000000")}
Als we de aanbevolen NumberDecimal() . volgen benadering met behulp van een String we zullen de volgende resultaten zien met behoud van precisie:
db.mytestcoll.insertOne({ price: NumberDecimal( "9999999.4999999999" ) } )
db.mytestcoll.find().pretty(){ _id: ObjectId("614b37296a124db40ae74d14"), price: Decimal128("9999999.4999999999")}
Voor elk gebruik dat nauwkeurige, exacte waarden vereist, kan deze terugkeer problemen veroorzaken. Elk werk waarbij monetaire transacties betrokken zijn, is een voorbeeld waarbij precisie uiterst belangrijk zal zijn en exacte waarden van cruciaal belang zijn voor nauwkeurige berekeningen. Deze demonstratie benadrukt hoe belangrijk het is om te weten welk numeriek gegevenstype het meest geschikt is voor uw gegevens.
Datum
De BSON Date gegevenstype is een 64-bits geheel getal dat staat voor het aantal milliseconden sinds het Unix-tijdperk (1 januari 1970). Dit gegevenstype slaat de huidige datum of tijd op en kan worden geretourneerd als een datumobject of als een tekenreeks. Date wordt als volgt weergegeven in MongoDB:
Type | Number | Alias | ------------------ | ------ | ------------ | Date | 9 | "date" |
Opmerking :BSON Date soort is gesigneerd. Negatieve waarden vertegenwoordigen datums vóór 1970.
Er zijn drie methoden om datumwaarden te retourneren.
-
Date()- geeft een string terug -
new Date()- geeft een datumobject terug met behulp van deISODate()omslag -
ISODate()- retourneert ook een datumobject met behulp van deISODate()omslag
We demonstreren deze opties hieronder:
var date1 = Date()var date2 = new Date()var date3 = ISODate()db.mytestcoll.insertOne({firstDate: date1, secondDate: date2, thirdDate: date3}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d22")}
En bij terugkomst:
db.mytestcoll.find().pretty(){ "_id" : ObjectId("614b37296a124db40ae74d22"), firstDate: 'Tue Sep 28 2021 11:28:52 GMT+0200 (Central European Summer Time)', secondDate: ISODate("2021-09-28T09:29:01.924Z"), thirdDate: ISODate("2021-09-28T09:29:12.151Z")}
Tijdstempel
Er is ook de Timestamp gegevenstype in MongoDB voor het weergeven van tijd. Echter, Timestamp zal het nuttigst zijn voor intern gebruik en is niet gekoppeld aan de Date type. Het type zelf is een reeks tekens die wordt gebruikt om de datum en tijd te beschrijven waarop een gebeurtenis plaatsvindt. Timestamp is een 64-bits waarde waarbij:
- de meest significante 32 bits zijn
time_twaarde (seconden sinds Unix-tijdperk) - de minst significante 32 bits zijn een oplopend
ordinalvoor bewerkingen binnen een bepaalde seconde
De weergave ervan in MongoDB ziet er als volgt uit:
Type | Number | Alias | ------------------ | ------ | ------------ | Timestamp | 17 | "timestamp" |
Bij het invoegen van een document dat velden op het hoogste niveau met lege tijdstempels bevat, vervangt MongoDB de lege tijdstempelwaarde door de huidige tijdstempelwaarde. De uitzondering hierop is als de _id veld een leeg tijdstempel bevat. De tijdstempelwaarde wordt altijd ingevoegd zoals deze is en niet vervangen.
Een nieuwe Timestamp invoegen waarde in MongoDB gebruikt de new Timestamp() functioneren en zien er ongeveer zo uit:
db.mytestcoll.insertOne( {ts: new Timestamp() });{ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d23")}
Wanneer u de verzameling opvraagt, retourneert u een resultaat dat lijkt op:
db.mytestcoll.find().pretty(){ "_id" : ObjectId("614b37296a124db40ae74d24"), "ts" : Timestamp( { t: 1412180887, i: 1 })}
Object
Het Object gegevenstype in MongoDB wordt gebruikt voor het opslaan van ingesloten documenten. Een ingesloten document is een reeks geneste documenten in key: value paar formaat. We demonstreren het Object typ hieronder:
var classGrades = {"Physics": 88, "German": 92, "LitTheoery": 79}db.mytestcoll.insertOne({student_name: "John Smith", report_card: classGrades}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d18")}
We kunnen dan ons nieuwe document bekijken:
db.mytestcoll.find().pretty(){ _id: ObjectId("614b37296a124db40ae74d18"), student_name: 'John Smith', report_card: {Physics: 88, German: 92, LitTheoery: 79}}
Het Object gegevenstype optimaliseert voor het opslaan van gegevens die het beste samen kunnen worden geopend. Het biedt een aantal efficiëntieverbeteringen op het gebied van opslag, snelheid en duurzaamheid in tegenstelling tot het afzonderlijk opslaan van elk klassemerk uit het bovenstaande voorbeeld.
Binaire gegevens
De Binary Data , of BinData , gegevenstype doet precies wat de naam aangeeft en slaat binaire gegevens op voor de waarde van een veld. BinData wordt het best gebruikt wanneer u gegevens opslaat en doorzoekt, vanwege de efficiëntie bij het weergeven van bitarrays. Dit gegevenstype kan op de volgende manieren worden weergegeven:
Type | Number | Alias | ------------------ | ------ | ------------ | Binary data | 5 | "binData" |
Hier is een voorbeeld van het toevoegen van enkele Binary Data in een document in een verzameling:
var data = BinData(1, "111010110111100110100010101")db.mytestcoll.insertOne({binaryData: data}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d20")}
Om vervolgens het resulterende document te zien:
db.mytestcoll.find().pretty(){ "_id" : ObjectId("614b37296a124db40ae74d20"), "binaryData" : BinData(1, "111010110111100110100010101")}
ObjectId
De ObjectId type is specifiek voor MongoDB en slaat de unieke ID van het document op. MongoDB biedt een _id veld voor elk document. ObjectId is 12 bytes groot en kan als volgt worden weergegeven:
Type | Number | Alias | ------------------ | ------ | ------------ | ObjectId | 7 | "objectId" |
ObjectId bestaat uit drie delen die samen de 12-byte make-up vormen:
- een tijdstempelwaarde van 4 bytes , die de creatie van de ObjectId vertegenwoordigt, gemeten in seconden sinds het Unix-tijdperk
- een willekeurige waarde van 5 bytes
- een oplopende teller van 3 bytes geïnitialiseerd op een willekeurige waarde
In MongoDB vereist elk document binnen een verzameling een unieke _id om als primaire sleutel te fungeren. Als de _id veld leeg wordt gelaten voor een ingevoegd document, zal MongoDB automatisch een ObjectId voor het veld genereren.
Er zijn verschillende voordelen aan het gebruik van ObjectIds voor de _id :
- in
mongosh(MongoDB-shell), de aanmaaktijd van deObjectIdis toegankelijk via deObjectId.getTimestamp()methode. - sorteren op een
_idveld waarinObjectId. wordt opgeslagen datatypes komt bijna overeen met sorteren op aanmaaktijd.
We hebben ObjectIds tot nu toe in de voorbeelden gezien en ze zullen er ongeveer zo uitzien:
db.mytestcoll.find().pretty(){ _id: ObjectId("614b37296a124db40ae74d19")}
Opmerking :ObjectId-waarden zouden in de loop van de tijd moeten toenemen, maar ze zijn niet noodzakelijk monotoon. Dit komt omdat ze:
- Bevatten slechts één seconde temporele resolutie, dus waarden die binnen dezelfde seconde zijn gemaakt, hebben geen gegarandeerde volgorde
- waarden worden gegenereerd door clients, die mogelijk verschillende systeemklokken hebben
Boolean
MongoDB heeft de native Boolean gegevenstype voor het opslaan van ware en valse waarden binnen een verzameling. Boolean in MongoDB kan als volgt worden weergegeven:
Type | Number | Alias | ------------------ | ------ | ------------ | Boolean | 8 | "bool" |
Een document invoegen met een Boolean gegevenstype ziet er ongeveer als volgt uit:
db.mytestcoll.insertOne({isCorrect: true, isIncorrect: false}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d21")}
Bij het zoeken naar het document zal het resultaat verschijnen als:
db.mytestcoll.find().pretty(){ "_id" : ObjectId("614b37296a124db40ae74d21") "isCorrect" : true, "isIncorrect" : false}
Reguliere expressie
De Regular Expression gegevenstype in MongoDB zorgt voor de opslag van reguliere expressies als de waarde van een veld. MongoDB gebruikt PCRE (Perl Compatible Regular Expression) als zijn reguliere expressietaal.
Het kan op de volgende manier worden weergegeven:
Type | Number | Alias | ------------------ | ------ | ------- | Regular Expression | 11 | "regex" |
Met BSON kunt u de typische stap "converteren van string" vermijden die vaak wordt ervaren bij het werken met reguliere expressies en databases. Dit type zal het nuttigst zijn wanneer u databaseobjecten schrijft waarvoor validatiepatronen of overeenkomende triggers nodig zijn.
U kunt bijvoorbeeld de Regular Expression . invoegen gegevenstype als volgt:
db.mytestcoll.insertOne({exampleregex: /tt/}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d16")}db.mytestcoll.insertOne({exampleregext:/t+/}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d17")}
Deze reeks verklaringen voegt deze documenten toe aan uw collectie. U kunt dan uw collectie opvragen om de ingevoegde documenten te vinden:
db.mytestcoll.find().pretty(){ _id: ObjectId("614b37296a124db40ae74d16"), exampleregex: /tt/, _id: ObjectId("614b37296a124db40ae74d17"), exampleregex: /t+/ }
De patronen voor reguliere expressies worden opgeslagen als regex en niet als strings. Dit stelt je in staat om naar een bepaalde string te zoeken en documenten terug te krijgen die een reguliere expressie hebben die overeenkomt met de gewenste string.
JavaScript (zonder scope)
Net zoals de eerder genoemde Regular Expression gegevenstype, stelt BSON MongoDB in staat om JavaScript-functies zonder bereik op te slaan als hun eigen type. De JavaScript type kan als volgt worden herkend:
Type | Number | Alias | ------------------ | ------ | ------------ | JavaScript | 13 | "javascript" |
Een document aan uw verzameling toevoegen met de JavaScript gegevenstype ziet er ongeveer zo uit:
db.mytestcoll.insertOne({jsCode: "function(){var x; x=1}"}){ "acknowledged": true, "insertedId": ObjectId("614b37296a124db40ae74d122")}
Met deze functionaliteit kunt u JavaScript-functies opslaan in uw MongoDB-verzamelingen, indien nodig voor een bepaalde gebruikssituatie.
Opmerking :Met MongoDB versie 4.4 en hoger, een alternatief JavaScript-type, de JavaScript with Scope gegevenstype, is verouderd
Conclusie
In dit artikel hebben we de meeste veelvoorkomende gegevenstypen behandeld die handig zijn bij het werken met MongoDB-databases. Er zijn aanvullende typen die niet expliciet in deze handleiding worden behandeld en die, afhankelijk van de gebruikssituatie, nuttig kunnen zijn. Aan de slag door deze typen te kennen, omvat de meeste gebruiksscenario's. Het is een sterke basis om te beginnen met het modelleren van uw MongoDB-database.
Het is belangrijk om te weten welke gegevenstypen voor u beschikbaar zijn wanneer u een database gebruikt, zodat u geldige waarden gebruikt en de gegevens met verwachte resultaten gebruikt. Er zijn risico's waar u tegenaan kunt lopen zonder uw gegevens correct te typen, zoals aangetoond in de Double versus Decimal128 oefening. Het is belangrijk om hierover na te denken voordat u zich tot een bepaald type verbindt.
Als u Prisma met een MongoDB-database wilt uitproberen, kunt u de documentatie over de dataconnector raadplegen.