Typer i Power Query M-formelspråket

Power Query M-formelspråket er et nyttig og uttrykksfullt dataflettingsspråk. Men det har noen begrensninger. Det finnes for eksempel ingen sterk håndhevelse av typesystemet. I noen tilfeller er det nødvendig med en strengere validering. Heldigvis gir M et innebygd bibliotek med støtte for typer for å gjøre sterkere validering mulig.

Utviklere bør ha en grundig forståelse av typesystemet for å kunne gjøre dette med enhver generalitet. Og selv om power query M-språkspesifikasjonen forklarer typesystemet godt, gir det noen overraskelser. Validering av funksjonsforekomster krever for eksempel en måte å sammenligne typer for kompatibilitet på.

Ved å utforske M-typesystemet mer nøye, kan mange av disse problemene avklares, og utviklere vil bli bemyndiget til å lage løsningene de trenger.

Kunnskap om predikatkalkulus og naiv sett teori bør være tilstrekkelig til å forstå notasjonen som brukes.

INNLEDENDE

(1) B := { true; false }
B er det vanlige settet med boolske verdier

(2) N := { gyldige M-identifikatorer }
N er settet med alle gyldige navn i M. Dette er definert et annet sted.

(3) P := ⟨B, T⟩
P er settet med funksjonsparametere. Hver av dem er muligens valgfri, og har en type. Parameternavn er irrelevante.

(4) Pⁿ := ⋃_0≤i≤n ⟨i, ^Pi⟩
Pⁿ er settet med alle ordnede sekvenser av n funksjonsparametere.

(5) P := ⋃^*P i
P^* er settet med alle mulige sekvenser av funksjonsparametere, fra lengden 0 på opp.

(6) F := ⟨B, N, T⟩
F er settet med alle postfelt. Hvert felt er muligens valgfritt, har et navn og en type.

(7) ^Fn := ∏_{0≤i≤n F}
Fⁿ er settet med alle sett med n postfelt.

