Understøttelse af varighed i Power Query M

En varighed i Power Query M repræsenterer forskellen mellem to tidspunkter, udtrykt i dage, timer, minutter og sekunder. Uanset om du beregner tiden mellem kundeinteraktioner, filtrerer poster baseret på forløbet tid eller opbygger dynamisk tidsbaseret logik, er varigheder afgørende for at skabe robuste og intelligente datamodeller.

I denne artikel undersøges strukturen, oprettelsen og manipulationen af varigheder i Power Query M. Den indeholder praktiske eksempler og deler tip, der hjælper dig med at bruge varigheder effektivt i dine egne dataarbejdsprocesser.

Opret en varighed

En varighed er defineret af funktionen #duration(<days>, <hours>, <minutes>, <seconds>) . Repræsenterer f.eks. #duration(2, 3, 0, 0) en varighed på 2 dage og 3 timer. Power Query M indeholder flere måder at oprette en varighed på, afhængigt af konteksten og det krævede præcisionsniveau.

Brug funktionen #duration

Den mest direkte måde at oprette en varighed på er med syntaksen #duration(<days>, <hours>, <minutes>, <seconds>) . Hvert argument skal være et tal, og resultatet er en varighedsværdi.

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

Denne funktion understøtter også brøkdele af sekunder:

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

Oprette varigheder ud fra dato- og klokkeslætsværdier

Varigheder kan også oprettes ved at trække en dato- og klokkeslætsværdi fra en anden. Resultatet er en varighed, der repræsenterer tidsrummet mellem de to.

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

Notat

Hvis du trækker en dato- og klokkeslætstype fra en anden dato- og klokkeslætstype (f.eks. hvis du trækker en date værdi fra en datetime værdi), opstår der en fejl. Hvis du skal bruge forskellige dato- og klokkeslætstyper til at bestemme en varighed, skal du bruge funktionerne Date.From, DateTime.From, DateTimeZone.Fromeller Time.From til eksplicit at ændre en af dato- og klokkeslætstyperne.

Konverter fra kompatible værdier

Funktionen Duration.From kan konvertere kompatible værdier til varigheder. Du kan finde flere oplysninger ved at gå til Duration.From(værdi).

Arbejde med varigheder

Når en varighed er oprettet i Power Query M, kan den manipuleres ved hjælp af forskellige handlinger og funktioner. Disse funktioner gør varigheder meget alsidige til tidsbaseret logik og beregninger.

Aritmetiske handlinger

Varigheder understøtter standardaritmetiske operationer:

Addition og subtraktion: Tilføj eller træk varigheder til eller fra hinanden eller fra dato- og klokkeslætsværdier.

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

Negation: En varighed kan negeres for at vende dens retning.

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

Multiplikation og division

Varigheder kan ganges eller divideres med numeriske værdier:

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

Denne beregning er nyttig til skalering af varigheder eller gennemsnitstidsintervaller.

Sammenligninger

Varigheder kan sammenlignes ved hjælp af standardsammenligningsoperatorer:

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

Denne beregning gør det muligt at bruge varigheder i betinget logik, f.eks. filtrering af rækker baseret på forløbet tid.

Typekompatibilitet

Varigheder er kompatible med dato- og klokkeslætsværdier i aritmetiske udtryk, men kan ikke udskiftes med dem. Hvis du f.eks. trækker to dato- og klokkeslætsværdier, får du et duration, men det er ugyldigt at tilføje to dato- og klokkeslætsværdier.

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

Varighedsfunktioner i M

Power Query M indeholder et sæt indbyggede funktioner til at arbejde med varigheder. Disse funktioner giver mulighed for konvertering, udtrækning af komponenter og aggregering af varighedsværdier, hvilket gør dem til vigtige værktøjer til tidsbaserede transformationer.

Duration.From(værdi)

Funktionen Duration.From konverterer en kompatibel værdi til en varighed. Kompatible værdier består enten af et tal, der fortolkes som en brøkdel af en dag, eller en tekstrepræsentation af en varighed. Gå til Duration.FromText for at få oplysninger om tekstrepræsentationsformaterne.

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

Komponent tilbehør

Disse funktioner udtrækker bestemte dele af en varighed:

Duration.Days(<duration>)

Returnerer antallet af hele dage i varigheden.
Duration.Hours(<duration>)

Returnerer antallet af timer ud over hele dagene.
Duration.Minutes(<duration>)

Returnerer antallet af minutter ud over hele timerne.
Duration.Seconds(<duration>)

Returnerer antallet af sekunder ud over hele minutterne.

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

Funktioner for samlet værdi

Disse funktioner returnerer den samlede værdi af en varighed i en enkelt enhed, herunder brøkdele:

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

Normalisering af varighed

I de fleste tilfælde består varigheden af dage, timer (maks. 23 timer), minutter (maks. 59 minutter) og sekunder (maks. 59,9999999 sekunder). I nogle tilfælde kan du dog overskride maksimumværdierne i varighedsparametrene. I dette tilfælde normaliserer Power Query M automatisk disse værdier:

Sekunder løber over i minutter
Minutter løber over i timer
Timer løber over i dage

Antag f.eks., at du har en kolonne, der angiver startdato og -klokkeslæt for en kørende proces. Derudover har du en kolonne, der viser, hvor lang tid det tog for processen at fuldføre, på få sekunder. Du vil oprette en tredje kolonne, der viser den dato og det klokkeslæt, hvor processen er fuldført.

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

Følgende tabel er resultatet af disse beregninger.

Skærmbillede af tabellen, der indeholder kolonnen med slutdato og -klokkeslæt, der er afledt af starttidspunktet og varigheden i sekunder.

Så selvom du kun havde det antal sekunder, som en proces fandt sted, ruller Power Query M denne varighedsværdi op i minutter, timer og dage, når resultatet evalueres.

Repræsentere uger, måneder og år

Da varigheder er baseret på faste enheder (dage, timer, minutter, sekunder), er der ikke noget indbygget begreb om uger, måneder eller år, som varierer i længde. En duration type i Power-forespørgsel M er en fast struktur, der ikke tager højde for kalenderregler. For nøjagtig varighed over måneder eller år skal du trække en dato og et klokkeslæt fra en anden i stedet for at bruge faste varigheder. Denne tilgang håndterer skudår, varierende månedslængder og sommertid korrekt. Bemærk dog også, at nogle funktionsmåmåder for dato og klokkeslæt kan variere, afhængigt af om forespørgslen kører lokalt (på Power Query Desktop) eller online (på Power Query Online). Du kan finde flere oplysninger ved at gå til Lokale, faste og UTC-varianter af aktuel dato og klokkeslæt. Undgå generelt at stole på faste varigheder til langsigtede beregninger.

Feedback

Var denne side nyttig?

Last updated on 2025-08-15