Types dans le langage de formules Power Query M

Le langage de formule Power Query M est un langage de mashup de données utile et expressif, mais il présente certaines limitations. Par exemple, il n’existe aucune forte mise en œuvre du système de type. Dans certains cas, une validation plus rigoureuse est nécessaire. Heureusement, M fournit une bibliothèque intégrée avec prise en charge des types pour faciliter une validation plus rigoureuse.

Les développeurs doivent avoir une solide compréhension du système de type afin d’effectuer cette opération. De plus, même si la spécification du langage Power Query M explique bien le système de type, quelques surprises demeurent. Par exemple, la validation des instances de fonction nécessite un moyen de comparer la compatibilité des types.

Une exploration attentive du système de type M permettra de clarifier un grand nombre de ces problèmes, et les développeurs seront en mesure de concevoir les solutions dont ils ont besoin.

Une connaissance du calcul des prédicats et de la théorie naïve des ensembles devrait suffire pour comprendre la notation utilisée.

PRÉLIMINAIRES

(1) B := { true; false }
B est l’ensemble typique de valeurs booléennes

(2) N := { identificateurs M valides }
N est l’ensemble de tous les noms valides en M. Ceci est défini ailleurs.

(3) P := ⟨B, T⟩
P est l’ensemble de paramètres de fonction. Chacun d’eux est éventuellement facultatif et a un type. Les noms des paramètres ne sont pas pertinents.

(4) Pⁿ := ⋃_0≤i≤n ⟨i, Pⁱ⟩
Pⁿ est l’ensemble de toutes les séquences classées de n paramètres de fonction.

(5) P := ⋃_0≤i≤∞P i^*
P^* est l’ensemble de toutes les séquences possibles de paramètres de fonction, de longueur inférieure ou égale à 0.

(6) F := ⟨B, N, T⟩
F est l’ensemble de tous les champs d’enregistrement. Chaque champ est éventuellement facultatif, a un nom et un type.

(7) Fⁿ := ∏_{0≤i≤n F}
Fⁿ est l’ensemble de tous les ensembles de n champs d’enregistrement.

(8) F := ( ⋃_0≤i≤∞ Fi ) ∖ { F | ⟨b_{1, n1}, t₁⟩, ⟨b_{2, n2, t2}⟩ ∈ F ⋀ n₁ = n_{2 }}^*
F^* est l’ensemble de tous les ensembles (de n’importe quelle longueur) de champs d’enregistrement, à l’exception des ensembles où plusieurs champs ont le même nom.

(9) C := ⟨N,T⟩
C est l’ensemble de types de colonnes pour les tables. Chaque colonne a un nom et un type.

(10) Cⁿ ⊂ ⋃_0≤i≤n ⟨i, C⟩
Cⁿ est l’ensemble de toutes les séquences classées de n types de colonnes.

(11) C := ( ⋃_0≤i≤∞ Ci ) ∖ { C^m | ⟨a, ⟨n_{1, t1}⟩⟩, ⟨b, ⟨n₂, t₂⟩⟩ ∈ C^{m ⋀} n₁ = n_{2 }}^*
C^* est l’ensemble de toutes les combinaisons (de n’importe quelle longueur) de types de colonnes, à l’exception de ceux où plusieurs colonnes ont le même nom.

TYPES M

(12) T_F := ⟨P, P^*⟩
Un type de fonction se compose d’un type de retour et d’une liste triée de zéro, un ou plusieurs paramètres de fonction.

(13) T_L :=〖T〗
Un type de liste est indiqué par un type donné (appelé « type d’élément ») entouré d’accolades. Étant donné que les accolades sont utilisées dans le métalangage, des crochets 〖 〗 sont utilisés dans ce document.

(14) T_R := ⟨B, F^*⟩
Un type d’enregistrement a un indicateur spécifiant s’il est « ouvert », et zéro, un ou plusieurs champs d’enregistrement non classés.

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

(16) T_R^• := ⟨false, F⟩
T_R^o et T_R^• sont des raccourcis de notation respectivement pour les types d’enregistrements ouverts et fermés.

(17) T_T := C^*
Un type de table est une séquence classée de zéro, un ou plusieurs types de colonnes, où il n’y a pas de collisions de noms.

(18) T_P := { any; none; null; logical; number; time; date; datetime; datetimezone; duration; text; binary; type; list; record; table; function; anynonnull }
Un type primitif est l’un des éléments de cette liste de mots clés M.

(19) T_N := { t_n, u ∈ T | t_n = u+null } = nullable t
Tout type peut également être marqué comme pouvant accepter la valeur Null, à l’aide du mot clé « nullable » .

(20) T := T_F ∪ T_L ∪ T_R ∪ T_T ∪ T_P ∪ T_N
L’ensemble de tous les types M est l’union de ces six ensembles de types :
Types de fonctions, types de listes, types d’enregistrements, types de tables, types primitifs et types Nullable.

FONCTIONS

