Function.ScalarVector

Syntaxe

Function.ScalarVector(scalarFunctionType as type, vectorFunction as function) as function

À propos

Retourne une fonction scalaire de type scalarFunctionType qui appelle vectorFunction avec une seule ligne d’arguments et retourne sa sortie unique. En outre, lorsque la fonction scalaire est appliquée à plusieurs reprises pour chaque ligne d’une table d’entrées, comme dans Table.AddColumn, vectorFunction sera appliquée une seule fois pour l'ensemble des entrées.

vectorFunction se verra attribuer une table dont les colonnes correspondent par le nom et la position aux paramètres de scalarFunctionType. Chaque ligne de cette table contient les arguments d’un appel à la fonction scalaire, avec les colonnes correspondant aux paramètres de scalarFunctionType.

vectorFunction doit retourner une liste de la même longueur que la table d’entrée, dont l’élément à chaque position doit être le même résultat que l’évaluation de la fonction scalaire sur la ligne d’entrée de la même position.

La table d’entrée est censée être diffusée en continu, de sorte que vectorFunction transmette en continu sa sortie à mesure que l’entrée arrive, en travaillant uniquement avec un segment d’entrée à la fois. En particulier, vectorFunction ne doit pas énumérer sa table d’entrée plusieurs fois.

Exemple 1

Multipliez deux colonnes de la table d’entrée en traitant les entrées par lots de 100.

Utilisation

let
    Compute.ScoreScalar = (left, right) => left * right,
    // When Function.ScalarVector batching kicks in, we'll receive all
    // of the inputs for the entire table here at once.
    Compute.ScoreVector = (input) => let
        chunks = Table.Split(input, 100),
        scoreChunk = (chunk) => Table.TransformRows(chunk, each Compute.ScoreScalar([left], [right]))
      in
        List.Combine(List.Transform(chunks, scoreChunk)),
    Compute.Score = Function.ScalarVector(
        type function (left as number, right as number) as number, 
        Compute.ScoreVector
    ),
    Final = Table.AddColumn(
        Table.FromRecords({
            [a = 1, b = 2],
            [a = 3, b = 4]
        }),
        "Result",
        each Compute.Score([a], [b])
    )
in
    Final

Output

Table.FromRecords({
    [a = 1, b = 2, Result = 2],
    [a = 3, b = 4, Result = 12]
})

Exemple 2

Calculez les scores de test dans les lots de deux et remplissez un champ d’ID de lot qui peut être utilisé pour vérifier que le traitement par lots fonctionne comme prévu.

Utilisation

let
  _GradeTest = (right, total) => Number.Round(right / total, 2),
  _GradeTests = (inputs as table) as list => let
    batches = Table.Split(inputs, 2),
    gradeBatch = (batch as table) as list =>
      let
        batchId = Text.NewGuid()
      in
        Table.TransformRows(batch, each [Grade = _GradeTest([right], [total]), BatchId = batchId])
  in
    List.Combine(List.Transform(batches, gradeBatch)),
  GradeTest = Function.ScalarVector(type function (right as number, total as number) as number, _GradeTests),
  Tests = #table(type table [Test Name = text, Right = number, Total = number],
    {
      {"Quiz 1", 3, 4},
      {"Test 1", 17, 22},
      {"Quiz 2", 10, 10}
    }),
  // To break batching, replace [Right] with {[Right]}{0}.
  TestsWithGrades = Table.AddColumn(Tests, "Grade Info", each GradeTest([Right], [Total]), type record),
  // To verify batching, also expand BatchId.
  Final = Table.ExpandRecordColumn(TestsWithGrades, "Grade Info", {"Grade"})
in
  Final

Output

#table(
    type table [Test Name = text, Right = number, Total = number, Grade = number],
    {
      {"Quiz 1", 3, 4, 0.75},
      {"Test 1", 17, 22, 0.77},
      {"Quiz 2", 10, 10, 1}
    }
)