Skip to content

Grootste gemene deler

Jump to bottom
LB edited this page Dec 13, 2022 · 1 revision

Grootste gemene deler

Gezien we dezelfde databronnen zo divers mogelijk wensen te ontsluiten is het van groot belang om de meest gepaste grootste gemene deler van onze data te bepalen.

Ten behoeve daarvan hebben we de volgende doelrepresentaties geevalueerd op de volgende criteria:

  • Modelleringsbasis (eg. document zoals Elasticsearch, regel zoals Postgres of relatie zoals Neo4j)
  • Unique Identifier
  • Geometrische velden
    • Point
    • Line String
    • Multi Point
    • Multi LineString
    • Multi Polygon
    • Geometry Collection
    • Bounding Box
    • Circle
    • PolyhedralSurface
    • TIN (TriangulatedSurface)
  • Scalaire typen
    • Numeriek
      • Integer
      • Floating Point
      • Decimaal
    • Text
    • Classificatie
    • Datum en Tijd
    • Binair
  • Logische types
    • Array
    • Map
    • Set
    • Struct
  • Range types
  • Nesting
    • Logisch
    • Arbitrair
  • Union types (incl. null)

Conclusie

  • We werken exclusief op regel/row-basis
  • Elke regel is adresseerbaar via een unique identifier in één kolom.
  • We ondersteunen de scalar types:
    • integer (tiny, small, int, bigint; max waarde ±2^53-1 ivm JSON)
    • decimal (schaal en optioneel precisie, maximaal 15 decimalen, vast op kolombasis)
    • floating point (half, float, double)
    • boolean
    • enum (maximaal 1024 waarden)
    • text (char, varchar, string)
    • binary (variable of fixed length)
    • Tijd
      • date (day within calendar)
      • time (time within day, microseconde precisie)
      • timestamp (moment in time, microseconde precisie, UTC)
      • interval (maanden, dagen en milliseconden)
  • Geometrie
    Een regel heeft maximaal één actief geometrie veld
    • Point
    • Polygoon
    • Line String
    • Multi Point
    • Multi LineString
    • Multi Polygon
  • Een kolom kan van de logische types zijn:
    • array (lijst van waardes met mogelijke duplicatie)
    • struct (klasse met gedefinieerde velden en types)
  • Een logisch type kan zelf ook weer een ander logisch type bevatten (e.g. array van maps)
  • Een kolom heeft geen UNION-semantiek dus kan niet meerdere types waardes te bevatten; behalve null.
  • Arbitrair-geneste data kan alleen, ongeïndexeerd, worden opgeslagen als JSON string.

Wat dit dus niet bevat is (en welke doelrepresentatie het niet ondersteunt):

  • Data op graaf/relatie niveau (Postgres, Avro, DataFrame, ...)
  • Meerdere (actieve) geometrie velden per object (GeoJSON)
  • Bounding Box en Circle (PostGIS, GeoJSON, GeoPandas, Athena)
  • GeometryCollection (AWS Athena, GeoPandas)
  • PolyhedralSurface en TIN (GeoJSON, ElasticSearch)
  • Decimalen met varierende precisie per regel of meer dan 15 decimalen precisie. (JSON)
  • Integers boven ±2^53 (JSON)
  • Enums met meer dan 1024 waardes (Postgres)
  • Tijd of moment op meer dan microseconde precisie (Postgres)
  • Interval op meer dan milliseconde precisie (Avro)
  • Sets
    Dit kan altijd toegevoegd worden als validatie op een Array
  • Maps
    Dit kan gemodelleerd worden als ongeindexeerde JSON.
    Eventueel later nog toe te voegen d.m.v. een koppeltabel in Postgres met beperking dat keys altijd strings zijn.
  • Union types (Postgres, Spark/Pandas Dataframe)
  • Range types (JSON Schema, Avro, Athena, Spark)
  • Arbitraire nesting met behoud van type informatie en indexering (Postgres, Avro, AWS Glue/Athena, Spark)

Wat nog ter discussie staat:

  • Integers boven ±2^53
    Dit lijkt binnen de gekozen aanpak niet haalbaar maar zou je eigenlijk wel verwachten als mogelijkheid.

