Typer i formelspråket Power Query M

Det Power Query M-formelspråket är ett användbart och uttrycksfullt kombinationsspråk för data. Men det har vissa begränsningar. Det finns till exempel ingen stark tillämpning av typsystemet. I vissa fall krävs en mer rigorös validering. Lyckligtvis tillhandahåller M ett inbyggt bibliotek med stöd för typer för att göra en starkare validering möjlig.

Utvecklare bör ha en grundlig förståelse för typsystemet för att kunna göra detta med all generalitet. Och även om Power Query M-språkspecifikationen förklarar typsystemet väl, lämnar det några överraskningar. Validering av funktionsinstanser kräver till exempel ett sätt att jämföra typer av kompatibilitet.

Genom att utforska M-typsystemet mer noggrant kan många av dessa problem klargöras, och utvecklare kommer att få möjlighet att skapa de lösningar de behöver.

Kunskap om predikatkalkyl och naiv uppsättningsteori bör vara tillräcklig för att förstå den notation som används.

FÖRBEREDELSER

(1) B := { true; false }
B är den typiska uppsättningen booleska värden

(2) N := { giltiga M-identifierare }
N är uppsättningen med alla giltiga namn i M. Detta definieras någon annanstans.

(3) P := ⟨B, T⟩
P är uppsättningen funktionsparametrar. Var och en är möjligen valfri och har en typ. Parameternamn är irrelevanta.

(4) Pⁿ := ⋃_0≤i≤n ⟨i, Pⁱ⟩
Pⁿ är uppsättningen med alla ordnade sekvenser av n-funktionsparametrar.

(5) P^* := ⋃_0≤i≤∞Pⁱ
P^* är uppsättningen av alla möjliga sekvenser av funktionsparametrar, från längd 0 till och med.

(6) F := ⟨B, N, T⟩
F är uppsättningen för alla postfält. Varje fält är eventuellt valfritt, har ett namn och en typ.

(7) Fⁿ := ∏_0≤i≤nF
Fⁿ är uppsättningen med alla uppsättningar av n postfält.

(8) F^* := ( ⋃_0≤i≤∞Fⁱ ) ∖ { F | ⟨b₁, n₁, t₁⟩, ⟨b₂, n₂, t₂⟩ ∈ F ⋀ n₁ = n₂ }
F^* är uppsättningen med alla uppsättningar (oavsett längd) för postfält, förutom de uppsättningar där fler än ett fält har samma namn.

(9) C := ⟨N,T⟩
C är uppsättningen med kolumntyper för tabeller. Varje kolumn har ett namn och en typ.

(10) Cⁿ ⊂ ⋃_0≤i≤n ⟨i, C⟩
Cⁿ är uppsättningen med alla ordnade sekvenser av n kolumntyper.

(11) C^* := ( ⋃_0≤i≤∞Cⁱ ) ∖ { C^m | ⟨a, ⟨n₁, t₁⟩⟩, ⟨b, ⟨n₂, t₂⟩⟩ ∈ C^m ⋀ n₁ = n₂ }
C^* är uppsättningen med alla kombinationer (oavsett längd) för kolumntyper, förutom de där fler än en kolumn har samma namn.

M TYPER

(12) T_F := ⟨P, P^*⟩
En funktionstyp består av en returtyp och en ordnad lista med noll eller fler funktionsparametrar.

(13) T_L :=〖T〗
En listtyp anges av en viss typ (kallas "objekttyp") omsluten i klammerparenteser. Eftersom klammerparenteser används i metallanguage används 〖 〗 hakparenteser i det här dokumentet.

(14) T_R := ⟨B, F^*⟩
En posttyp har en flagga som anger om den är "öppen" och noll eller fler osorterade postfält.

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

(16) T_R^• := ⟨false, F⟩
T_R^o och T_R^• är notationella genvägar för öppna respektive stängda posttyper.

(17) T T := C^*
En tabelltyp är en ordnad sekvens med noll- eller fler kolumntyper, där det inte finns några namnkollisioner.

(18) T_P := { any; none; null; logical; number; time; date; datetime; datetimezone; duration; text; binary; type; list; record; table; function; anynonnull }
En primitiv typ är en från den här listan med M-nyckelord.

(19) T_N := { t_n, u ∈ T | t_n = u+null } = nullable t
Alla typer kan dessutom markeras som nullbara med hjälp avnyckelordet "nullable".

(20) T := T_F ∪ T_L ∪ T_R ∪ T_T ∪ T_P ∪ T_N
Uppsättningen av alla M-typer är en union av dessa sex uppsättningar av typer:
Funktionstyper, listtyper, posttyper, tabelltyper, primitiva typer och null-typer.

FUNKTIONER

En funktion måste definieras: NonNullable : T ← T
Den här funktionen tar en typ och returnerar en typ som är likvärdig förutom att den inte överensstämmer med null-värdet.

IDENTITETER

Vissa identiteter behövs för att definiera vissa specialfall och kan också hjälpa till att klargöra ovanstående.

