Typy v jazyce vzorců Power Query M

Jazyk vzorců Power Query M je užitečný a výrazný jazyk mashupu dat. Má ale určitá omezení. Například neexistuje silné vynucování systému typů. V některých případech je potřeba přísnější ověření. M naštěstí poskytuje integrovanou knihovnu s podporou typů, aby bylo možné silnější ověřování.

Vývojáři by měli důkladně porozumět systému typů, aby to mohli provést s jakoukoli generalitou. A zatímco specifikace jazyka Power Query M vysvětluje systém typů dobře, ponechá několik překvapení. Například ověření instancí funkcí vyžaduje způsob, jak porovnat typy z důvodu kompatibility.

Prozkoumáním systému typů M důkladněji je možné řadu těchto problémů objasnit a vývojáři budou moct vytvářet potřebná řešení.

Znalost predikátu kalkulu a naïvové teorie množiny by měla být adekvátní k pochopení použitého zápisu.

PŘEDBĚŽNÉ KROKY

(1) B := { true; false }
B je typická sada logických hodnot.

(2) N := { platné identifikátory M }
N je sada všech platných názvů v jazyce M. Toto je definováno jinde.

(3) P := ⟨B, T⟩
P je sada parametrů funkce. Každý z nich je pravděpodobně volitelný a má typ. Názvy parametrů nejsou relevantní.

(4) Pⁿ := ⋃_0≤i≤n ⟨i, ^Pi⟩
Pⁿ je sada všech seřazených sekvencí n parametrů funkce.

(5) P := ⋃^*P i
P^* je sada všech možných sekvencí parametrů funkce od délky 0 nahoru.

(6) F := ⟨B, N, T⟩
F je sada všech polí záznamů. Každé pole je pravděpodobně volitelné, má název a typ.

(7) ^Fn := ∏_{0≤i≤n F}
Fⁿ je sada všech sad n polí záznamů.