Modellering

  • Elke regel is adresseerbaar via een unique identifier in één kolom.
    • Gemodelleerd als $ref naar /definitions/id.
      "$ref": "https://ams-schema.glitch.me/[email protected]#/definitions/id"
  • Scalaire types
    • integer (tiny8, small16, int32, bigint64)
      • Gemodelleerd als integer met exclusiveMaximum en negatief minimum van 2^(bits-1).
        {"type":"integer", "exclusiveMaximum": 128, "minimum": 128}
      • Signed integers kunnen een minimum van 0 opgeven en exclusiveMaximum van 2^bits
        {"type":"integer", "exclusiveMaximum": 256, "minimum": 0}
      • Bij ontbreken van een maximum/minimum wordt een bigint64 gebruikt.
      • Maximum-/minimumwaardes van meer dan ±2^53-1 (15 decimalen) leveren een waarschuwing op m.b.t. mogelijk inaccurate encodering in JSON.
      • Unsigned bigint64 wordt niet ondersteund.
    • decimal
      • Gemodelleerd als number met een multipleOf van 0.1^schaal.
        {"type":"number", "multipleOf": 0.01}
      • Optionele precisie wordt meegeven via de maximum van 10^(precisie-schaal)-1
        e.g. een precisie van 7 bij een schaal van 2 geeft een maximum van 99999)
        {"type":"number", "multipleOf": 0.01, "maximum": 99999}
      • Maximum-/minimumwaardes van meer dan 15 decimalen (±2^53-1) leveren een waarschuwing op m.b.t. mogelijk inaccurate encodering in JSON.
    • floating point (half, float, double)
      • Gemodelleerd als number zonder opgave van multipleOf. Opslag gebeurt altijd in double formaat. Half en float kan als annotatie op de provenance meegenomen worden.
      • dataset: {"provenance": {..., "type": "elasticsearch"}
        column: {"provenance": {..., "type":"half_float"}
    • boolean
      • Gemodelleerd als boolean type.
    • enum (maximaal 1024 waarden)
      • Gemodelleerd als een string type met enum voor de toegestane waardes.
      • {"type": "string", "enum": ["rood", "geel", "groen"]}
    • text (char, varchar, string)
      • Gemodelleerd als string
        {"type":"string"}
      • Varchar heeft een maxLength attribuut
        {"type":"string", "maxLength": 10}
      • Char heeft ook een minLength attribuut met de gelijke waarde
        {"type":"string", "maxLength": 10, "minLength": 10}
    • binary (variable of fixed length)
      • Gemodelleerd als string met contentEncoding van type base64
        {"type":"string", "contentEncoding": "base64"}
      • Fixed length binary kan deels enforced worden via een maxLength van via de formule 4*ceil(bytes/3) en kan meegenomen in de provenance.
    • Tijd
      • date (day within calendar)
        • Gemodelleerd als string met date format
          {"type":"string", "format": "date"} ⇒ "2020-02-20"
      • time (time within day, microseconde precisie)
        • Gemodelleerd als string met time format. Precisie boven de microseconde wordt afgekapt.
          {"type":"string", "format": "time"} ⇒ "12:00:00" of "12:00:00.000000"
      • timestamp (moment in time, microseconde precisie, UTC)
        • Te modelleren als string met date-time format.
          Precisie boven de microseconde wordt afgekapt.
          Bij voorkeur wordt gewerkt met een opgegeven tijdszone. Wanneer er geen tijdszone wordt opgegeven levert dit een data-kwaliteit waarschuwing op.
          {"type":"string", "format": "date-time"} ⇒ "2020-02-20T12:00:00+01:00", "2020-02-20T12:00:00.000000+01:00" of "2020-02-20T12:00:00"
        • Te modelleren als string met date-time format.
          Precisie boven de microseconde wordt afgekapt.
          De tijdszone kan weggelaten wanneer deze in de metadata van het veld opgenomen is.
          {"type":"string", "format": "date"}
      • interval (maanden, dagen en milliseconden)
  • Geometrie (Point, Polygoon, Line String, Multi Point, Multi LineString, Multi Polygon)
    • Gemodelleerd als GeoJson Schema's Geometry type
      "$ref": "https://geojson.org/schema/Geometry.json" of in context:
      "geometry": { "$ref": "https://geojson.org/schema/Geometry.json", "description": "Geografische locatie" }
  • Een kolom kan van de logische types zijn:
    • array (lijst van waardes met mogelijke duplicatie)
      • Gemodelleerd als List validation met gespecificeerd item type.
        {"type": "array", "items": {"type": "number"}}
      • Tuple validatie wordt niet ondersteunt aangezien dit in veel doelrepresentaties een union semantiek vereist. Elk tuple element kan wel een eigen veld gegeven worden.
    • struct (klasse met gedefinieerde velden en types)
      • Gemodelleerd als object met typed properties en geen additionele properties
        {"type": "object", "properties": {"count": { "type": "number" }}, "additionalProperties": false}
  • Een logisch type kan zelf ook weer een ander logisch type bevatten (e.g. array van structs)
    {"type": "array", "items": {"type": "object", "properties": {"name": { "type": "string" }}, "additionalProperties": false}}
  • Een kolom heeft geen UNION semantiek dus kan niet meerdere types waardes te bevatten; behalve null.
    • Elk veld is nullable tenzij het als required property is opgegeven.
      {"type": "object", "properties": {"name": { "type": "string" }}, "required": ["name"], "additionalProperties": false}
    • De anyOf operater is dus niet toegestaan
      {"anyOf": [{ "type": "integer" }, { "type": "string"}]}
  • Arbitrair-geneste data kan alleen, ongeindexeerd, worden opgeslagen als JSON string.
    • Gemodelleerd als object type zonder type definitie
      {"type": "object"}
    • Dit is een fallback type en het gebruik hiervan dient waar mogelijk voorkomen te worden.
    • Gebruik voor bijvoorbeeld een config/properties veld (string keys naar string values) is een voorbeeld van acceptabel gebruik.

Doelrepresentaties

Deze aspecten hebben we geevalueerd aan de hand van de volgende doelrepresentaties:

RDF

Gezien de aard van RDF grafen zijn alle representaties per definitie te representeren. Hier zal de complexiteit vooral liggen in het technisch afdwingen van de subset van representaties (document als modelleringsbasis en beperkte logische types.)

Postgres/GIS

  • Modelleringsbasis
    Postgres werkt exclusief op basis van row/regel als kernelement voor data modellering.
    Werken met documenten (schemaloos en arbitrair genest) is mogelijk via hulpmiddelen maar niet idiomatisch.
    Data opslaan op het niveau van (graaf-)relaties is effectief niet mogelijk wegens performance problematiek.
  • Unique Identifier
    Samengestelde unique identifiers van arbitraire waardes (integer, string, etc.)
    Het UUID data type wordt ook ondersteund.
  • Geometrische velden
    PostGIS ondersteunt meerdere geometrie velden per regel. Een PostGIS geometrie veld kan alle relevante geometrieen ondersteunen.
    • Point ✔
    • Line String ✔
    • Polygon ✔
    • Multi Point ✔
    • Multi LineString ✔
    • Multi Polygon ✔
    • Geometry Collection ✔
    • Bounding Box ✔
    • Circle Circle is niet ondersteund
    • PolyhedralSurface ✔
    • TIN (TriangulatedSurface) ✔
  • Scalaire typen
    • Numeriek
      • Integer
        Signed integers van de types smallint, integer en bigint (maximum waarde van ±2^63)
      • Floating Point
        Real of double (max 8 bytes en 15 decimalen precisie)
      • Decimaal
        Per kolom wordt zowel de maximum cijfers voor als het minimum aantal cijfers achter de komma gedefinieerd.
        Het is ook mogelijk het money type te gebruiken om alleen fractionele precisie achter de komma te definieren per kolom.
        Varierende precisie per regel/row is echter niet mogelijk.
    • Text
      Variable character length with maximum (varchar), fixed character length (char), variable length (text)
    • Classificatie
      • Boolean
        Ondersteund
      • Enum
        Alleen tekst gebaseerd; met een maximum lengte van 63 bytes by default.
        Per database server kan je maximaal 2^32 (4,294,967,296) enums opslaan dus we stellen voor het aantal enum waardes per veld te beperken tot 1024
  • Datum en Tijd
    • Datum
      Dag van 4713 BC tot 5874897 AD
    • Tijd
      Tijd van de dag, **tot microseconde **precisie. Ondersteunt ook tijdzones.
    • Moment
      Timestamp kan zonder time zone en is dan gewoon datum + tijd.
      Samen met timezone is het een exact moment in de tijd.
    • Interval
      Een interval met een optionele waardes per unit en een direction. Compatibel met ISO 8601 time intervals.
      De units zijn microsecond, millisecond, second, minute, hour, day, week, month, year, decade, century, millennium
  • Binair
    Postgres ondersteunt alleen variable length binary blobs (bytea.) Fixed length binary data kan daar natuurlijk wel gewoon in gerepresenteerd worden.
  • Logische types
    • Array
      Postgres ondersteunt meerdimensionele arrays met data van een gespecificeerd type.
      Dit kan natuurlijk ook in tabelvorm genormaliseerd worden opgeslagen.
    • Map
      Door middel van de HSTORE extensie is het mogelijk key value pairs van string naar string te implementeren. Het JSONB type kan dit ook representeren.
      Typed map data is niet direct ondersteund maar kan wel weergegeven worden d.m.v. een koppeltabel indien nodig.
    • Set
      Een set data type ondersteunt Postgres niet.
      Ook dit is natuurlijk wel te normaliseren door middel van een extra tabel.
    • Struct
      Postgres kan complexe types ondersteunen.
  • Range types
    Postgres ondersteunt range types op veel verschillende typen en custom ranges kunnen gedefinieerd worden.
  • Nesting
    • Logisch
      Logische nesting is realiseerbaar door middel van complex types.
    • Arbitrair
      Arbitraire nesting is alleen realiseerbaar door een JSONB type te gebruiken en dat te indexeren.
  • Union types
    Postgres ondersteunt geen union types,m.u.v. de UNION met NULL voor elk mogelijk type.

(ND/Geo)JSON + Schema

  • Modelleringsbasis
    Geschikt voor document of row based modellering
  • Unique Identifier
    Unique identifiers zijn niet intrinsiek aanwezig maar velden kunnen wel als dusdanig gebruikt worden.
    Het UUID data type wordt niet expliciet ondersteund maar kan wel gerepresenteerd worden.
  • Geometrische velden
    GeoJSON ondersteunt slechts één actieve geometrische feature per object.
    • Point ✔
    • Line String ✔
    • Polygon ✔
    • Multi Point ✔
    • Multi LineString ✔
    • Multi Polygon ✔
    • Geometry Collection ✔
    • Bounding Box Bounding Box is niet ondersteund
    • Circle: Circle is niet ondersteund
    • PolyhedralSurface PolyhedralSurface is niet ondersteund
    • TIN (TriangulatedSurface) TIN is niet ondersteund
  • Scalaire typen
    • Numeriek
      • Integer
        Integers worden niet inherent ondersteund in JSON. Met behulp van metadata kan het wel opgeslagen worden als number type.
        Dit heeft wel slechts een maximum waarde van maar ±2^53 (9.007.199.254.740.991)
      • Floating Point
        Wordt standaard opgeslagen als een 'double' van 8 bytes met 15 decimalen precisie.
      • Decimaal
        Wordt niet ondersteund. Met behulp van metadata kan het wel opgeslapen worden als number type door middel van afronding naar de precisie van de bron (i.e. 3.798999 naar 3.799 gezien precisie van 3 decimalen. Dit geeft wel een ook een maximale precisie van 15 decimalen.
    • Text
      Wordt ondersteund in een string formaat met variable length text. Lengte restricties worden niet ondersteund maar kunnen wel gerepresenteerd worden.
    • Classificatie
      • Boolean
        Ondersteund in de vorm van true false.
      • Enum
        Niet ondersteund in het data formaat. Kan wel weergegeven worden in het bijhorende JSON Schema.
    • Datum en Tijd
      Geen van de datum en tijd types wordt direct ondersteund door JSON. Met behulp van het schema kunnen ze wel gerepresenteerd worden.
    • Binair
      • JSON ondersteunt geen binaire data. Dit kan wel weer worden gegeven in de vorm van Base64 encoded strings.
  • Logische types
    • Array
      JSON ondersteunt dit volledig op elk niveau; echter niet typed.
    • Map
      Volledig ondersteund; echter niet typed.
    • Set
      Niet ondersteund.
    • Struct
      JSON kan geneste complexe structuren aan; echter niet typed.
  • Range types
    Kan in string formaat geencodeerd worden maar ook in JSON schema worden ranges niet ondersteund.
  • Nesting
    • Logisch
      Logische nesting is onbeperkt mogelijk
    • Arbitrair
      Arbitraire nesting is onbeperkt mogelijk
  • Union types
    Union types zijn onbeperkt mogelijk (volledig dynamisch getyped; ook JSON Schema ondersteunt het)

MapServer

MapServer ondersteunt de weergave van alle relevante geometrische gegevens in de vorm van MapLayers.

MapServer biedt ook de mogelijkheid om metadata behorende bij een punt te ontsluiten. Dit gebeurt echter door middel van templating waarbij de onderliggende Postgres kolommen in het template ontsloten kunnen worden.

Dit betekent dat het zonder toevoegingen een zeer beperkend formaat zou zijn. Dit hoeft verder niet problematisch te zijn aangezien de GetFeatureInfo resultaten ook als optioneel gezien zouden kunnen worden en/of per dataset/maplaag in custom templates meegeleverd kan worden. Dit dient echter wel besproken te worden met eventuele klanten.

De onderstaande analyse gaat uit van een poging tot automatische ontsluiting van alle gegevens. Beperkingen zijn niet als rood gemarkeerd aangezien deze te vergaand zijn om ook onze grootste gemene deler te laten sturen.

  • Modelleringsbasis: Volgt Postgres modellering
  • Unique Identifier: Kan deze weergeven.
  • Geometrische velden: Ondersteunt alle beschikbare PostGIS geometrieen.
  • Scalaire typen
    • Numeriek: Kunnen weergegeven worden in text formaat.
    • Text: Kan weergegeven worden.
    • Classificatie: Kunnen weergegeven worden in text formaat.
  • Datum en Tijd: Onduidelijk of de formattering controleerbaar is en voldoet aan de vereisten.
  • Binair: Onduidelijk of binaire data als Base64 gerenderd kan worden.
  • Logische types
    • Array: Onduidelijk of dit ondersteund wordt.
    • Map: Hoogstwaarschijnlijk niet ondersteund.
    • Set: Niet ondersteund.
    • Struct: Waarschijnlijk wel ondersteund. Nesting zal programmatisch in het template uitgeschreven moeten worden.
  • Nesting
    • Logisch: Logische nesting kan programmatisch uitgeschreven worden in de templates.
      Complex maar haalbaar.
    • Arbitrair: Dit valt niet programmatisch te realiseren in GetFeatureInfo templates
  • Union types: Mogelijk via templating

Wellicht zou het wel mogelijk zijn om een JSON representatie van het hele object toe te voegen op Postgres niveau welke één op één in het template kan worden ontsloten.

ElasticSearch

  • Modelleringsbasis
    De modelleringsbasis van ElasticSearch is document. Het is natuurlijk echter altijd mogelijk om rows weer te geven als een document.
  • Unique Identifier
    Ondersteunt identifiers door representatie in native datatypes. Uniqueness constraints kunnen niet ge-enforced worden.
  • Geometrische velden
    • Point ✔
    • Line String ✔
    • Polygon ✔
    • Multi Point (Nog) niet goed ondersteund voor querying.
    • Multi LineString ✔
    • Multi Polygon ✔
    • Geometry Collection ✔
    • Bounding Box ✔
    • Circle ✔
    • PolyhedralSurface ✘
    • TIN (TriangulatedSurface) ✘
  • Scalaire typen
    • Numeriek
      • Integer ✔ long, integer, short and byte
      • Floating Point
        float, double, half_float
      • Decimaal
        Kan als scaled_float gerepresenteerd worden (long met fixed precisie/scaling)
    • Text
      Ruim ondersteund inclusief meervoudig indexering
    • Classificatie
      • Boolean ✔
      • Enum ✔
        Beperkingen op waardes niet ondersteund. Efficiente indexering wel mogelijk door 'keyword' type.
  • Datum en Tijd
    • Datum
      Date zijn 'sort of' ondersteund als time since epoch in UTC.
    • Tijd
      Niet ondersteund maar wel representabel.
    • Moment
      Ondersteund; echter <span style="color: #f39c12;>opgesplitst in date met milliseconde- en date_nanos met nanoseconde-precisie.
    • Interval
      Niet ondersteund maar wel representabel.
  • Binair
    Ondersteund echter niet doorzoekbaar.
  • Logische types
    • Array ✔
    • Map ✔
    • Set
      Niet ondersteund.
    • Struct
      Typed data wordt niet ondersteund maar kan wel weergegeven worden.
  • Range types ✔
    ElasticSearch ondersteund range types voor integer, float, long, double, date en ip.
  • Nesting
    • Logisch ✔
    • Arbitrair ✔
  • Union types ✔

CSV

In CSV kan elke mogelijke waarde natuurlijk gemapt worden op een string representatie.

Structs zouden ook in CSV weergegeven kunnen worden door de nesting hierarchie plat te slaan in CSV kolommen.

Arrays en maps kunnen kunnen niet op een kolomstructuur gemapt worden dus zullen deze altijd als text representatie opgenomen worden.

Derhalve oefent CSV geen invloed uit op de grootste gemene deler.

Avro

  • Modelleringsbasis
    AWS Avro is een row/record formaat.
  • Unique Identifier
    Wordt als concept niet ondersteund. Wel een UUID type.
  • Geometrische velden
    Niet inherent ondersteund. WKT/WKB representatie is altijd mogelijk. Het is mogelijk om dit ook native in Avro te encoden d.m.v. custom logische types; echter is het voordeel daarvan boven WKB/WKT nog niet duidelijk.
  • Scalaire typen
    • Numeriek
      • Integer ✔ (int, long)
      • Floating Point ✔ (float, double)
      • Decimaal ✔ (logisch type; precisie en schaal per veld)
    • Text ✔ (string)
    • Classificatie
      • Boolean ✔
      • Enum ✔
  • Datum en Tijd
    • Datum ✔
    • Tijd ✔ (vooraf gespecificeerd op milleseconde en maximaal microseconde precisie)
    • Moment ✔ (vooraf gespecificeerd op milleseconde en maximaal microseconde precisie)
    • Interval ✔ Duration. Beschikbaar in units months, days en milliseconds. Dit zijn de universeel toepasbare units.
  • Binair ✔ (zowel fixed als variable length)
  • Logische types
    • Array ✔ (incl. typing van waardes)
    • Map ✔ (incl. typing van waardes; alle keys zijn strings)
    • Set ✘
    • Struct ✔ (incl. typing van waardes)
  • Range types ✘
    Niet ondersteund. Kan wel gepresenteerd worden natuurlijk.
  • Nesting
    • Logisch ✔ logische types kunnen genest worden
    • Arbitrair ✘ arbitraire nesting niet mogelijk; alleen via indexeren van string veld met JSON
  • Union types ✔
    Volledig ondersteund op elk niveau.

Pandas Dataframe

  • Modelleringsbasis
    Pandas Dataframes zijn een row/record formaat.
  • Unique Identifier
    Wordt ondersteund via indexering van Pandas.
  • Geometrische velden
    Ondersteund via de GeoPandas extensie
    • Point ✔
    • Line String ✔
    • Polygon ✔
    • Multi Point ✔
    • Multi LineString ✔
    • Multi Polygon ✔
    • Geometry Collection Niet ondersteund.
    • Bounding Box ✘
    • Circle ✘
    • PolyhedralSurface ✘
    • TIN (TriangulatedSurface) ✘
  • Scalaire typen
    • Numeriek
      • Integer ✔ (int64)
      • Floating Point ✔ (float64)
      • Decimaal ≈ can be stored as Python object
    • Text ≈ can be stored as Python object
    • Classificatie
      • Boolean ✔
      • Enum ✔ (CategoricalDtype)
  • Datum en Tijd
    • Datum ≈ can be stored as Python object
    • Tijd ≈ can be stored as Python object
    • Moment ✔ (reqular and tz-aware)
    • Interval ??
      It seems this only supports an interval in terms of seconds and thus not month or year based intervals.
  • Binair ≈ can be stored as Python object
  • Logische types
    • Array ✔
    • Map ≈ can be stored as Python object
    • Set ≈ can be stored as Python object
    • Struct ✔
  • Range types ✔ (IntervalIndex)
  • Nesting
    • Logisch ✔
    • Arbitrair ≈ can be stored as Python objects
  • Union types ✘

(Geo)Spark Dataframe

  • Modelleringsbasis
    Dataframes zijn een row/record formaat.
  • Unique Identifier
    Wordt niet specifiek ondersteund.
  • Geometrische velden
    Ondersteund via de GeoSpark extensie
    • Point ✔
    • Line String ✔
    • Polygon ✔
    • Multi Point ✔ (Niet in code gevonden maar wel vermeld op de GeoSpark site)
    • Multi LineString ✔ (Niet in code gevonden maar wel vermeld op de GeoSpark site)
    • Multi Polygon ✔ (Niet in code gevonden maar wel vermeld op de GeoSpark site)
    • Geometry Collection ✔ (Niet in code gevonden maar wel vermeld op de GeoSpark site)
    • Bounding Box ✔
    • Circle ✔
    • PolyhedralSurface ✘
    • TIN (TriangulatedSurface) ✘
  • Scalaire typen
    • Numeriek
      • Integer ✔ (byte, short, integer, long)
      • Floating Point ✔ (float, double)
      • Decimaal ✔ (varying precision per row)
    • Text ✔ (no fixed lengths)
    • Classificatie
      • Boolean ✔
      • Enum
        Not greatly supported. Seems like it would need some custom Enumeration User Defined Type to be added.
        For performance reasons using strings is also not recommended which makes just mapping it to string less than ideal.
  • Datum en Tijd
    • Datum ✔
    • Tijd ✘
    • Moment ✔
    • Interval ≈ Supported but only months and microseconds. Not days which is incorrect when crossing daylight savings time adjustments.
  • Binair ✔ (no fixed lengths)
  • Logische types
    • Array ✔ (typed)
    • Map ✔ (typed)
    • Set ✘
    • Struct ✔ (typed)
  • Range types ✘
  • Nesting
    • Logisch ✔
    • Arbitrair ✘ only as raw manually processed JSON blob
  • Union types ✘

AWS Glue / Athena

AWS Glue is het meta schema formaat dat ondersteund wordt door AWS Athena; een flexibele BI omgeving die gemaakt is om efficient te werken op heterogene data; zoals ook binnen DataPunt het geval is.

We hebben niet direct de wens om te integreren met AWS Athena maar het is een goed model om tegen te vergelijken als sanity check.

Zo heeft Athena bijvoorbeeld beperkingen m.b.t. het gebruik van Geometry Collections en kiezen we er toch voor om deze in Amsterdam Schema toe te laten.

  • Modelleringsbasis
    AWS Glue werkt ook op row-basis
  • Unique Identifier
    Wordt als concept niet ondersteund. Ook geen UUID veld. Wel allemaal representabel.
  • Geometrische velden
    Kan opgeslagen worden als JSON of WKT representatie in een veld.
    • Point ✔
    • Line String ✔
    • Polygon ✔
    • Multi Point
      Multi point wordt niet ondersteund
    • Multi LineString ✔
    • Multi Polygon ✔
    • Geometry Collection
      Geometrie collecties worden niet ondersteund.
    • Bounding Box ✘
    • Circle ✘
    • PolyhedralSurface ✘
    • TIN (TriangulatedSurface) ✘
  • Scalaire typen
    • Numeriek
      • Integer ✔ (tinyint, smallint, int, bigint)
      • Floating Point ✔ (float, double)
      • Decimaal ✔ (precisie en schaal per kolom)
    • Text ✔ (char, varchar(65535), string )
    • Classificatie
      • Boolean ✔
      • Enum
  • Datum en Tijd
    • Datum ✔
    • Tijd ✘ (wel representabel, niet ondersteund)
    • Moment ✔
    • Interval
      Niet omschreven welke units mogelijk zijn. Voorbeelden melden week, day, hour, minute en second. Werkt niet in alle systemen.
  • Binair ✔
  • Logische types
    • Array ✔ (incl. typing van waardes)
    • Map ✔ (incl. typing van sleutels en waardes)
    • Set ✔ (incl. typing van waardes)
    • Struct ✔ (incl. typing van waardes)
  • Range types ✘
    Niet ondersteund. Kan wel gepresenteerd worden natuurlijk.
  • Nesting
    • Logisch ✔ alle logische types kunnen genest worden
    • Arbitrair ✘ arbitraire nesting niet mogelijk; alleen via indexeren van string veld met JSON
  • Union types ✔
    Volledig ondersteund op elk niveau.
Clone this wiki locally