(21) nullable any = any
(22) nullable anynonnull = any
(23) nullbar null = null
(24) nullable none = null
(25) nullable t ∈ T = nullable t
(26) NonNullable(nullable t ∈ T) = NonNullable(t)
(27) NonNullable(any) = anynonnull

TYPKOMPATIBILITET

Som definierats någon annanstans kan en M-typ användas med en annan M-typ om och endast om alla värden som överensstämmer med den första typen också överensstämmer med den andra typen.

Här definieras en kompatibilitetsrelation som inte är beroende av överensstämmande värden och som baseras på egenskaperna för själva typerna. Det förutses att den här relationen, enligt definitionen i det här dokumentet, helt motsvarar den ursprungliga semantiska definitionen.

Relationen "är kompatibel med" : ≤ : B ← T × T
I avsnittet nedan representerar ett gemener alltid en M-typ, ett element i T.

Φ representerar en delmängd av F^* eller C^*.

(28) t ≤ t
Den här relationen är reflexiv.

(29) t_en ≤ t_b ∧ t_b ≤ t_c → t_a ≤ t_c
Den här relationen är transitiv.

(30) Ingen ≤ inte ≤ några
M-typer bildar ett gitter över den här relationen. ingen är längst ned, och någon är överst.

(31) t_a, t_b ∈ T_N ∧ t_a ≤ t_a → NonNullable(t_a) ≤ NonNullable(t_b)
Om två typer är kompatibla är de icke-ullerbara motsvarigheterna också kompatibla.

(32) null ≤ t ∈ T_N
Den primitiva typen null är kompatibel med alla null-typer.

(33) t ∉ T_N ≤ anynonnull
Alla icke-inullbara typer är kompatibla med anynonnull.

(34) NonNullable(t) ≤ t
En icke-inullerbar typ är kompatibel med den nullbara motsvarigheten.

(35) t ∈ T_F → t ≤ funktion
Alla funktionstyper är kompatibla med funktionen.

(36) t ∈ T_L → t ≤ lista
Alla listtyper är kompatibla med listan.

(37) t ∈ T_R → t ≤ post
Alla posttyper är kompatibla med posten.

(38) t ∈ T_T → t ≤ tabell
Alla tabelltyper är kompatibla med tabellen.

(39) t_en ≤ t_b ↔ 〖t_a〗≤〖t_b〗
En listtyp är compaible med en annan listtyp om objekttyperna är kompatibla och vice versa.

(40) t_a ∈ T_F = ⟨ p_a, p^* ⟩, t_b ∈ T_F = ⟨ p_b, p^* ⟩ ∧ p_a ≤ p_b → t_a ≤ t_b
En funktionstyp är kompatibel med en annan funktionstyp om returtyperna är kompatibla och parameterlistorna är identiska.

(41) t_en ∈ T_R^o, t_b ∈ T_R^• → t_a ≰ _{t b}
En öppen posttyp är aldrig kompatibel med en typ av stängd post.

(42) t_a ∈ T_R^• = ⟨false, Φ⟩, t_b ∈ T_R^o = ⟨true, Φ⟩ → t_a ≤ t_b
En stängd posttyp är kompatibel med en i övrigt identisk öppen posttyp.

(43) t_a ∈ T_R^o = ⟨true, (Φ, ⟨true, n, any⟩)⟩, t_b ∈ T_R^o = ⟨true, Φ⟩ → t_a ≤ t_b ∧ t_b ≤ t_a
Ett valfritt fält med vilken typ som helst kan ignoreras när två öppna posttyper jämförs.

(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
Två posttyper som bara skiljer sig åt med ett fält är kompatibla om fältets namn och valfritt är identiska och fälttyperna är kompatibla.

(45) t_a ∈ T_R = ⟨b, (Φ, ⟨false, n, u⟩)⟩, t_b ∈ T_R = ⟨b, (Φ, ⟨true, n, u⟩)⟩ → t_a ≤ t_b
En posttyp med ett fält som inte är valfritt är kompatibelt med en identisk posttyp, men för det fältet är det valfritt.

(46) t_a ∈ T_R^o = ⟨true, (Φ, ⟨b, n, u⟩)⟩, t_b ∈ T_R^o = ⟨true, Φ⟩ → t_a ≤ t_b
En öppen posttyp är kompatibel med en annan öppen posttyp med ett fält med färre fält.

(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
En tabelltyp är kompatibel med en andra tabelltyp, som är identisk men för en kolumn som har en annan typ, när typerna för den kolumnen är kompatibla.

REFERENSLISTA

Microsoft Corporation (2015 augusti)
Microsoft Power Query for Excel Formula Language Specification [PDF]
Hämtad från https://msdn.microsoft.com/library/mt807488.aspx

Microsoft Corporation (n.d.)
Power Query M-funktionsreferens [webbsida]
Hämtad från https://msdn.microsoft.com/library/mt779182.aspx