Une fonction doit être définie : NonNullable : T ← T
Cette fonction prend un type et retourne un type équivalent, sauf qu’il n’est pas conforme à la valeur Null.

IDENTITÉS

Certaines identités sont nécessaires pour définir certains cas spéciaux, et peuvent également aider à élucider ce qui précède.

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

COMPATIBILITÉ DES TYPES

Comme défini ailleurs, un type M est compatible avec un autre type M si et seulement si toutes les valeurs conformes au premier type sont également conformes au second type.

Cet exemple définit une relation de compatibilité qui ne dépend pas de valeurs conformes et est basée sur les propriétés des types eux-mêmes. Il est attendu que cette relation, telle que définie dans ce document, soit complètement équivalente à la définition sémantique d’origine.

La relation « est compatible avec » : ≤ : B ← T × T
Dans la section ci-dessous, un t minuscule représente toujours un type M, un élément de T.

Un Φ représente un sous-ensemble de F^* ou de C^*.

(28) t ≤ t
Cette relation est réflexive.

(29) t_a ≤ t_b ∧ t_b ≤ t_c → t_a ≤ t_c
Cette relation est transitive.

(30) none ≤ t ≤ any
Les types M forment un treillis sur cette relation ; none est le bas et any est le haut.

(31) t_a, t_b ∈ T_N ∧ t_a ≤ t_a → NonNullable(t_a) ≤ NonNullable(t_b)
Si deux types sont compatibles, les équivalents NonNullable sont également compatibles.

(32) null ≤ t ∈ T_N
Le type primitif null est compatible avec tous les types nullable.

(33) t ∉ T_N ≤ anynonnull
Tous les types nonnullable sont compatibles avec anynonnull.

(34) NonNullable(t) ≤ t
Un type NonNullable est compatible avec l’équivalent nullable.

(35) t ∈ T_F → t ≤ function
Tous les types de fonctions sont compatibles avec function.

(36) t ∈ T_L → t ≤ list
Tous les types de listes sont compatibles avec list.

(37) t ∈ T_R → t ≤ record
Tous les types d’enregistrements sont compatibles avec record.

(38) t ∈ T_T → t ≤ table
Tous les types de tables sont compatibles avec table.

(39) t_a ≤ t_b ↔ 〖t_a〗≤〖t_b〗
Un type de liste est compatible avec un autre type de liste si les types d’éléments sont compatibles, et inversement.

(40) t_a ∈ T_F = ⟨ p_a, p^* ⟩, t_b ∈ T_F = ⟨ p_b, p^* ⟩ ∧ p_a ≤ p_b → t_a ≤ t_b
Un type de fonction est compatible avec un autre type de fonction si les types de retour sont compatibles et si les listes de paramètres sont identiques.

(41) t_a ∈ T_R^o, t_b ∈ T_R^• → t_a ≰ t_b
Un type d’enregistrement ouvert n’est jamais compatible avec un type d’enregistrement fermé.

(42) t_a ∈ T_R^• = ⟨false, Φ⟩, t_b ∈ T_R^o = ⟨true, Φ⟩ → t_a ≤ t_b
Un type d’enregistrement fermé est compatible avec un type d’enregistrement ouvert identique.

(43) t_a ∈ T_R^o = ⟨true, (Φ, ⟨true, n, any⟩)⟩, t_b ∈ T_R^o = ⟨true, Φ⟩ → t_a ≤ t_b ∧ t_b ≤ t_a
Un champ facultatif avec le type any peut être ignoré lors de la comparaison de deux types d’enregistrements ouverts.

(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
Deux types d’enregistrements qui diffèrent uniquement par un champ sont compatibles si le nom et le caractère facultatif du champ sont identiques et si les types de ce champ sont compatibles.

(45) t_a ∈ T_R = ⟨b, (Φ, ⟨false, n, u⟩)⟩, t_b ∈ T_R = ⟨b, (Φ, ⟨true, n, u⟩)⟩ → t_a ≤ t_b
Un type d’enregistrement avec un champ non facultatif est compatible avec un type d’enregistrement identique mais dont ce champ est facultatif.

(46) t_a ∈ T_R^o = ⟨true, (Φ, ⟨b, n, u⟩)⟩, t_b ∈ T_R^o = ⟨true, Φ⟩ → t_a ≤ t_b
Un type d’enregistrement ouvert est compatible avec un autre type d’enregistrement ouvert avec un champ de moins.

(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
Un type de table est compatible avec un second type de table qui est identique mais dont l’une des colonnes a un type différent, quand les types de cette colonne sont compatibles.

REFERENCES

Microsoft Corporation (août 2015)
Spécification du langage de formule Microsoft Power Query pour Excel [PDF]
Récupéré à partir de https://msdn.microsoft.com/library/mt807488.aspx

Microsoft Corporation (non daté)
Informations de référence sur les fonctions Power Query M
Récupéré à partir de https://msdn.microsoft.com/library/mt779182.aspx