Meine projekterprobte Kalendertabelle für Power BI und Power Pivot

Ich kann mich in meiner Arbeit als Berater und Entwickler für Power BI-Lösungen lediglich an ein einziges Projekt erinnern, in dem die vorhandenen Daten nicht im zeitlichen Verlauf analysiert werden sollten. In allen anderen Projekten war dies fester Bestandteil der Anforderung und somit war auch die Integration einer passenden Kalendertabelle einer der ersten Schritte im Projekt. Natürlich habe ich mir über die Jahre eine entsprechende Tabelle in einer Funktion gekapselt. In diesem Beitrag stelle ich Dir meine projekterprobte Kalendertabelle nicht nur vor, sondern auch zur Verfügung.

Als Abonnent meines Newsletters erhältst Du die Beispieldateien zu den Beiträgen dazu. Hier geht’s zum Abonnement des Newsletters!

Wieso eine Kalendertabelle?

Falls Du Dir die Frage stellst, wozu Du eine solche Tabelle überhaupt benötigst und was die Folgen sein könnten, wenn Du sie nicht (so) in Dein Datenmodell integrierst, lies bitte meine zweiteilige Reihe zu Kalendertabellen in Power BI und Power Pivot. Danach solltest Du ein Verständnis dafür haben, warum Du sie benötigst.

Meine Kalendertabellenfunktion

Um nicht in jedem Projekt wieder mit der Erstellung einer neuen Kalendertabelle starten zu müssen, habe ich mir die am häufigsten auftretenden Business-Anforderungen an eine Kalendertabelle in einer entsprechenden M-Funktion gekapselt. Ich behaupte nicht, dass diese Funktion für jedes Projekt ausreichend ist. Aber sie bietet auf jeden Fall einen sehr guten Startpunkt und kann durch Dich natürlich entsprechend erweitert werden, wenn der Bedarf bestehen sollte. In den allermeisten meiner Projekte war die Funktion jedoch vollkommen ausreichend.

let

fn=(StartJahr, JahreInDieZukunft, optional Culture, optional StartFiskaljahr, optional Wochenstart )=>

let

