Function.ScalarVector

Sintaxis

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

Acerca de

Devuelve una función escalar de tipo scalarFunctionType que invoca vectorFunction con una sola fila de argumentos y devuelve su salida única. Además, cuando la función escalar se aplica repetidamente para cada fila de una tabla de entradas, como en Table.AddColumn, en lugar de vectorFunction se aplicará una vez para todas las entradas.

vectorFunction se le pasará una tabla cuyas columnas coincidan en nombre y posición con los parámetros de scalarFunctionType. Cada fila de esta tabla contiene los argumentos de una llamada a la función escalar, con las columnas correspondientes a los parámetros de scalarFunctionType.

vectorFunction debe devolver una lista de la misma longitud que la tabla de entrada, donde el elemento en cada posición debe ser el mismo resultado de evaluar la función escalar en la misma posición de la fila de entrada.

Se espera que la tabla de datos de entrada se procese en flujo, por lo que se espera que vectorFunction transmita su salida a medida que ingresan los datos, procesando solo un fragmento de datos a la vez. En concreto, vectorFunction no deben enumerar su tabla de entrada más de una vez.

Ejemplo 1

Multiplique dos columnas de la tabla de entrada mediante el procesamiento de las entradas en lotes de 100.

Uso

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

Salida

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

Ejemplo 2

Calcule las puntuaciones de las pruebas en lotes de dos y rellene un campo de identificador de lote que se puede usar para comprobar que el procesamiento por lotes funciona según lo previsto.

Uso

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

Salida

#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}
    }
)