Compatibilidad con la duración en Power Query M

Una duración en Power Query M representa la diferencia entre dos puntos de tiempo, expresada en días, horas, minutos y segundos. Tanto si calcula el tiempo entre las interacciones del cliente, el filtrado de registros en función del tiempo transcurrido o la creación de lógica dinámica basada en tiempo, las duraciones son esenciales para crear modelos de datos sólidos e inteligentes.

En este artículo se explora la estructura, la creación y la manipulación de duraciones en Power Query M. Incluye ejemplos prácticos y sugerencias para compartir para ayudarle a usar duraciones de forma eficaz en sus propios flujos de trabajo de datos.

Crear una duración

La función define #duration(<days>, <hours>, <minutes>, <seconds>) una duración. Por ejemplo, #duration(2, 3, 0, 0) representa una duración de 2 días y 3 horas. Power Query M proporciona varias maneras de crear una duración, según el contexto y el nivel de precisión necesario.

Use la función #duration

La manera más directa de crear una duración es con la #duration(<days>, <hours>, <minutes>, <seconds>) sintaxis . Cada argumento debe ser un número y el resultado es un valor de duración.

#duration(2, 5, 30, 0) // 2 days, 5 hours, 30 minutes

Esta función también admite fracciones de segundo:

#duration(0, 0, 0, 1.75) // 1.75 seconds

Crear duraciones a partir de valores de fecha y hora

Las duraciones también se pueden crear restando un valor de fecha y hora de otro. El resultado es una duración que representa el intervalo de tiempo entre los dos.

let
    Source = 
    {
        #date(2025, 7, 24) - #date(2025, 7, 23),
        // Result: #duration(1, 0, 0, 0)
        #time(12, 0, 0) - #time(11, 30, 30),
        // Result: #duration(0, 0, 29, 30)
        #datetime(2025, 7, 24, 12, 0, 0) - #datetime(2025, 7, 23, 12, 0, 0),
        // Result: #duration(1, 0, 0, 0)
        #datetimezone(2025, 7, 24, 12, 0, 0, 7, 0) - #datetimezone(2025, 7, 23, 10, 30, 0, 4, 0),
        // Result: #duration(0, 22, 30, 0)
        #datetime(2025, 7, 24, 12, 0, 0) - DateTime.From(#date(2025, 7, 23))
        // Result: #duration(1, 12, 0, 0)
    }
in
    Source

Nota:

Restar un tipo de fecha y hora de un tipo de fecha y hora diferente (por ejemplo, restando un date valor de un datetime valor) produce un error. Si debe usar diferentes tipos de fecha y hora para determinar una duración, use las Date.Fromfunciones , DateTime.From, DateTimeZone.Fromo Time.From para cambiar explícitamente uno de los tipos de fecha y hora.

Conversión de valores compatibles

La Duration.From función puede convertir valores compatibles en duraciones. Para obtener más información, vaya a Duration.From(valor).

Trabajar con duraciones

Una vez creada una duración en Power Query M, se puede manipular mediante varias operaciones y funciones. Estas funcionalidades hacen que las duraciones sean muy versátiles para la lógica y los cálculos basados en tiempo.

Operaciones aritméticas

Las duraciones admiten operaciones aritméticas estándar:

Suma y resta: agregue o resta duraciones entre sí o de valores de fecha y hora.

let
    Source = {
        #duration(1, 2, 0, 0) + #duration(0, 3, 30, 0),
        // Result: #duration(1, 5, 30, 0)
        #duration(1, 2, 0, 0) - #duration(0, 3, 30, 0),
        // Result: #duration(0, 22, 30, 0)
        #datetime(2025, 7, 24, 12, 0, 0) + #duration(0, 2, 0, 0),
        // Result: #datetime(2025, 7, 24, 14, 0, 0)
        #datetime(2025, 7, 24, 12, 0, 0) - #duration(0, 2, 0, 0),
        // Result: #datetime(2025, 7, 24, 10, 0, 0)
        #time(12, 0, 0) - #duration(0, 3, 30, 0)
        // Result: #time(8, 30, 0)
    }
in
    Source

Negación: una duración se puede negar para invertir su dirección.

let
    Source = {
        #datetime(2025, 7, 24, 12, 0, 0) + -#duration(0, 2, 0, 0),
        // Result (subtracts two hours): #datetime(2025, 7, 24, 10, 0, 0)
        #datetime(2025, 7, 23, 12, 0, 0) - #datetime(2025, 7, 24, 12, 0, 0)
        // Result: -#duration(1, 0, 0, 0)
    }
in
    Source

Multiplicación y división

Las duraciones se pueden multiplicar o dividir por valores numéricos:

let
    Source = {
        #duration(0, 2, 0, 0) * 2,
        // Result (4 hours): #duration(0, 4, 0, 0)
        #duration(1, 0, 0, 0) / 2
        // Result (12 hours): #duration(0, 12, 0, 0)
    }
in
    Source

Este cálculo es útil para las duraciones de escalado o el promedio de intervalos de tiempo.

Comparaciones

Las duraciones se pueden comparar mediante operadores de comparación estándar:

let
    Source = #duration(1, 0, 0, 0) > #duration(0, 23, 59, 59)
        // Result: true
in
    Source

Este cálculo permite usar duraciones en la lógica condicional, como el filtrado de filas en función del tiempo transcurrido.

Compatibilidad de tipos