/*

JahreInDieZukunft = 2,

StartJahr = 2017,

Culture = "de-de",

StartFiskaljahr = "Feb",

Wochenstart = "Di",

/

Heute = Date.From(DateTime.LocalNow()),

EndJahr = Date.Year(Date.From(DateTime.LocalNow())) + JahreInDieZukunft,

StartFiskJahr = if StartFiskaljahr = null then "Jan" else StartFiskaljahr,

GetStartDay = if StartFiskJahr = "Jan" then #date(StartJahr,1,1) else Date.FromText("01."&StartFiskJahr &Number.ToText(StartJahr)),

GetEndDay = if StartFiskJahr = "Jan" then #date(EndJahr,12,31) else Date.EndOfMonth( Date.AddMonths( Date.AddYears( Date.FromText("01."&StartFiskJahr &Number.ToText(EndJahr)), 1), -1) ),

GetCultureDefaultGermany = if Culture = null then "de-de" else Culture,

DayCount = Duration.Days(Duration.From(GetEndDay - GetStartDay)) + 1,

GetListOfDates = List.Dates(GetStartDay,DayCount,#duration(1,0,0,0)),

TableFromList = Table.FromList(GetListOfDates, Splitter.SplitByNothing()),

ChangedType = Table.TransformColumnTypes(TableFromList,{{"Column1", type date}}),

Date = Table.Buffer( Table.RenameColumns(ChangedType,{{"Column1", "Datum"}}) ),

#"AddFull date Description" = Table.AddColumn(Date, "Volle Datumsbezeichnung", each Date.ToText([Datum], "dd. MMMM yyyy", Culture), type text),

//================================================

ErmittleWochenstart =

if Wochenstart = null then

1

else

List.Select( {

[Tag="Mo", Wochenstart= Day.Monday],

[Tag="Di", Wochenstart= Day.Tuesday],

[Tag="Mi", Wochenstart= Day.Wednesday],

[Tag="Do", Wochenstart= Day.Thursday],

[Tag="Fr", Wochenstart= Day.Friday],

[Tag="Sa", Wochenstart= Day.Saturday],

[Tag="So", Wochenstart= Day.Sunday]

}, each _[Tag] = Wochenstart ){0}[Wochenstart] ,

//================================================

AddWeekDaySort = Table.AddColumn(#"AddFull date Description", "Tag der Woche #", each Date.DayOfWeek([Datum], ErmittleWochenstart) + 1, Int64.Type),

AddMonthDaySort = Table.AddColumn(AddWeekDaySort, "Tag des Monats #", each Date.Day([Datum]), Int64.Type),

#"Tag des Jahres eingefügt" = Table.AddColumn(AddMonthDaySort, "Tag des Jahres #", each Date.DayOfYear([Datum]), Int64.Type),

AddDayKey = Table.AddIndexColumn(#"Tag des Jahres eingefügt", "TagesKey #", 1, 1, Int64.Type),

AddDayName = Table.AddColumn(AddDayKey, "Name des Tages (TTTT)", each Date.DayOfWeekName([Datum], Culture), type text),

AddDaysName2digits = Table.AddColumn(AddDayName, "Name des Tages (TT)", each Date.ToText([Datum],"ddd", Culture), type text),

AddDaysName1digit = Table.AddColumn(AddDaysName2digits, "Name des Tages (T)", each Text.Start(Date.DayOfWeekName([Datum], Culture),1) & Text.Repeat(Character.FromNumber(8203), [#"Tag der Woche #"]), type text),

WT_WE_flag = Table.AddColumn(AddDaysName1digit, "Wochentags_Flag", each if [#"Tag der Woche #"] < 6 then "Weekday" else "Weekend", type text),

AddWeekOfYear = Table.AddColumn(WT_WE_flag, "Woche #", each Date.WeekOfYear([Datum]), Int64.Type),

#"Wochenbeginn eingefügt" = Table.AddColumn(AddWeekOfYear, "Woche Start", each Date.StartOfWeek([Datum]), type date),

#"Wochenende eingefügt" = Table.AddColumn(#"Wochenbeginn eingefügt", "Woche Ende", each Date.EndOfWeek([Datum]), type date),

AddYearWeek = Table.AddColumn(#"Wochenende eingefügt", "JahrWoche #", each Date.Year([Datum])100+[#"Woche #"], Int64.Type),

TableWeekKey = /List.Distinct(#"Geänderter Typ4"[YearWeek])/ Table.AddIndexColumn(Table.TransformColumnTypes(Table.RenameColumns(Table.FromList(List.Sort(List.Distinct(AddYearWeek[#"JahrWoche #"]),Order.Ascending), Splitter.SplitByNothing(), null, null, ExtraValues.Error),{{"Column1", "YearWeek"}}),{{"YearWeek", Int64.Type}}), "WeekKey #", 1, 1),

AddWeeKey = Table.NestedJoin(AddYearWeek,{"JahrWoche #"},TableWeekKey,{"YearWeek"},"WK",JoinKind.LeftOuter),

#"Expanded WK" = Table.ExpandTableColumn(AddWeeKey, "WK", {"WeekKey #"}, {"WochenKey #"}),

RemovedYearWeek = Table.RemoveColumns(#"Expanded WK",{"JahrWoche #"}),

AddKW_Jahr = Table.AddColumn(RemovedYearWeek, "Woche Jahr", each "KW"&Text.PadStart(Number.ToText([#"Woche #"]),2,"0") &" "&Number.ToText(Date.Year([Datum])), type text),

AddJahr_KW = Table.AddColumn(AddKW_Jahr, "Jahr Woche", each Number.ToText(Date.Year([Datum])) &" "&"KW"&Text.PadStart(Number.ToText([#"Woche #"]),2,"0"), type text),

fnGetIsoWeekNumber = (MyDate as date) =>

//Source --> https://blogs.office.com/en-us/2009/06/30/week-numbers-in-excel/

let

//MyDate = #date(2016,1,3),

Part1 = Number.From(MyDate) - Number.From(#date(Date.Year(Date.From(Number.From(MyDate) - (Date.DayOfWeek(Date.AddDays(MyDate,-1), Day.Sunday) + 1) + 4)),1,3)),

Part2 = Date.DayOfWeek(#date(Date.Year(Date.From(Number.From(MyDate) - (Date.DayOfWeek(Date.AddDays(MyDate,-1), Day.Sunday) +1) + 4)),1,3), Day.Sunday)+1 + 5,

ISOWeekNumber = Number.IntegerDivide(Part1 + Part2, 7)

in

ISOWeekNumber,

AddIsoWeek = Table.AddColumn(AddJahr_KW, "IsoKW #", each fnGetIsoWeekNumber([Datum]), Int64.Type),

AddIsoYear = Table.AddColumn(AddIsoWeek,"IsoJahr #",each Date.Year(Date.AddDays([Datum],3 - Date.DayOfWeek([Datum], 1))), Int64.Type),

AddIsoYear_IsoKW = Table.AddColumn(AddIsoYear, "IsoJahr IsoKW", each Text.From([#"IsoJahr #"]) & " KW" & Text.PadStart(Text.From([#"IsoKW #"]),2,"0") , type text),

AddIsoKW_IsoYear = Table.AddColumn(AddIsoYear_IsoKW, "IsoKW IsoJahr", each "KW" & Text.PadStart(Text.From([#"IsoKW #"]),2,"0") &" "&Text.From([#"IsoJahr #"]), type text),

GetIsoKalenderwochenKey = Table.AddIndexColumn( Table.Distinct( Table.SelectColumns(AddIsoKW_IsoYear, {"IsoJahr IsoKW"}), {"IsoJahr IsoKW"}), "IsoKWKey #", 1, 1),

AddIsoKalenderwochenKey = Table.AddJoinColumn(AddIsoKW_IsoYear, {"IsoJahr IsoKW"}, GetIsoKalenderwochenKey, {"IsoJahr IsoKW"}, "NEU"),

ExpandIsoKalenderwochenKey = Table.ExpandTableColumn(AddIsoKalenderwochenKey, "NEU", {"IsoKWKey #"}, {"IsoKWKey #"}),

AddMonthSort = Table.AddColumn(ExpandIsoKalenderwochenKey, "Monat #", each Date.Month([Datum]), Int64.Type),

AddMonthName = Table.AddColumn(AddMonthSort, "Monat (MMMM)", each Date.MonthName([Datum], Culture), type text),

AddMonthName3digits = Table.AddColumn(AddMonthName, "Monat (MMM)", each Date.ToText([Datum], "MMM", Culture), type text),

AddMonthName1digit = Table.AddColumn(AddMonthName3digits, "Monat (M)", each Text.Start(Date.MonthName([Datum], Culture),1) & Text.Repeat(Character.FromNumber(8203), [#"Monat #"]), type text),

AddMonthNameShort_Year = Table.AddColumn(AddMonthName1digit, "Monat (MMM) Jahr", each [#"Monat (MMM)"] &" "& Number.ToText(Date.Year([Datum])), type text),

#"AddJahr Monat (MMM)" = Table.AddColumn(AddMonthNameShort_Year, "Jahr Monat (MMM)", each Number.ToText(Date.Year([Datum])) &" "&[#"Monat (MMM)"], type text),

AddYearMonth = Table.TransformColumnTypes(Table.AddColumn(#"AddJahr Monat (MMM)", "JahrMonat #", each Date.Year([Datum])100 + [#"Monat #"]),{{"JahrMonat #", Int64.Type}}),

TableYearMonth = Table.AddIndexColumn(Table.TransformColumnTypes(Table.RenameColumns(Table.FromList(List.Sort(List.Distinct(AddYearMonth[#"JahrMonat #"]),Order.Ascending), Splitter.SplitByNothing(), null, null, ExtraValues.Error),{{"Column1", "YearMonth"}}),{{"YearMonth", Int64.Type}}), "YearMonthKey", 1, 1),

#"Zusammenführte Abfragen" = Table.NestedJoin(AddYearMonth,{"JahrMonat #"},TableYearMonth,{"YearMonth"},"MK",JoinKind.LeftOuter),

#"Erweiterte MK" = Table.ExpandTableColumn(#"Zusammenführte Abfragen", "MK", {"YearMonthKey"}, {"MonatKey #"}),

#"Entfernte Spalten1" = Table.RemoveColumns(#"Erweiterte MK",{"JahrMonat #"}),

AddSoM = Table.AddColumn(#"Entfernte Spalten1", "Monatsbeginn", each Date.StartOfMonth([Datum]), type date),

AddEoM = Table.AddColumn(AddSoM, "Monatsende", each Date.EndOfMonth([Datum]), type date),

AddQuarter = Table.AddColumn(AddEoM, "Quartal #", each Date.QuarterOfYear([Datum]), Int64.Type),

AddQuarterName = Table.AddColumn(AddQuarter, "Quartal", each "Q" & Number.ToText([#"Quartal #"]), type text),

AddQuartal_Jahr = Table.AddColumn(AddQuarterName, "Quartal Jahr", each "Q"&Number.ToText([#"Quartal #"]) &"-"&Number.ToText(Date.Year([Datum])), type text),

AddJahr_Quartal = Table.AddColumn(AddQuartal_Jahr, "Jahr Quartal", each Number.ToText(Date.Year([Datum])) & "-Q" & Number.ToText([#"Quartal #"]), type text),

AddYearQuarter = Table.AddColumn(AddJahr_Quartal, "Jahr Quartal #", each Date.Year([Datum]) 100 + [#"Quartal #"], Int64.Type),

TableYearQuarter = Table.AddIndexColumn(Table.TransformColumnTypes(Table.RenameColumns(Table.FromList(List.Sort(List.Distinct(#"AddYearQuarter"[#"Jahr Quartal #"]),Order.Ascending), Splitter.SplitByNothing(), null, null, ExtraValues.Error),{{"Column1", "YearQuarter"}}),{{"YearQuarter", Int64.Type}}), "QuartalKey", 1, 1),

GetQuartalKey = Table.NestedJoin(AddYearQuarter,{"Jahr Quartal #"},TableYearQuarter,{"YearQuarter"},"QK",JoinKind.LeftOuter),

AddQuartalKey = Table.ExpandTableColumn(GetQuartalKey, "QK", {"QuartalKey"}, {"QuartalKey #"}),

#"Entfernte Spalten" = Table.RemoveColumns(AddQuartalKey,{"Jahr Quartal #"}),

AddHalfYearSort = Table.TransformColumnTypes(Table.AddColumn(#"Entfernte Spalten", "Halbjahr #", each if Date.Month([Datum]) < 7 then 1 else 2),{{"Halbjahr #", Int64.Type}}),

AddHalfYearName = Table.AddColumn(AddHalfYearSort, "Halbjahr", each "HJ " & Number.ToText([#"Halbjahr #"]), type text),

AddHalbjahr_Jahr = Table.AddColumn(AddHalfYearName, "Halbjahr Jahr", each "HJ "&Number.ToText([#"Halbjahr #"])&"-"&Number.ToText(Date.Year([Datum])), type text),

#"Hinzugefügte benutzerdefinierte Spalte3" = Table.AddColumn(AddHalbjahr_Jahr, "Jahr Halbjahr", each Number.ToText(Date.Year([Datum]))&"-"& "HJ "&Number.ToText([#"Halbjahr #"]), type text),

AddYearHalfYear = Table.TransformColumnTypes(Table.AddColumn(#"Hinzugefügte benutzerdefinierte Spalte3", "JahrHalbjahr #", each Date.Year([Datum])100+[#"Halbjahr #"]),{{"JahrHalbjahr #", Int64.Type}}),

TableYearHalfYear = Table.AddIndexColumn(Table.TransformColumnTypes(Table.RenameColumns(Table.FromList(List.Sort(List.Distinct(AddYearHalfYear[#"JahrHalbjahr #"]),Order.Ascending), Splitter.SplitByNothing(), null, null, ExtraValues.Error),{{"Column1", "YearHalfYear"}}),{{"YearHalfYear", Int64.Type}}), "HalfYearKey", 1, 1),

GetHalfYearKey = Table.NestedJoin(AddYearHalfYear,{"JahrHalbjahr #"},TableYearHalfYear,{"YearHalfYear"},"HYK",JoinKind.LeftOuter),

AddHalfYearKey = Table.ExpandTableColumn(GetHalfYearKey, "HYK", {"HalfYearKey"}, {"HalbjahrKey #"}),

#"Entfernte Spalten4" = Table.RemoveColumns(AddHalfYearKey,{"JahrHalbjahr #"}),

AddYear = Table.AddColumn(#"Entfernte Spalten4", "Jahr #", each Date.Year([Datum]), Int64.Type),

AddJahrKey = Table.AddColumn(AddYear, "JahrKey #", each [#"Jahr #"] - List.Min(AddYear[#"Jahr #"]) + 1, Int64.Type),

IsLeapYear = Table.Buffer( Table.TransformColumnTypes(Table.AddColumn(AddJahrKey, "Schaltjahr", each Number.From( Date.IsLeapYear( [Datum] ))),{{"Schaltjahr", Int64.Type}}) ),

fnKeysTodayRecord =

let

TabelleAufHeuteFiltern = Table.SelectRows(IsLeapYear, each _[Datum] = Heute),

Output =

[

TagesKeyHeute = TabelleAufHeuteFiltern[#"TagesKey #"]{0},

WochenKeyHeute = TabelleAufHeuteFiltern[#"WochenKey #"]{0},

IsoKWHeute = TabelleAufHeuteFiltern[#"IsoKWKey #"]{0},

MonatKeyHeute = TabelleAufHeuteFiltern[#"MonatKey #"]{0},

QuartalKeyHeute = TabelleAufHeuteFiltern[#"QuartalKey #"]{0},

HalbjahrKeyHeute = TabelleAufHeuteFiltern[#"HalbjahrKey #"]{0},

JahrKeyHeute = TabelleAufHeuteFiltern[#"JahrKey #"]{0}

]

in

Output,

AddRelativerTag = Table.AddColumn(IsLeapYear, "Relativer Tag #", each [#"TagesKey #"] - fnKeysTodayRecord[TagesKeyHeute], Int64.Type),

AddRelativeWoche = Table.AddColumn(AddRelativerTag, "Relative Woche #", each [#"WochenKey #"] - fnKeysTodayRecord[WochenKeyHeute], Int64.Type),

AddRelativeIsoWoche = Table.AddColumn(AddRelativeWoche, "Relative IsoWoche #", each [#"IsoKWKey #"] - fnKeysTodayRecord[IsoKWHeute], Int64.Type),

AddRelativerMonat = Table.AddColumn(AddRelativeIsoWoche, "Relativer Monat #", each [#"MonatKey #"] - fnKeysTodayRecord[MonatKeyHeute], Int64.Type),

AddRelativesQuartal = Table.AddColumn(AddRelativerMonat, "Relatives Quartal #", each [#"QuartalKey #"] - fnKeysTodayRecord[QuartalKeyHeute], Int64.Type),

AddRelativesHalbjahr = Table.AddColumn(AddRelativesQuartal, "Relatives Halbjahr #", each [#"HalbjahrKey #"] - fnKeysTodayRecord[HalbjahrKeyHeute], Int64.Type),

AddRelativesJahr = Table.AddColumn(AddRelativesHalbjahr, "Relatives Jahr #", each [#"JahrKey #"] - fnKeysTodayRecord[JahrKeyHeute], Int64.Type),

//2Go-Ermittlung

ListGetWeek2Go = List.Buffer( Table.SelectRows(AddRelativesJahr, each [#"Relative Woche #"] = 0 and [Datum] > Heute)[Datum] ),

ListGetIsoWeek2Go = List.Buffer( Table.SelectRows(AddRelativesJahr, each [#"Relative IsoWoche #"] = 0 and [Datum] > Heute)[Datum] ),

ListGetMonth2Go = List.Buffer( Table.SelectRows(AddRelativesJahr, each [#"Relativer Monat #"] = 0 and [Datum] > Heute)[Datum] ),

ListGetQuarter2Go = List.Buffer( Table.SelectRows(AddRelativesJahr, each [#"Relatives Quartal #"] = 0 and [Datum] > Heute)[Datum] ),

ListGetHalfYear2Go = List.Buffer( Table.SelectRows(AddRelativesJahr, each [#"Relatives Halbjahr #"] = 0 and [Datum] > Heute)[Datum] ),

ListGetYear2Go = List.Buffer( Table.SelectRows(AddRelativesJahr, each [#"Relatives Jahr #"] = 0 and [Datum] > Heute)[Datum] ),

AddCol_Woche2Go = Table.AddColumn( AddRelativesJahr, "Woche 2 Go", each Number.From( List.Contains(ListGetWeek2Go, [Datum]) ), Int64.Type),

AddCol_IsoWoche2Go = Table.AddColumn( AddCol_Woche2Go, "IsoWoche 2 Go", each Number.From( List.Contains(ListGetIsoWeek2Go, [Datum]) ), Int64.Type),

AddCol_Monat2Go = Table.AddColumn( AddCol_IsoWoche2Go, "Monat 2 Go", each Number.From( List.Contains(ListGetMonth2Go, [Datum]) ), Int64.Type),

AddCol_Quartal2Go = Table.AddColumn( AddCol_Monat2Go, "Quartal 2 Go", each Number.From( List.Contains(ListGetQuarter2Go, [Datum]) ), Int64.Type),

AddCol_Halbjahr2Go = Table.AddColumn( AddCol_Quartal2Go, "Halbjahr 2 Go", each Number.From( List.Contains(ListGetHalfYear2Go, [Datum]) ), Int64.Type),

AddCol_Jahr2Go = Table.AddColumn( AddCol_Halbjahr2Go, "Jahr 2 Go", each Number.From( List.Contains(ListGetYear2Go, [Datum]) ), Int64.Type),

//==============================================================================Fiskaljahresberechnungen=================================================================

GetStartMonatsnummerFiskaljahr = List.PositionOf({"Jan", "Feb", "Mrz", "Apr", "Mai", "Jun", "Jul", "Aug", "Sep", "Okt", "Nov", "Dez"}, StartFiskJahr ) + 1,

AddFiscalYear = Table.AddColumn(AddCol_Jahr2Go, "Fiskaljahr #", each if Date.Month([Datum]) < GetStartMonatsnummerFiskaljahr then Date.Year([Datum]) else Date.Year([Datum]) + 1

, Int64.Type),

#"Hinzugefügte benutzerdefinierte Spalte" = Table.AddColumn(AddFiscalYear, "Fiskaljahr", each if Date.Month([Datum]) < GetStartMonatsnummerFiskaljahr then "FJ " & Number.ToText(Date.Year([Datum])) else "FJ " & Number.ToText(Date.Year([Datum]) + 1), type text),

#"AddFiscalDay#" = Table.AddColumn(#"Hinzugefügte benutzerdefinierte Spalte", "Fiskaltag #", each

[

FJStart = Date.FromText(StartFiskaljahr &" "& Number.ToText([#"Fiskaljahr #"] - 1)),

FJEnde = Date.AddDays(Date.AddMonths(FJStart, 12), -1),

ListOfFiscalDates = List.Buffer( List.Transform( {Number.From(FJStart)..Number.From(FJEnde)}, each Date.From(_)) ),

Position = List.PositionOf(ListOfFiscalDates, [Datum]) + 1

][Position], type number),

#"AddFiscalMonth#" = Table.AddColumn(#"AddFiscalDay#", "Fiskalmonat #", each if ( Date.Month([Datum]) >= GetStartMonatsnummerFiskaljahr) then Date.Month([Datum]) - GetStartMonatsnummerFiskaljahr +1

else

Date.Month([Datum])+13-GetStartMonatsnummerFiskaljahr, Int64.Type),

AddFiskalmonat_MMMM = Table.AddColumn(#"AddFiscalMonth#", "Fiskalmonat (MMMM)", each Date.MonthName([Datum]), type text),

Add_Fiskalmonat_MMM = Table.AddColumn(AddFiskalmonat_MMMM, "Fiskalmonat (MMM)", each Date.ToText([Datum], "MMM", Culture), type text),

AddFiskalmonat_MM = Table.AddColumn(Add_Fiskalmonat_MMM, "Fiskalmonat (M)", each Text.Start(Date.MonthName([Datum], Culture),1) & Text.Repeat(Character.FromNumber(8203), [#"Monat #"]), type text),

Add_FiskalQuartal = Table.TransformColumnTypes(Table.AddColumn(AddFiskalmonat_MM, "Fiskalquartal #", each Number.RoundUp([#"Fiskalmonat #"]/3 ,0)), {{"Fiskalquartal #", Int64.Type}}),

#"Hinzugefügte benutzerdefinierte Spalte1" = Table.AddColumn(Add_FiskalQuartal, "Fiskalquartal", each "FQ " & Number.ToText([#"Fiskalquartal #"]), type text),

#"Hinzugefügte benutzerdefinierte Spalte2" = Table.AddColumn(#"Hinzugefügte benutzerdefinierte Spalte1", "Fiskalquartal Fiskaljahr", each [Fiskalquartal]&"-FJ "&Number.ToText([#"Fiskaljahr #"]), type text),

AddFiscalYearQuarterName = Table.AddColumn(#"Hinzugefügte benutzerdefinierte Spalte2", "Fiskaljahr Fiskalquartal", each "FJ "&Text.From([#"Fiskaljahr #"]) &"-FQ" & Text.From([#"Fiskalquartal #"]), type text),

AddFiscalYearQuarter = Table.AddColumn(AddFiscalYearQuarterName, "Fiskal_JahrQuartal", each [#"Fiskaljahr #"] 100 + [#"Fiskalquartal #"], Int64.Type),

TableFiscalYearQuarter = Table.AddIndexColumn(Table.TransformColumnTypes(Table.RenameColumns(Table.FromList(List.Sort(List.Distinct(#"AddFiscalYearQuarter"[#"Fiskal_JahrQuartal"]),Order.Ascending), Splitter.SplitByNothing(), null, null, ExtraValues.Error),{{"Column1", "Fiscal_YearQuarter"}}),{{"Fiscal_YearQuarter", Int64.Type}}), "Fiskal_QuartalKey", 1, 1),

GetFiscalYearQuarterKey = Table.NestedJoin(AddFiscalYearQuarter,{"Fiskal_JahrQuartal"},TableFiscalYearQuarter,{"Fiscal_YearQuarter"},"FYQ",JoinKind.LeftOuter),

#"Erweiterte FYQ" = Table.ExpandTableColumn(GetFiscalYearQuarterKey, "FYQ", {"Fiskal_QuartalKey"}, {"FiskalQuartalKey #"}),

#"Entfernte Spalten2" = Table.RemoveColumns(#"Erweiterte FYQ",{"Fiskal_JahrQuartal"}),

AddFiscalHalfYear = Table.TransformColumnTypes(Table.AddColumn(#"Entfernte Spalten2", "Fiskalhalbjahr #", each if [#"Fiskalmonat #"]<7 then 1 else 2), {{"Fiskalhalbjahr #", Int64.Type}}),

AddFiscalHalfYearName = Table.AddColumn(AddFiscalHalfYear, "Fiskalhalbjahr", each "FHJ " & Number.ToText([#"Fiskalhalbjahr #"]), type text),

AddFiscalYearHalfYearName = Table.AddColumn(AddFiscalHalfYearName, "Fiskaljahr Fiskalhalbjahr", each "FJ " &Text.From([#"Fiskaljahr #"]) & "-FHJ" & Text.From([#"Fiskalhalbjahr #"]), type text),

#"Hinzugefügte benutzerdefinierte Spalte4" = Table.AddColumn(AddFiscalYearHalfYearName, "Fiskalhalbjahr Fiskaljahr", each "FHJ " & Text.From([#"Fiskalhalbjahr #"])&"-FJ " &Text.From([#"Fiskaljahr #"]), type text),

AddFiscalYearHalfYear = Table.AddColumn(#"Hinzugefügte benutzerdefinierte Spalte4", "Fiskal_JahrHalbjahr", each [#"Fiskaljahr #"] * 100 + [#"Fiskalhalbjahr #"], Int64.Type),

TableFiscalYearHalfYear = Table.AddIndexColumn(Table.TransformColumnTypes(Table.RenameColumns(Table.FromList(List.Sort(List.Distinct(#"AddFiscalYearHalfYear"[Fiskal_JahrHalbjahr]),Order.Ascending), Splitter.SplitByNothing(), null, null, ExtraValues.Error),{{"Column1", "Fiscal_YearHalfYear"}}),{{"Fiscal_YearHalfYear", Int64.Type}}), "Fiskal_HalbjahresKey", 1, 1),

GetFiscalYearHalfYearKey = Table.NestedJoin(AddFiscalYearHalfYear,{"Fiskal_JahrHalbjahr"},TableFiscalYearHalfYear,{"Fiscal_YearHalfYear"},"FYHY",JoinKind.LeftOuter),

#"Erweiterte FYHY" = Table.ExpandTableColumn(GetFiscalYearHalfYearKey, "FYHY", {"Fiskal_HalbjahresKey"}, {"FiskalhalbjahresKey #"}),

AddFiscalYearKey = Table.AddColumn(#"Erweiterte FYHY", "FiskalJahresKey #", each [#"Fiskaljahr #"] - List.Min(#"Erweiterte FYHY"[#"Fiskaljahr #"]) + 1, Int64.Type),

#"Entfernte Spalten3" = Table.RemoveColumns(AddFiscalYearKey,{"Fiskal_JahrHalbjahr"}),

fnKeysTodayRecordFiscal =

let

TabelleAufHeuteFiltern = Table.SelectRows(#"Entfernte Spalten3", each _[Datum] = Heute),

Output =

[

FiscalQuartalKeyHeute = TabelleAufHeuteFiltern[#"FiskalQuartalKey #"]{0},

FiskalHalbjahrKeyHeute = TabelleAufHeuteFiltern[#"FiskalhalbjahresKey #"]{0},

FiskalJahrKeyHeute = TabelleAufHeuteFiltern[#"FiskalJahresKey #"]{0}

]

in

Output,

//Relative Fiscal-Einheiten

AddRelativesFiskalQuartal = Table.AddColumn(#"Entfernte Spalten3", "Relatives FiskalQuartal #", each [#"FiskalQuartalKey #"] - fnKeysTodayRecordFiscal[FiscalQuartalKeyHeute], Int64.Type),

AddRelativesFiskalHalbjahr = Table.AddColumn(AddRelativesFiskalQuartal, "Relatives FiskalHalbjahr #", each [#"FiskalhalbjahresKey #"] - fnKeysTodayRecordFiscal[FiskalHalbjahrKeyHeute], Int64.Type),

AddRelativesFiskalJahr = Table.AddColumn(AddRelativesFiskalHalbjahr, "Relatives FiskalJahr #", each [#"FiskalJahresKey #"] - fnKeysTodayRecordFiscal[FiskalJahrKeyHeute], Int64.Type),

//2Go-Ermittlung

ListGetFiscalQuarter2Go = List.Buffer( Table.SelectRows(AddRelativesFiskalJahr, each [#"Relatives FiskalQuartal #"] = 0 and [Datum] > Heute)[Datum] ),

ListGetFiscalHalfYear2Go = List.Buffer( Table.SelectRows(AddRelativesFiskalJahr, each [#"Relatives FiskalHalbjahr #"] = 0 and [Datum] > Heute)[Datum] ),

ListGetFiscalYear2Go = List.Buffer( Table.SelectRows(AddRelativesFiskalJahr, each [#"Relatives FiskalJahr #"] = 0 and [Datum] > Heute)[Datum] ),

AddCol_FiskalQuartal2Go = Table.AddColumn( AddRelativesFiskalJahr, "FiskalQuartal 2 Go", each Number.From( List.Contains(ListGetFiscalQuarter2Go, [Datum]) ), Int64.Type),

AddCol_FiskalHalbJahr2Go = Table.AddColumn( AddCol_FiskalQuartal2Go, "FiskalHalbjahr 2 Go", each Number.From( List.Contains(ListGetFiscalHalfYear2Go, [Datum]) ), Int64.Type),

AddCol_FiskalJahr2Go = Table.AddColumn( AddCol_FiskalHalbJahr2Go, "FiskalJahr 2 Go", each Number.From( List.Contains(ListGetFiscalYear2Go, [Datum]) ), Int64.Type),

//==============================================================================Fiskaljahresberechnungen=================================================================

Output = if StartFiskJahr = "Jan" then AddCol_Jahr2Go else AddCol_FiskalJahr2Go

in

Output

,

fnType = type function(

StartJahr as number,

JahreInDieZukunft as number,

optional Culture as (type text meta [Documentation.AllowedValues={"de-de", "en-US", "fr-FR", "es-ES"}]),

optional StartFiskaljahr as (type text meta[Documentation.AllowedValues={"Jan", "Feb", "Mrz", "Apr", "Mai", "Jun", "Jul", "Aug", "Sep", "Okt", "Nov", "Dez"}]),

optional Wochenstart as (type text meta[Documentation.AllowedValues={"Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"}])

) as table meta [

Documentation.Name="fnCalendar (von Lars Schreiber --> ssbi-blog.de)",

Documentation.LongDescription="Diese Funktion erstellt eine Kalendertabelle, angelehnt an den Vorschlägen der Kimball-Group.",

Documentation.Author="Lars Schreiber, ssbi-blog.de",

Documentation.Examples=

{[

Description = "Gibt eine Kalendertabelle zurück, die in 2019 beginnt und ausgehend vom aktuellen Jahr automatisch um ein Jahr in die Zukunft mitwächst.",

Code = "fnKalender(2019, 1, null, null, null)",

Result =""

],[

Description = "Gibt eine Kalendertabelle zurück, die in 2019 beginnt und ausgehend vom aktuellen Jahr automatisch um ein Jahr in die Zukunft mitwächst. Es werden weitere Spalten integriert, die der Logik einer Fiskaljahres entsprechen, das im Juli beginnnt und im Juni des Folgejahres endet.",

Code = "fnKalender(2019, 1, null, ""Jul"", null)",

Result =""

]}

]

in

Value.ReplaceType(fn, fnType)

view raw fnKalender.pq hosted with by GitHub

Falls Du wissen möchtest, wie Du eine Funktion in Power BI wiederverwendest, findest Du hier eine kurze Anleitung dazu. Als nächstes möchte ich ein paar Worte zu den Parametern dieser Funktion verlieren.

Parameter

Um die Kalendertabelle erstellen zu können, benötigt meine Funktion ein paar wenige Parameter. Diese unterscheiden sich in notwendige und optionale Parameter.

Notwendige Parameter

In meiner oben erwähnten Reihe zu Kalendertabellen in Power BI habe ich detailliert die Ansprüche an eine solche Tabelle herausgearbeitet. Kurz zusammengefasst benötigt eine Kalendertabelle zwingend eine Spalte vom Typ Datum, die lückenlos – möglichst für komplette Jahre – genau einen Eintrag pro Kalendertag aufweist. Dies berücksichtigt meine Funktion und benötigt daher das StartJahr. Da sich Kalendertabellen bei fortschreitenden Jahren in der Regel an diese anpassen sollen, fragt der zweite Parameter JahreInDieZukunft danach, wie viele Jahre die Kalendertabelle – ausgehend vom Kalenderjahr des heutigen Tages – in die Zukunft gehen soll. Falls Dein Datenmodell also Budgetwerte für die kommenden 3 Jahre beinhaltet, sollte dieser Parameter 3 lauten. Beide Parameter werden als Ganzzahl übergeben. Hieraus wird eine Tabelle erzeugt, die vom 1. Januar des Startjahres bis zum 31. Dezember des Endjahres (=aktuelles Jahr + JahreInDieZukunft) geht.

Neben diesen beiden notwendigen Parametern, kann meine Funktion 2 weitere Parameter verarbeiten, die für die Funktionsweise jedoch nicht essentiell sind, weil sie nicht in jedem Projekt benötigt werden.

Optionale Parameter

Die optionalen Parameter sind für Sonderfälle gedacht, die nicht in jedem Projekt eine Rolle spielen. Hierbei handelt es sich um die Möglichkeit die sog. Culture von Deutsch auf eine andere Sprache zu ändern und ein eventuell vom Kalenderjahr abweichendes Geschäftsjahr zu berücksichtigen.

Culture (optional)

In der Programmiersprache M gibt es diverse Funktionen, die einen Parameter Culture akzeptieren. Für meine Kalendertabelle ist das für Textspalten sinnvoll. So kann ich über die Auswahl der Culture „en-US“ definieren, dass Tagesnamen und Monatsnamen auf Englisch abgebildet werden und nicht auf Deutsch. Meine Funktion bietet die Möglichkeit zwischen Deutsch („de-de“), Englisch („en-US“), Französisch („fr-FR“) und Spanisch („es-ES“) zu wählen. Die Integration weiterer Sprachen ist auf Basis der hier abgebildeten Auflistung von Cultures jedoch problemlos möglich. Wichtig ist es an dieser Stelle zu bemerken, dass sich die Culture lediglich auf den Inhalt der Spalten, nicht aber auf die Spaltenüberschriften auswirkt. Eine Mehrsprachigkeit meines Datenmodells kann ich hierüber nicht erzielen.

StartFiskaljahr (optional)

Nicht jedes Geschäftsjahr beginnt mit dem 01. Januar. Bei Microsoft ist der Geschäftsjahresanfang beispielsweise der 01. Juli eines Jahres. Dies führt dazu, dass der Januar des Jahres 2021 , der 7. Monat im Geschäftsjahr 2020 von Microsoft ist, obwohl es sich ja um das Kalenderjahr 2021 handelt. Sofern ich diese Logik in einem Kundenprojekt benötigt, kann ich den Startmonat des Geschäftsjahres mit angeben und bekomme ausschließlich dann weitere Spalten in meiner Kalendertabelle hinzugefügt, die diese Logik integrieren.

Kalendertabelle bei vom Kalenderjahr abweichendem Fiskaljahr, Power BI, Power Pivot — Kalendertabelle bei vom Kalenderjahr abweichendem Fiskaljahr

Solche Logiken können beispielsweise nützlich für die Sortierung von Monatsnamen in Slicern oder anderen Visualisierungen sein (man würde im genannten Fall vermutlich wollen, dass der erste Monat im Slicer der Juli ist und der letzte der Juni). Aber natürlich auch für die Nutzung in Time-Intelligence-Funktionen in DAX kann eine solche Tabelle sehr nützlich sein.

Erläuterungen zu den verschiedenen Spalten

Alle Spalten innerhalb der Tabelle habe ich – zumindest für meinen Begriff – sprechend benannt. Erklärungsbedürftig könnten dennoch die Spalten mit den Suffixen “ #“ und speziell „Key #“ sein.

“ #“-Spalten

Alle Spalten, die eine Raute „#“ aufweisen, sind nummerische Spalten. Der Unterschied zwischen den Spalten „Quartal“ und „Quartal #“ ist, dass das Quartal mit „Q1“ bis „Q4“ vom Typ Text ist und, die Spalte „Quartal #“ mit 1 bis 4 vom Typ Zahl ist. Nummerische Spalten können zum Rechnen in DAX-Ausdrücken benutzt werden, aber auch, um andere Textspalten danach zu sortieren. Hierfür stelle ich weiter unten ein C#-Skript zur Verfügung, das Du mit dem externen Tool Tabular Editor nutzen kannst, um Dir das Leben zu erleichtern.

Nummerische und Text-Versionen einer Spalte, Power BI, Power Pivot — Nummerische und Text-Versionen einer Spalte

„Key #“-Spalten

Time-Intelligence-Funktionalitäten sind eine geniale Sache in DAX. Einfach TOTALYTD() zu nutzen, um zur Laufzeit einen Year-to-date-Wert zu kalkulieren, ist großartig. Manchmal muss ich jedoch eigene TI-Funktionen in DAX schreiben, weil die Standardfunktionen das so nicht anbieten. Dies trifft beispielsweise zu, wenn ich mit Iso-Kalenderwochen arbeite. Um hier auch jahresübergreifend auf Vorwochen zugreifen zu können, gibt es die Spalte „IsoKWKey“, mit der z. B. folgendes Measure möglich wäre:

Umsatz Vorwoche =
CALCULATE (
    SUM ( Fact[Umsatz] ),
    FILTER (
        ALL ( Kalender ),
        Kalender[IsoKWKey]
            = MAX ( Kalender[IsoKWKey] ) – 1
    )
)

Diese „Key #“-Spalten sollten dem Berichtsersteller eher vorenthalten werden, weil es rein technische Spalten für die Erstellung von Measures oder das Sortieren von Textspalten sind.

„Relative #“-Spalten

Häufig wird in Projekte gefordert, einen Filtern in einen Bericht einzubauen, der dafür sorgt, dass mir alle Daten immer für den aktuellen Tag, die aktuelle Woche, den aktuellen Monat, das aktuelle Jahr usw. angezeigt werden, sobald die Daten aktualisiert sind. Marcus Wegener gab mir den Tipp, hier doch relative Spalten einzubauen, die mich auch den gestrigen Tag ([Relativer Tag #] = -1) oder das vorletzte Quartal ([Relatives Quartal #] = -2) auswählen lassen. Der folgende Screenshot zeigt, dass der 12.09.2022 der heutige Tag ist (an diesem aktualisiere ich diesen Artikel) und davon ausgehend die Vergangenheit mit negativen Zahlen und die Zukunft mit positiven Zahlen gekennzeichnet ist.

Relative Zeitbezüge machen die Selektion von relativen Tagen (z. B. heute oder gestern) in Power BI-Berichten möglich

Ein C#-Skript für Tabular Editor zur automatischen Integration der Kalendertabelle ins Datenmodell

Um das Sortieren von Textspalten, das Ausblenden von Key-Spalten und das Nicht-Aggregieren von nummerischen Spalten nicht von Hand einstellen zu müssen, habe ich ein Skript geschrieben, dass dies in Tabular Editor für Dich automatisiert umsetzt.

	var Kalender_Tabelle = "Kalender";

	//Alle Spalten der Kalendertabelle durchlaufen
	foreach( var col in Model.Tables[Kalender_Tabelle].Columns)

	{
	//Nummerische Spalten nicht aggregieren
	col.SummarizeBy = AggregateFunction.None;

	//Spalten mit Endung "Key #" ausblenden... reinn technische Spalten
	if(col.Name.EndsWith("Key #")) {col.IsHidden = true;}
	}

	//Sort by Column-Eigenschaft einstellen

	//Volle Datumsbezeichnung nach Datum soriteren
	Model.Tables[Kalender_Tabelle].Columns["Volle Datumsbezeichnung"].SortByColumn = Model.Tables[Kalender_Tabelle].Columns["Datum"];

	//Name des Tages sortieren
	Model.Tables[Kalender_Tabelle].Columns["Name des Tages (TTTT)"].SortByColumn = Model.Tables[Kalender_Tabelle].Columns["Tag der Woche #"];
	Model.Tables[Kalender_Tabelle].Columns["Name des Tages (TT)"].SortByColumn = Model.Tables[Kalender_Tabelle].Columns["Tag der Woche #"];
	Model.Tables[Kalender_Tabelle].Columns["Name des Tages (T)"].SortByColumn = Model.Tables[Kalender_Tabelle].Columns["Tag der Woche #"];

	//Woche sortieren
	Model.Tables[Kalender_Tabelle].Columns["Woche Jahr"].SortByColumn = Model.Tables[Kalender_Tabelle].Columns["WochenKey #"];
	Model.Tables[Kalender_Tabelle].Columns["Jahr Woche"].SortByColumn = Model.Tables[Kalender_Tabelle].Columns["WochenKey #"];

	//IsoWoche sortieren
	Model.Tables[Kalender_Tabelle].Columns["IsoJahr IsoKW"].SortByColumn = Model.Tables[Kalender_Tabelle].Columns["IsoKWKey #"];
	Model.Tables[Kalender_Tabelle].Columns["IsoKW IsoJahr"].SortByColumn = Model.Tables[Kalender_Tabelle].Columns["IsoKWKey #"];

	//Monate sortieren
	Model.Tables[Kalender_Tabelle].Columns["Monat (MMMM)"].SortByColumn = Model.Tables[Kalender_Tabelle].Columns["Monat #"];
	Model.Tables[Kalender_Tabelle].Columns["Monat (MMM)"].SortByColumn = Model.Tables[Kalender_Tabelle].Columns["Monat #"];
	Model.Tables[Kalender_Tabelle].Columns["Monat (M)"].SortByColumn = Model.Tables[Kalender_Tabelle].Columns["Monat #"];
	Model.Tables[Kalender_Tabelle].Columns["Monat (MMM) Jahr"].SortByColumn = Model.Tables[Kalender_Tabelle].Columns["MonatKey #"];
	Model.Tables[Kalender_Tabelle].Columns["Jahr Monat (MMM)"].SortByColumn = Model.Tables[Kalender_Tabelle].Columns["MonatKey #"];

	//-->Falls kein Fiskaljahr vorliegt, ab hier bitte den Code entfernen
	//Fiskalmonat sortieren
	Model.Tables[Kalender_Tabelle].Columns["Fiskalmonat (MMMM)"].SortByColumn = Model.Tables[Kalender_Tabelle].Columns["Fiskalmonat #"];
	Model.Tables[Kalender_Tabelle].Columns["Fiskalmonat (MMM)"].SortByColumn = Model.Tables[Kalender_Tabelle].Columns["Fiskalmonat #"];
	Model.Tables[Kalender_Tabelle].Columns["Fiskalmonat (M)"].SortByColumn = Model.Tables[Kalender_Tabelle].Columns["Fiskalmonat #"];

view raw TE_Kalendertabelle.csx hosted with

by GitHub

Wie Du das Skript nutzen kannst, zeige ich Dir in meine Erklärvideo.

Du willst Power Query von Grund auf lernen?

Dann ist mein Videokurs für Einsteiger genau richtig für dich:
Über 160 Videos
Mehr als 13 Stunden Laufzeit
Verständlich. Praxisnah. Auf Deutsch.
Alles ohne Programmierung

Mein Erklärvideo

Sie sehen gerade einen Platzhalterinhalt von YouTube. Um auf den eigentlichen Inhalt zuzugreifen, klicken Sie auf die Schaltfläche unten. Bitte beachten Sie, dass dabei Daten an Drittanbieter weitergegeben werden.

Mehr Informationen

Inhalt entsperren Erforderlichen Service akzeptieren und Inhalte entsperren

Ich hoffe meine Tabelle ist Dir eine Hilfe. Wenn Du weitere Ideen hast, die in diese Tabelle integriert werden sollten, schick mir gerne eine Mail und ich sehe, was ich tun kann

Bis zum nächsten Mal und denk dran: Sharing is caring. Wenn Dir der Beitrag gefallen hat, dann teile ihn gerne. Falls Du Anmerkungen hast, schreibe gerne einen Kommentar, oder schicke mir eine Mail an lars@ssbi-blog.de

Viele Grüße aus Hamburg,

Lars

Lars Schreiber

Lars ist Berater, Entwickler und Trainer für Microsoft Power BI. Er ist zertifizierter Power BI-Experte und Microsoft Trainer. Für sein Engagement in der internationalen Community wurde Lars seit 2017 jährlich durch Microsoft der MVP-Award verliehen. Lies hier mehr…

Kommentare

Stefan H. meint

17. März 2025 um 8:32 am

Hallo,
vielen Dank für die prima Kalendertabellenfunktion. Ist bei mir zum Standard geworden.
Mir ist aufgefallen, dass der „Fiskalmonat (MMMM)“ unberührt von der eingestellten Culture auf Deutsch bleibt. Ich dachte bevor ich bei mir lokal versuche, den Code zu berichtigen, wäre es sinnvoller, dies an Dich zurückzumelden.
Grüße,
Stefan
P.S. Wäre noch möglich, die Verarbeitung der Variablen ‚StartFiskaljahr‘ und ‚Wochenstart‘ so anzupassen, dass auch englische Bezeichnungen erkannt würden? Also z.B. „Mar“ statt „Mrz“ oder „Tue“ statt „Di“ und „Wed“ statt „Mi“?
Moritz meint

25. November 2024 um 12:34 pm

Hallo Lars,

Danke für die Arbeit und die Kalendertabelle (ich musste auch erst mal, wie Robert Unterdorfer suchen, wo ich sie finden kann)…

Zwei weitere Ansätze habe ich noch, die Du ggfs. integrieren könntest:
1. Schaltjahr bzw. Anzahl der Tage in dem aktuellen Jahr, um diese für Durchschnittsberechnungen zu verwenden.
2. Einbindung von Feiertagen:
– Bestimmung des Karfreitag um über die Jahre die regelmäßig verschobenen (kirchlichen) Feiertage berechnen zu können und z. B. die Oster- oder Pfingstfeiertage (bzw. Wochen) übereinander legen zu können
Und damit verbunden generell die Frage: Feiertage (oder gar Schulferien) je Bundesland: Diese mit einfließen zu lassen wird wahrscheinlich (auch aufgrund der verlässlichen Datenquellen) schwierig, oder siehst Du eine Möglichkeit?

Vielen Dank!
Robert Unterdorfer meint

8. Juli 2024 um 11:56 am

Hallo Herr Scheiber,

gibt es die Vorlage für den Kalender noch auf Ihrer Seite-kann Sie unter dem Link https://ssbi-blog.de/blog/business-topics/meine-projekterprobte-kalendertabelle-fuer-power-bi-und-power-pivot/ nicht finden!

Beste Grüße
Marc meint

15. Mai 2023 um 3:00 pm

Hallo Herr Schreiber,

wirklich eine hervorragende Arbeit, welche Sie geleistet haben.
Danke für diesen wertvollen Beitrag.

Haben Sie schon einmal daran gedacht die Formel um ein „relatives Fiskaljahr # “ zu erweitern?
- Lars Schreiber meint
  
  27. Juli 2023 um 4:47 pm
  
  Moin Marc (ich hoffe das wertschätzende Du ist okay),
  
  es hat einen Moment gedauert, aber ich habe in der aktuellen Funktion das relative Fiskaljahr, Fiskalhalbjahr und Fiskalquartal integriert.
  
  Bin auf Dein Feedback gespannt.
  
  Danke und viele Grüße aus Hamburg,
  Lars

Meine projekterprobte Kalendertabelle für Power BI und Power Pivot

Wieso eine Kalendertabelle?