Condividi tramite

Supporto della durata in Power Query M

Una durata in Power Query M rappresenta la differenza tra due punti nel tempo, espressi in giorni, ore, minuti e secondi. Sia che si stia calcolando il tempo tra le interazioni con i clienti, il filtro dei record in base al tempo trascorso o la creazione di una logica dinamica basata sul tempo, le durate sono essenziali per la creazione di modelli di dati affidabili e intelligenti.

Questo articolo illustra la struttura, la creazione e la modifica delle durate in Power Query M. Include esempi pratici e condivisioni suggerimenti che consentono di usare in modo efficace le durate nei flussi di lavoro dei dati.

Creare una durata

Una durata è definita dalla #duration(<days>, <hours>, <minutes>, <seconds>) funzione . Ad esempio, #duration(2, 3, 0, 0) rappresenta una durata di 2 giorni e 3 ore. Power Query M offre diversi modi per creare una durata, a seconda del contesto e del livello di precisione richiesto.

Usare la funzione #duration

Il modo più diretto per creare una durata è la #duration(<days>, <hours>, <minutes>, <seconds>) sintassi . Ogni argomento deve essere un numero e il risultato è un valore di durata.

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

Questa funzione supporta anche i secondi frazionari:

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

Creare durate dai valori di data e ora

È anche possibile creare durate sottraendo un valore di data e ora da un altro. Il risultato è una durata che rappresenta l'intervallo di tempo tra i due.

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

Annotazioni

Sottraendo un tipo di data e ora da un tipo di data e ora diverso (ad esempio, sottraendo un date valore da un datetime valore) viene generato un errore. Se è necessario usare tipi di data e ora diversi per determinare una durata, usare le Date.Fromfunzioni , DateTime.FromDateTimeZone.From, o Time.From per modificare in modo esplicito uno dei tipi di data e ora.

Converti da valori compatibili

La Duration.From funzione può convertire valori compatibili in durate. Per altre informazioni, vedere Duration.From(valore).

Usare le durate

Una volta creata una durata in Power Query M, può essere modificata usando varie operazioni e funzioni. Queste funzionalità rendono le durate estremamente versatili per la logica e i calcoli basati sul tempo.

Operazioni aritmetiche

Le durate supportano operazioni aritmetiche standard:

  • Addizione e sottrazione: aggiungere o sottrarre durate tra loro o da valori di data e ora.

    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

  • Negazione: una durata può essere negata per invertire la direzione.

    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

Moltiplicazione e divisione

Le durate possono essere moltiplicate o divise per valori numerici:

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

Questo calcolo è utile per la scalabilità di durate o intervalli di tempo medi.

Confronti

È possibile confrontare le durate usando gli operatori di confronto standard:

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

Questo calcolo consente l'uso delle durate nella logica condizionale, ad esempio il filtro delle righe in base al tempo trascorso.

Compatibilità del tipo

Le durate sono compatibili con i valori di data e ora nelle espressioni aritmetiche, ma non intercambiabili con essi. Ad esempio, la sottrazione di due valori di data e ora restituisce un durationoggetto , ma l'aggiunta di due valori di data e ora non è valida.

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

Funzioni di durata in M

Power Query M include un set di funzioni predefinite per l'uso delle durate. Queste funzioni consentono la conversione, l'estrazione di componenti e l'aggregazione dei valori di durata, rendendoli strumenti essenziali per le trasformazioni basate sul tempo.

Duration.From(valore)

La Duration.From funzione converte un valore compatibile in una durata. I valori compatibili sono costituiti da un numero interpretato come frazione di un giorno o come rappresentazione testuale di una durata. Passare a Duration.FromText per informazioni sui formati di rappresentazione testuale.

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

Funzioni di accesso ai componenti

Queste funzioni estraggono parti specifiche di una durata:

  • Duration.Days(<duration>)

    Restituisce il numero di giorni interi nella durata.

  • Duration.Hours(<duration>)

    Restituisce il numero di ore successive all'intero giorno.

  • Duration.Minutes(<duration>)

    Restituisce il numero di minuti oltre le ore intere.

  • Duration.Seconds(<duration>)

    Restituisce il numero di secondi oltre i minuti interi.

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

Funzioni valore totale

Queste funzioni restituiscono il valore totale di una durata in una singola unità, incluse le parti frazionarie:

  • 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

Normalizzazione della durata

Nella maggior parte dei casi, la durata è costituita da giorni, ore (massimo 23 ore), minuti (massimo 59 minuti) e secondi (massimo 59,9999999 secondi). Tuttavia, in alcuni casi è possibile superare i valori massimi nei parametri di durata. In questo caso, Power Query M normalizza automaticamente questi valori:

  • Overflow di secondi in minuti
  • Minuti di overflow in ore
  • Overflow di ore in giorni

Si supponga, ad esempio, di avere una colonna che fornisce la data e l'ora di inizio per un processo in esecuzione. Inoltre, si dispone di una colonna che mostra quanto tempo è necessario per il completamento del processo, in secondi. Si vuole creare una terza colonna che mostri la data e l'ora di completamento del processo.

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 tabella seguente è il risultato di questi calcoli.

Screenshot della tabella contenente la colonna data e ora di fine derivata dall'ora di inizio e dalla durata in secondi.

Pertanto, anche se si dispone solo del numero di secondi in cui è stato eseguito un processo, Power Query M esegue il rollup del valore di durata in minuti, ore e giorni in cui viene valutato il risultato.

Rappresenta settimane, mesi e anni

Poiché le durate sono basate su unità fisse (giorni, ore, minuti, secondi), non esiste un concetto nativo di settimane, mesi o anni, che variano in lunghezza. Un duration tipo in Power Query M è una struttura fissa che non tiene conto delle regole del calendario. Per un intervallo di tempo accurato in mesi o anni, sottrarre una data e un'ora da un'altra invece di usare durate fisse. Questo approccio gestisce correttamente gli anni bisestili, le lunghezze dei mesi variabili e l'ora legale.This approach correctly handle leap years, varying month lengths, and daylight savings time (DST). Si noti tuttavia che un comportamento di data e ora può variare a seconda che la query venga eseguita localmente (in Power Query Desktop) o online (in Power Query Online). Per informazioni dettagliate, passare a Varianti locali, fisse e UTC della data e dell'ora correnti. In generale, evitare di basarsi su durate fisse per i calcoli a lungo termine.

  • Last updated on