Las duraciones son compatibles con valores de fecha y hora en expresiones aritméticas, pero no intercambiables con ellos. Por ejemplo, restar dos valores de fecha y hora produce un duration, pero agregar dos valores de fecha y hora no es válido.

let
    Source = 
    {
        #datetime(2025, 7, 24, 12, 0, 0) - #datetime(2025, 7, 23, 12, 0, 0),
        // Result: #duration(1, 0, 0, 0)
        #datetime(2025, 7, 24, 12, 0, 0) + #datetime(2025, 7, 23, 12, 0, 0)
        // Result: Error
    }
in
    Source

Funciones de duración en M

Power Query M incluye un conjunto de funciones integradas para trabajar con duraciones. Estas funciones permiten la conversión, la extracción de componentes y la agregación de valores de duración, lo que las convierte en herramientas esenciales para las transformaciones basadas en el tiempo.

Duration.From(valor)

La Duration.From función convierte un valor compatible en una duración. Los valores compatibles constan de un número que se interpreta como una fracción de un día o una representación textual de una duración. Vaya a Duration.FromText para obtener información sobre los formatos de representación textual.

let
    Source =
    {
        Duration.From(1.5),
        // Result: 1.5 days = #duration(1, 12, 0, 0)
        Duration.From("2.05:55:20.242")
        // Result: #duration(2, 5, 55, 20.242)
    }
in
    Source

Descriptores de acceso de componente

Estas funciones extraen partes específicas de una duración:

Duration.Days(<duration>)

Devuelve el número de días enteros en la duración.
Duration.Hours(<duration>)

Devuelve el número de horas más allá de los días completos.
Duration.Minutes(<duration>)

Devuelve el número de minutos más allá de las horas completas.
Duration.Seconds(<duration>)

Devuelve el número de segundos más allá de los minutos completos.

let
    Source = #duration(2, 5, 30, 45),
    TextFormat = Text.Format(
        "Duration = #{0} days, #{1} hours, #{2} minutes, and #{3} seconds.",
        {
            Duration.Days(Source), 
            Duration.Hours(Source), 
            Duration.Minutes(Source), 
            Duration.Seconds(Source)
        }
    )
    // Results: "Duration = 2 days, 5 hours, 30 minutes, and 45 seconds."
in
    TextFormat

Funciones de valor total

Estas funciones devuelven el valor total de una duración en una sola unidad, incluidas las partes fraccionarias:

Duration.TotalDays(<duration>)
Duration.TotalHours(<duration>)
Duration.TotalMinutes(<duration>)
Duration.TotalSeconds(<duration>)

let
    Source = 
    {
        Duration.TotalDays(#duration(1, 12, 0, 0)),    // 1.5 days
        Duration.TotalHours(#duration(1, 12, 0, 0)),   // 36 hours
        Duration.TotalMinutes(#duration(1, 12, 0, 0)), // 2160 minutes
        Duration.TotalSeconds(#duration(1, 12, 0, 0))  // 129600 seconds
    }
in
    Source

Normalización de la duración

En la mayoría de los casos, la duración se compone de días, horas (máximo 23 horas), minutos (máximo 59 minutos) y segundos (máximo 59,9999999 segundos). Sin embargo, en algunos casos puede superar los valores máximos en los parámetros de duración. En este caso, Power Query M normaliza automáticamente estos valores:

Desbordamiento de segundos en minutos
Desbordamiento de minutos en horas
Desbordamiento de horas en días

Por ejemplo, supongamos que tiene una columna que proporciona la fecha y hora de inicio de un proceso en ejecución. Además, tiene una columna que muestra cuánto tiempo ha tardado el proceso en completarse, en segundos. Desea crear una tercera columna que muestre la fecha y hora en que se completa el proceso.

let
    Source = #table(type table[StartTime = datetime, Seconds = Int64.Type],
    {
        {#datetime(2025, 7, 25, 8, 0, 0), 5400},
        {#datetime(2025, 7, 25, 13, 15, 0), 86400},
        {#datetime(2025, 7, 24, 22, 30, 0), 172800}
    }),
    AddSeconds = Table.AddColumn(
        Source, 
        "EndTime", 
        each [StartTime] + #duration(0, 0, 0, [Seconds]), 
        type datetime
    )
in
    AddSeconds

La tabla siguiente es el resultado de estos cálculos.

Captura de pantalla de la tabla que contiene la columna de fecha y hora de finalización derivada de la hora de inicio y la duración en segundos.

Por lo tanto, aunque solo tuviera el número de segundos que tuvo lugar un proceso, Power Query M acumula ese valor de duración en minutos, horas y días cuando se evalúa el resultado.

Representar semanas, meses y años

Dado que las duraciones se basan en unidades fijas (días, horas, minutos, segundos), no hay ningún concepto nativo de semanas, meses o años, que varían en longitud. Un duration tipo de Power Query M es una estructura fija que no tiene en cuenta las reglas de calendario. Durante los meses o años, resta una fecha y hora de otra en lugar de usar duraciones fijas. Este enfoque controla correctamente los años bisiestos, las distintas longitudes del mes y el horario de verano (DST). Sin embargo, tenga en cuenta también que algún comportamiento de fecha y hora puede diferir en función de si la consulta se ejecuta localmente (en Power Query Desktop) o en línea (en Power Query Online). Para obtener más información, vaya a Variantes locales, fijas y UTC de fecha y hora actuales. En general, evite confiar en duraciones fijas para los cálculos a largo plazo.

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2025-08-15