(8) F := ( ⋃_{^* F}i ) ∖ { ^F | ⟨_b1, _n1, _t1⟩, ⟨_b2, _n2, _t2⟩ ∈ F ⋀ _{n1n =}
F^* er settet med alle sett (av en hvilken som helst lengde) av postfelt, bortsett fra settene der mer enn ett felt har samme navn.

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

(10) ^Cn ⊂ ⋃_0≤i≤n ⟨i, C⟩
Cⁿ er settet med alle ordnede sekvenser av n kolonnetyper.

(11) C := ( ⋃^* Ci ) ∖ { Cm | ⟨^a, ⟨_n1, _t1⟩⟩, ⟨b, ⟨_n2, _t2⟩⟩ ∈ ^Cm ⋀ n1_{n =} }
C^* er settet med alle kombinasjoner (av en hvilken som helst lengde) av kolonnetyper, bortsett fra de der mer enn én kolonne har samme navn.

M-TYPER

(12) T_F := ⟨P, P⟩^*
En funksjonstype består av en returtype, og en sortert liste over null-eller-flere funksjonsparametere.

(13) _TL :=〖T〗
En listetype angis av en gitt type (kalt elementtype) innpakket i klammeparenteser. Siden klammeparenteser brukes i metallfiske, 〖 〗 hakeparenteser brukes i dette dokumentet.

(14) T_R := ⟨B, F⟩^*
En posttype har et flagg som angir om det er «åpent» og null eller flere usorterte postfelt.

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

(16) _TR^• := ⟨false, F⟩
T^Ro og T_R^• er notasjonssnarveier for henholdsvis åpne og lukkede oppføringstyper.

(17) _TT := C ^*
En tabelltype er en ordnet sekvens med null-eller-flere kolonnetyper, der det ikke er noen navnekollisjoner.

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

(19) _TN := { t_n, u ∈ T | t_n = u+null } = nullable t
Alle typer kan i tillegg merkes som nullstillbare, ved hjelp av nøkkelordet «nullable ».

(20) T := T_F ∪ T_L ∪ T_R ∪ T_T ∪ T_P ∪ T_N
Settet med alle M-typer er unionen av disse seks settene med typer:
Funksjonstyper, listetyper, oppføringstyper, tabelltyper, primitive typer og typer som kan nullstilles.

FUNKSJONER

Én funksjon må defineres: NonNullable : T ← T
Denne funksjonen tar en type, og returnerer en type som tilsvarer, bortsett fra at den ikke samsvarer med nullverdien.

IDENTITETER

Noen identiteter er nødvendig for å definere noen spesielle tilfeller, og kan også bidra til å belyse ovennevnte.

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

TYPEKOMPATIBILITET

Som definert et annet sted, kan en M-type kompateres med en annen M-type hvis og bare hvis alle verdier som samsvarer med den første typen, også samsvarer med den andre typen.

Her er definert en kompatibilitetsrelasjon som ikke er avhengig av samsvarende verdier, og er basert på egenskapene til selve typene. Det forventes at denne relasjonen, som definert i dette dokumentet, er helt lik den opprinnelige semantiske definisjonen.

Relasjonen "er kompatibel med" : ≤ : B ← T × T
I inndelingen nedenfor vil en liten t alltid representere en M-type, et element av T.

En ^*

(28) t ≤ t
Denne relasjonen er refleksiv.

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

(30) ingen ≤ ikke ≤ noen
M-typer danner et gitter over denne relasjonen. ingen er nederst, og alle er øverst.

(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-ekvivalentene som ikke kan brukes, også kompatible.

(32) null ≤ t ∈ T_N
Primitiv type null er kompatibel med alle typer som kan nullstilles.

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

(34) NonNullable(t) ≤ t
En type som ikke kan nullstilles, er kompatibel med den nullbare ekvivalenten.

(35) t ∈ T_F → t ≤ funksjon
Alle funksjonstyper er kompatible med funksjonen.

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

(37) t ∈ T_R → t ≤ post
Alle oppføringstyper er kompatible med posten.

(38) t ∈ T_T → t ≤ tabell
Alle tabelltyper er kompatible med tabellen.

(39) t_a ≤ t_b ↔ 〖t_a〗≤〖t_b〗
En listetype kan sammenlignes med en annen listetype hvis elementtypene er kompatible, og omvendt.

(40) t_a ∈ T_F = ⟨ p_a, ^* ⟩, t_b ∈ T_F = ⟨ p_b, ^* ⟩ ∧ p_a ≤ p_b → t_a ≤ t b
En funksjonstype er kompatibel med en annen funksjonstype hvis returtypene er kompatible, og parameterlistene er identiske.

(41) t_a ∈ _TR^o, t_b ∈ _TR^• → t_a ≰ t b
En åpen posttype er aldri kompatibel med en lukket posttype.

(42) t_a ∈ ^T_R• = ⟨false, Φ⟩, t_b ∈ T^_Ro = ⟨true, Φ⟩ → t_a ≤ t b
En lukket posttype er kompatibel med en ellers identisk åpen posttype.

(43) t_a ∈ ^TRo = ⟨true, (Φ, ⟨true, n, any⟩)⟩, t_b ∈ T^Ro = ⟨true, Φ⟩ → t_a ≤ t_b ∧ t_b ≤ t a
Et valgfritt felt med hvilken som helst type kan ignoreres når du sammenligner to åpne oppføringstyper.

(44) t_en ∈ T_R = ⟨b, (Φ, ⟨β, n, u_a⟩)⟩, t_b ∈ T_R = ⟨b, (Φ, ⟨β, n, u_b⟩)⟩ ∧ u_a ≤ u_b → t_a ≤ t b
To posttyper som bare varierer med ett felt, er kompatible hvis navnet og valgfriheten til feltet er identisk, og typene nevnte 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-valgfritt felt er kompatibelt med en posttype identisk, men for at feltet skal være valgfritt.

(46) t_a ∈ T^_Ro = ⟨true, (Φ, ⟨b, n, u⟩)⟩, t_b ∈ T^_Ro = ⟨true, Φ⟩ → t_a ≤ t b
En åpen posttype er kompatibel med en annen åpen posttype med ett færre felt.

(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 tabelltype er kompatibel med en annen tabelltype, som er identisk, men for én kolonne som har en annen type, når typene for denne kolonnen er kompatible.

Relatert innhold

• språkspesifikasjon for Power Query M
• referanse for Power Query M-funksjonen
• typer og typekonvertering
• typer