(8) F := ( ⋃^* Fi ) ∖ { ^F | ⟨_b1, _n1, _t1⟩, ⟨_b2, _{n2, t2}⟩ ∈ F ⋀ _{n 1n =}
F^* je sada všech sad (libovolné délky) polí záznamů s výjimkou sad, u kterých má více polí stejný název.

(9) C := ⟨N,T⟩
C je sada typů sloupců pro tabulky. Každý sloupec má název a typ.

(10) ^Cn ⊂ ⋃_0≤i≤n ⟨i, C⟩
Cⁿ je sada všech seřazených sekvencí n typů sloupců.

(11) C := ( ⋃^* _{C i} ) ∖ { C^m | ⟨a, ⟨n_{1, t¹}⟩⟩, ⟨_b, ⟨n_{2, t2}⟩⟩ ∈ C_m ⋀ =
C^* je sada všech kombinací (libovolné délky) typů sloupců, s výjimkou těch, u kterých má více než jeden sloupec stejný název.

M TYPES

(12) T_F := ⟨P, P⟩^*
Typ funkce se skládá z návratového typu a seřazeného seznamu parametrů funkce nula nebo více.

(13) _TL :=〖T〗
Typ seznamu je označen daným typem (označovaným jako "typ položky") zabaleným do složených závorek. Vzhledem k tomu, že složené závorky se používají v metalanguage, 〖 〗 hranaté závorky se používají v tomto dokumentu.

(14) T_R := ⟨B, F⟩^*
Typ záznamu má příznak označující, jestli je "otevřená", a pole s nulovým nebo více neuspořádaným záznamem.

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

(16) _TR^• := ⟨false, F⟩
T_R^o a T_R^• jsou notační zkratky pro otevřené a uzavřené typy záznamů.

(17) T T := C ^*
Typ tabulky je seřazená posloupnost typů sloupců s nulovou nebo více hodnotami, kde nejsou žádné kolize názvů.

(18) T_P := { any; none; null; logical; number; time; datetime; datetimezone; duration; text; binary; type; list; record; table; function; anynonnull }
Primitivní typ je jeden z tohoto seznamu klíčových slov M.

(19) _TN := { t_n, u ∈ T | t_n = u+null } = nullable t
Libovolný typ lze navíc označit jako nullable pomocí klíčového slova nullable .

(20) T := _{TF ∪ T L ∪ TR} ∪ _{T T T∪ TP ∪T N}
Sada všech typů M je sjednocení těchto šesti sad typů:
Typy funkcí, typy seznamů, typy záznamů, typy tabulek, primitivní typy a typy s možnou hodnotou Null.

FUNKCE

Je potřeba definovat jednu funkci: NonNullable: T ← T
Tato funkce přebírá typ a vrací typ, který je ekvivalentní s tím rozdílem, že neodpovídá hodnotě null.

IDENTITY

Některé identity jsou potřeba k definování některých zvláštních případů a mohou také pomoct s elucididou výše.

(21) Libovolná hodnota null = libovolná
(22) nullable anynonnull = any
(23) Nullable null = null
(24) Žádná s možnou hodnotou null = null
(25) nullable nullable t ∈ T = nullable t
(26) NonNullable(nullable t ∈ T) = NonNullable(t)
(27) NonNullable(any) = anynonnull

KOMPATIBILITA TYPŮ

Jak je definováno jinde, typ M je kompatibilní s jiným typem M, pokud a pouze pokud všechny hodnoty, které odpovídají prvnímu typu, odpovídají také druhému typu.

Zde je definován vztah kompatibility, který nezávisí na odpovídajících hodnotách a je založen na vlastnostech samotných typů. Předpokládá se, že tento vztah, jak je definován v tomto dokumentu, je zcela ekvivalentní původní sémantické definici.

Vztah "je kompatibilní s" : ≤ : B ← T × T
V následující části bude malá písmena t vždy představovat typ M, prvek T.

Φ bude představovat podmnožinu F nebo C^*.^*

(28) t ≤ t
Tento vztah je reflexní.

29) t a ≤ _{tb ∧ t b ≤} t_{c →} t_a ≤ t c
Tento vztah je tranzitivní.

(30) žádné ≤ t ≤ žádné
Typy M tvoří mřížku nad tímto vztahem; žádné není dole a všechny jsou nahoře.

(31) t_a, t_{b b} ∈ T_N ∧ t a ≤ _t a → NonNullable(t_a) ≤ NonNullable(t b)
Jsou-li kompatibilní dva typy, jsou také kompatibilní ekvivalenty NonNullable.

(32) hodnota null ≤ t ∈ T N
Primitivní typ null je kompatibilní se všemi typy s možnou hodnotou null.

(33) t ∉ T N _{≤ anynonnull}
Všechny nenulovatelné typy jsou kompatibilní s anynonnull.

(34) Nenulable(t) ≤ t
Typ NonNullible je kompatibilní s ekvivalentem s možnou hodnotou null.

(35) t ∈ T_F → t ≤
Všechny typy funkcí jsou kompatibilní s funkcí.

(36) t ∈ T L → _{t ≤}
Všechny typy seznamů jsou kompatibilní se seznamem .

(37) t ∈ T R → t ≤ záznam
Všechny typy záznamů jsou kompatibilní se záznamem .

(38) t ∈ T T_→t ≤ tabulka
Všechny typy tabulek jsou kompatibilní s tabulkou.

(39) t a ≤ t_b ↔ 〖t_a〗≤〖t_b〗
Typ seznamu je kompatibilní s jiným typem seznamu, pokud jsou typy položek kompatibilní a naopak.

(40) t_a ∈ T_F = ⟨ p a, ^* ⟩, t_{b b} ∈ T_F = ⟨ p_b,^* ⟩ ∧ p_a ≤ pb → t a ≤ t _{b b}
Typ funkce je kompatibilní s jiným typem funkce, pokud jsou návratové typy kompatibilní a seznamy parametrů jsou identické.

(41) t_a ∈ _TR^o, t_{b b} ∈ _TR^• → t_a ≰ t b
Typ otevřeného záznamu není nikdy kompatibilní s uzavřeným typem záznamu.

(42) t_a ∈ ^TR• = ⟨false, Φ⟩, t_{b ∈}T^_Ro = ⟨true, Φ⟩ → _{t a} ≤ _{t b}
Uzavřený typ záznamu je kompatibilní s jiným identickým otevřeným typem záznamu.

(43) t_a ∈ ^TRo = ⟨true, (Φ, ⟨true, n, any⟩)⟩, t_{b ∈}T_R^o = ⟨true, Φ⟩ → t a ≤ t_{b ∧} t_b ≤ t a
Volitelné pole s typemmůže být při porovnávání dvou otevřených typů záznamů ignorováno.

(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
Dva typy záznamů, které se liší pouze jedním polem, jsou kompatibilní, pokud je název a volitelnost pole stejné a typy uvedeného pole jsou kompatibilní.

(45) t_a ∈ T_R = ⟨b, (Φ, ⟨false, n, u⟩)⟩, t_{b ∈} T_R = ⟨b, (Φ, ⟨true, n, u⟩)⟩ → t a ≤ t b
Typ záznamu s nepovinným polem je kompatibilní s identickým typem záznamu, ale pro toto pole je volitelné.

(46) t_a ∈ T^_Ro = ⟨true, (Φ, ⟨b, n, u⟩)⟩, t_{b ∈}T^_Ro = ⟨true, Φ⟩ → _{t a} ≤ t b
Typ otevřeného záznamu je kompatibilní s jiným typem otevřeného záznamu s jedním menším polem.

(47) t_a ∈ T_T = (Φ, ⟨i, ⟨n, u_a⟩⟩), t_{b b ∈}T T = (Φ, ⟨i, ⟨n, u_b⟩⟩) ∧ u a ≤ u_b → t_a ≤ t b b
Typ tabulky je kompatibilní s druhým typem tabulky, který je shodný, ale pro jeden sloupec s odlišným typem, pokud jsou typy pro daný sloupec kompatibilní.

Související obsah

• specifikace jazyka Power Query M
• Power Query M - referenční funkce
• Typy a převod typů
• typy