Typer i M-formelsproget i Power Query

M-formelsproget i Power Query er et nyttigt og udtryksfuldt datamakssprog. Men det har nogle begrænsninger. Der er f.eks. ingen stærk håndhævelse af typesystemet. I nogle tilfælde er det nødvendigt med en strengere validering. Heldigvis leverer M et indbygget bibliotek med understøttelse af typer for at gøre stærkere validering mulig.

Udviklere skal have en grundig forståelse af typen system i-for at gøre dette med enhver generelhed. Og selvom M-sprogspecifikationen til Power Query forklarer typesystemet godt, efterlader det nogle få overraskelser. Validering af funktionsforekomster kræver f.eks. en metode til at sammenligne typer for kompatibilitet.

Ved at udforske M-systemet mere omhyggeligt kan mange af disse problemer afklares, og udviklere får mulighed for at udforme de løsninger, de har brug for.

Viden om prædikatkalkulus og naiv sætteori bør være tilstrækkelig til at forstå den anvendte notation.

SAGSBEHANDLING

(1) B := { true; false }
B er det typiske sæt booleske værdier

(2) N := { gyldige M-id'er }
N er sættet af alle gyldige navne i M. Dette er defineret et andet sted.

(3) P := ⟨B, T⟩
P er sættet af funktionsparametre. Hver enkelt er muligvis valgfri og har en type. Parameternavne er irrelevante.

(4) Pⁿ := ⋃_0≤i≤n ⟨i, P^i⟩
Pⁿ er sættet af alle ordnede sekvenser af n funktionsparametre.

(5) P := ⋃_0≤i≤∞P i^*
P^* er sættet af alle mulige sekvenser af funktionsparametre fra længden 0 og op.

(6) F := ⟨B, N, T⟩
F er sættet af alle postfelter. Hvert felt er muligvis valgfrit, har et navn og en type.

(7) Fⁿ := ∏_{0≤i≤n F}
Fⁿ er sættet af alle sæt n postfelter.

(8) F := ( ⋃_0≤i≤∞Fⁱ ) ∖ { F | ⟨b₁, n₁, t₁⟩, ⟨b₂, n₂, t₂⟩ ∈ F ⋀ n_{1 =} n_{2 }}^*
F^* er sættet af alle sæt (af en hvilken som helst længde) af postfelter, bortset fra de sæt, hvor mere end ét felt har det samme navn.

(9) C := ⟨N,T⟩
C er sættet af kolonnetyper for tabeller. Hver kolonne har et navn og en type.

(10) Cn ⊂ ⋃_0≤i≤n ⟨i, C⟩
Cⁿ er sættet af alle ordnede sekvenser af n kolonnetyper.

(11) C := ( ⋃_0≤i≤∞Ci ) ∖ { Cm | ⟨a, ⟨n₁, t₁⟩⟩, ⟨b, ⟨n₂, t₂⟩⟩ ∈ C^m ⋀ n₁ = n₂ }^*
C^* er sættet af alle kombinationer (af en hvilken som helst længde) af kolonnetyper, bortset fra dem, hvor mere end én kolonne har det samme navn.

M-TYPER

(12) T_F := ⟨P, P⟩^*
En funktionstype består af en returtype og en sorteret liste over funktionsparametre med nul eller flere.

(13) T_L :=〖T〗
En listetype er angivet af en given type (kaldet "elementtype") ombrudt i krøllede klammeparenteser. Da krøllede klammeparenteser anvendes i metalanguage, 〖 〗 kantede parenteser bruges i dette dokument.

(14) T_R := ⟨B, F⟩^*
En posttype har et flag, der angiver, om den er "åben" og nul eller flere usorterede postfelter.

(15) T_R^o := ⟨true, F⟩

(16) T_R^• := ⟨false, F⟩
T_R^o og T_R^• er notationelle genveje til henholdsvis åbne og lukkede posttyper.

(17) T_T := C ^*
En tabeltype er en sorteret sekvens af nul eller flere kolonnetyper, hvor der ikke er navnekollisioner.

(18) T_P := { any; null; logical; number; time; date; datetime; datetimezone; duration; text; binary; type; list; record; table; function; anynonnull }
En primitiv type er en fra denne liste over M-nøgleord.

(19) T_N := { t_n, u ∈ T | t_n = u+null } = t, der kan være null
En hvilken som helst type kan desuden markeres som null ved hjælp af nøgleordet "nullable" .

(20) T := T_F ∪ T_L ∪ T_R ∪ T T ∪ T_P ∪ T N
Sættet af alle M-typer er foreningen af disse seks sæt af typer:
Funktionstyper, listetyper, posttyper, tabeltyper, primitive typer og null-typer.

FUNKTIONER

Der skal defineres én funktion: Ikke-ullerbar : T ← T
Denne funktion tager en type og returnerer en type, der er tilsvarende, bortset fra at den ikke er i overensstemmelse med null-værdien.

IDENTITETER

Nogle identiteter er nødvendige for at definere nogle særlige tilfælde og kan også hjælpe med at belyse ovenstående.

(21) nullable any = any
(22) nullable anynonnull = any
(23) null kan være null = null
(24) ingen kan være null = null
(25) Nullable t ∈ T = nullable t
(26) NonNullable(nullable t ∈ T) = NonNullable(t)
(27) NonNullable(any) = anynonnull

TYPEKOMPATIBILITET

Som defineret et andet sted kan en M-type være kompatibel med en anden M-type, hvis og kun hvis alle værdier, der er i overensstemmelse med den første type, også er i overensstemmelse med den anden type.

Her er defineret en kompatibilitetsrelation, der ikke afhænger af overensstemmende værdier, og som er baseret på egenskaberne for selve typerne. Det forventes, at denne relation, som defineret i dette dokument, svarer fuldstændigt til den oprindelige semantiske definition.

Relationen "er kompatibel med": ≤ : B ← T × T
I nedenstående afsnit repræsenterer et lille t altid en M-type, der er et element af T.

En Φ repræsenterer en delmængde af F^* eller C^*.

(28) t ≤ t
Denne relation er refleksiv.

(29) t_a ≤ t_b ∧ t_b ≤ t_c → t_a ≤ t c
Denne relation er transitiv.

(30) Ingen ≤ ≤ nogen
M-typer danner et gitter over denne relation. ingen er bunden, og enhver er toppen.

(31) t_a, t_b ∈ T_N ∧ t_a ≤ t_a → NonNullable(t_a) ≤ NonNullable(t_b)
Hvis to typer er kompatible, er de ikke-ullable ækvivalenter også kompatible.

(32) null ≤ t ∈ T_N
Den primitive type null er kompatibel med alle typer, der kan være null.

(33) t ∉ T_N ≤ anynonnull
Alle typer, der ikke kanulleres, er kompatible med anynonnull.

(34) NonNullable(t) ≤ t
En ikke-ullibel type er kompatibel med den tilsvarende værdi, der kan være null.

(35) t ∈ T_F → t ≤ funktion
Alle funktionstyper er kompatible med funktionen.

(36) t ∈ T_L → t ≤ liste
Alle listetyper er kompatible med listen.

(37) t ∈ T_R → t ≤ post
Alle posttyper er kompatible med post.

(38) t ∈ T T → t ≤ tabel
Alle tabeltyper er kompatible med tabellen.

(39) t_a ≤ t_b ↔ 〖t_a〗≤〖t_b〗
En listetype kan kombineres med en anden listetype, hvis elementtyperne er kompatible og omvendt.

(40) t_a ∈ T_F = ⟨ p_a, p^* ⟩, t_b ∈ T_F = ⟨ p_b, p^* ⟩ ∧ p_a ≤ p_b → t_a ≤ t b
En funktionstype er kompatibel med en anden funktionstype, hvis returtyperne er kompatible, og parameterlisterne er identiske.

(41) t_a ∈ T_R^o, t_b ∈ T_R^• → t_a ≰ t b
En åben posttype er aldrig kompatibel med en lukket posttype.

(42) t_a ∈ TR• = ⟨false, Φ⟩, t_b ∈ T_Ro = ⟨true, Φ⟩ → t_a ≤ t b
En lukket posttype er kompatibel med en ellers identisk åben posttype.

(43) t_a ∈ TRo = ⟨true, (Φ, ⟨true, n, any⟩)⟩, t_b ∈ T_Ro = ⟨true, Φ⟩ → t_a ≤ t_b ∧ t_b ≤ t a
Et valgfrit felt med typen any kan ignoreres, når du sammenligner to åbne posttyper.

(44) t_a ∈ T_R = ⟨b, (Φ, ⟨β, n, u_a⟩)⟩, t_b ∈ T_R = ⟨b, (Φ, ⟨β, n, u_b⟩)⟩ ∧ u_a ≤ u_{b →} t_a ≤ t_{b b}
To posttyper, der kun adskiller sig fra ét felt, er kompatible, hvis feltets navn og valgfrihed er identiske, og typerne af det pågældende felt er kompatible.

(45) t_a ∈ T_R = ⟨b, (Φ, ⟨false, n, u⟩)⟩, t_b ∈ T_R = ⟨b, (Φ, ⟨true, n, u⟩)⟩ → t_a ≤ t b
En posttype med et ikke-valgfrit felt er kompatibel med en posttype, der er identisk, men for det pågældende felt er valgfrit.

(46) t_a ∈ T_Ro = ⟨true, (Φ, ⟨b, n, u⟩)⟩, t_b ∈ T_Ro = ⟨true, Φ⟩ → t_a ≤ t b
En åben posttype er kompatibel med en anden åben posttype med ét felt færre.

(47) t_a ∈ T_T = (Φ, ⟨i, ⟨n, u_a⟩⟩), t_b ∈ T_T = (Φ, ⟨i, ⟨n, u_b⟩⟩) ∧ u_a ≤ u_b → t_a ≤ t_{b b}
En tabeltype er kompatibel med en anden tabeltype, som er identisk, men for én kolonne med forskellig type, når typerne for den pågældende kolonne er kompatible.

REFERENCES (REFERENCER)

Microsoft Corporation (2015 August)
Microsoft Power Query til Excel-formelsprogspecifikation [PDF]
Hentet fra https://msdn.microsoft.com/library/mt807488.aspx

Microsoft Corporation (n.d.)
Reference til M-funktion i Power Query [webside]
Hentet fra https://msdn.microsoft.com/library/mt779182.aspx