Powerbi Power BI桌面DAX重新启动运行总计列

我有一张桌子，每个人都有一年中每一天的记录。我使用此函数实现了基于“每日余额”列的运行总计

CALCULATE(
SUM(Leave[Daily Balance]),
FILTER(
   ALLEXCEPT(Leave, Leave[Employee Id]),
   Leave[Date] <= EARLIER(Leave[Date])
))

计算(
总额（假期[每日余额]），
滤器(
ALLEXCEPT（休假，休假[员工Id]），
Leave[Date]花了一段时间，但我找到了一个解决方法。假设空白的余额值始终为-1，“Working”的值为1，并且所有日期的数据都是可用的，没有间隙，下面的计算可能会起作用：

Running Total = 
    VAR Employee = Leave[Employee ID]
    VAR Date1 = Leave[Date]
    VAR Prev_Blank = CALCULATE(MAX(Leave[Date]),
                        FILTER(Leave,Leave[Date] < Date1),
                        FILTER(Leave,Leave[Employee ID]=Employee),
                        FILTER(Leave,Leave[Type]=BLANK()))  
    VAR Day_count_Working = CALCULATE(COUNT(Leave[Date]),
                        FILTER(Leave,Leave[Date] > Prev_Blank),
                        FILTER(Leave,Leave[Date] <= Date1),
                        FILTER(Leave,Leave[Employee ID]=Employee),
                        FILTER(Leave,Leave[Type]="Working")) 
    VAR Day_count = CALCULATE(COUNT(Leave[Date]),
                        FILTER(Leave,Leave[Date] >= Prev_Blank),
                        FILTER(Leave,Leave[Date] <= Date1),
                        FILTER(Leave,Leave[Employee ID]=Employee)) 
RETURN (IF(Day_count_Working=BLANK(),Day_count,Day_count-1)-Day_count_Working)*-1 + Day_count_Working

运行总数=
VAR Employee=休假[员工ID]
VAR Date1=休假[日期]
VAR Prev_Blank=计算（最大值（休假[日期]），
过滤器（休假，休假[日期]<日期1），
过滤器（休假，休假[员工ID]=员工），
筛选器（Leave，Leave[Type]=BLANK（））
VAR Day_count_Working=计算（计数（休假[日期]），
过滤器（离开，离开[日期]>上一页空白），
过滤器（休假，休假[日期]=上一页为空），
FILTER（Leave，Leave[Date]计算有点长，但它似乎在我使用的示例数据中起作用。请尝试一下：

Running Total = 
    VAR Employee = Leave[Employee ID]
    VAR Date1 = Leave[Date]
    VAR Prev_Blank = CALCULATE(MAX(Leave[Date]),
                        FILTER(Leave,Leave[Date] < Date1),
                        FILTER(Leave,Leave[Employee ID]=Employee),
                        FILTER(Leave,Leave[Type]=BLANK()))  
    VAR Prev_Working = CALCULATE(MAX(Leave[Date]),
                        FILTER(Leave,Leave[Date] < Date1),
                        FILTER(Leave,Leave[Employee ID]=Employee),
                        FILTER(Leave,Leave[Type]="Working"))    
    VAR Prev_Blank1 = CALCULATE(MAX(Leave[Date]),
                        FILTER(Leave,Leave[Date] < Prev_Working),
                        FILTER(Leave,Leave[Employee ID]=Employee),
                        FILTER(Leave,Leave[Type]=BLANK()))  
    VAR Prev_type = CALCULATE(MAX(Leave[Type]),
                        FILTER(Leave,Leave[Date] = Date1-1),
                        FILTER(Leave,Leave[Employee ID]=Employee))
    VAR Prev_Blank2 = IF(Leave[Type]="Working" && (Prev_Blank1=BLANK() || Prev_type=BLANK()),Date1-1,Prev_Blank1)    
    VAR Day_count_Working = CALCULATE(COUNT(Leave[Date]),
                        FILTER(Leave,Leave[Date] > Prev_Blank2),
                        FILTER(Leave,Leave[Date] <= Date1),
                        FILTER(Leave,Leave[Employee ID]=Employee),
                        FILTER(Leave,Leave[Type]="Working")) 
    VAR Day_count = CALCULATE(COUNT(Leave[Date]),
                        FILTER(Leave,Leave[Date] >= Prev_Blank2),
                        FILTER(Leave,Leave[Date] <= Date1),
                        FILTER(Leave,Leave[Employee ID]=Employee)) 
RETURN (IF(Day_count_Working=BLANK(),Day_count,Day_count-1)-Day_count_Working)*-1 + Day_count_Working

运行总数=
VAR Employee=休假[员工ID]
VAR Date1=休假[日期]
VAR Prev_Blank=计算（最大值（休假[日期]），
过滤器（休假，休假[日期]<日期1），
过滤器（休假，休假[员工ID]=员工），
筛选器（Leave，Leave[Type]=BLANK（））
VAR Prev_Working=计算（最大值（休假[日期]），
过滤器（休假，休假[日期]<日期1），
过滤器（休假，休假[员工ID]=员工），
过滤器（休假，休假[类型]=“工作”））
VAR Prev_Blank1=计算（最大值（休假[日期]），
过滤器（休假，休假[日期]<上次工作），
过滤器（休假，休假[员工ID]=员工），
筛选器（Leave，Leave[Type]=BLANK（））
VAR Prev_类型=计算（最大值（离开[类型]），
过滤器（休假，休假[日期]=日期1-1），
过滤器（休假，休假[员工ID]=员工））
VAR Prev_Blank2=IF（leve[Type]=“Working”&（Prev_Blank1=BLANK（）| | Prev_Type=BLANK（）），Date1-1，Prev_Blank1）
VAR Day_count_Working=计算（计数（休假[日期]），
过滤器（休假，休假[日期]>上一页空白2），
过滤器（休假，休假[日期]=Prev_Blank2），
筛选（离开，离开[日期]希望下次您将粘贴csv或生成样本数据而不是图片的代码。：）

我建议您使用PowerQuery进行计算。
为了提高可读性，我尝试将代码分成几个步骤。
这看起来可能有点复杂，但效果很好。只需将其粘贴到高级编辑器中，然后用源数据替换源。
祝你好运

let
    Source = Table.FromRows(Json.Document(Binary.Decompress(Binary.FromText("i45WMjDUMzDSMzIwtFTSUQpILSrOz1MwBDLL84uyM/PSlWJ1gGqMsKuBSBrjkzQhwnRTItSYEaHGHJ9DLPBJWhI23dAAjwGGOAIRIokj9OCmxwIA", BinaryEncoding.Base64), Compression.Deflate)), let _t = ((type text) meta [Serialized.Text = true]) in type table [date = _t, name = _t, #"type" = _t]),
    SetTypes = Table.TransformColumnTypes(Source,{{"date", type date}, {"name", type text}, {"type", type text}}),
    TempColumn1 = Table.AddColumn(SetTypes, "LastOtherType", (row)=>List.Max(Table.SelectRows(SetTypes, each ([name] = row[name] and [type] <> row[type] and [date] <= row[date]))[date], row[date]), type date) //Here for each row we select all rows of other type with earlier date, and take max that date. Thus we know when was previous change from one type to another
 //Here for each row we select all rows of other type with earlier date, and take max that date. Thus we know when was previous change from one type to another
,
    TempColumn2 = Table.AddColumn(TempColumn1, "Count", (row)=>
(if row[type]="working" then 1 else -1) * 
Table.RowCount(
Table.SelectRows(SetTypes, each ([name] = row[name] and [type] = row[type] and [date] <= row[date] and [date] > row[LastOtherType])) /* select all rows between type change (see prev step) and current row */
), /*and count them*/
Int64.Type) // finally multiply -1 if they are not working type
,
    FinalColumn = Table.AddColumn(TempColumn2, "FinalFormula", (row)=> 
(if row[type] = "working" then row[Count] else /* for working days use Count, for others take prev max Count and add current Count, which is negative for non-working*/
Table.LastN(Table.SelectRows(TempColumn2, each [name] = row[name] and [type] = "working" and [LastOtherType] <= row[LastOtherType]),1)[Count]{0}
+ row[Count])
, Int64.Type),
    RemovedTempColumns = Table.RemoveColumns(FinalColumn,{"LastOtherType", "Count"})
in
    RemovedTempColumns

let
Source=Table.fromrrows（Json.Document（Binary.decompression（Binary.FromText（“i45wmjdumzdsmziwtsuqpilsroz1mwbdll84uym/pslwj1ggqmskubsbrjkzhwnrtsyeahghj9dlpbjwhi23daajwggoairiokj9ocmxwia”，binarycodeding.Base64），Compression.Deflate）），让类型表[date=（type text）meta[Serialized.text=true]，#“type”=#，
SetTypes=Table.TransformColumnTypes（源，{{“日期”，类型日期}，{“名称”，类型文本}，{“类型”，类型文本}），
TempColumn1=Table.AddColumn（SetTypes，“LastOtherType”，（row）=>List.Max（Table.SelectRows（SetTypes），每个（[name]=行[name]和[type]行[type]和[date]
（如果行[类型]=“工作”，则1其他-1）*
表1.RowCount(
Table.SelectRows（SetTypes，每个（[name]=行[name]和[type]=行[type]和[date]行[LastOtherType]）/*选择类型更改（请参见上一步）和当前行之间的所有行*/
)，/*并数一数*/
int 64.Type）//如果它们不是工作类型，则最后乘以-1
,
FinalColumn=Table.AddColumn（TempColumn2，“FinalFormula”，（行）=>
（如果行[type]=“working”，则行[Count]else/*对于工作日使用Count，对于其他工作日使用prev max Count并添加当前计数，对于非工作日为负数*/
Table.LastN（Table.SelectRows（TempColumn2，每个[name]=行[name]和[type]=工作”和[LastOtherType]概述

这是要求PowerBI完成的一件具有挑战性的事情，因此可能很难找到一个整洁的方法

最大的问题是PowerBI的数据模型不支持连续计数的概念——至少不像我们在Excel中那样。在Excel中，一列可以引用同一列的“前一行”中出现的值，然后通过另一列中列出的一些“每日变化”进行调整

PowerBI只能通过将某些行子集上的所有每日更改相加来模拟这一点。我们获取当前行中的日期值并创建一个筛选表，其中所有日期都小于当前行的日期，然后将该子集中的所有每日更改相加。这似乎是一个细微的差异，但非常重要：

这意味着无法“覆盖”我们的运行总计。正在进行的唯一计算是在包含每日更改的列上进行的–包含“运行总计”的列只是一个结果–它永远不会用于任何后续行的计算

我们必须放弃“重置”的概念，而是设想创建一个包含“调整”值的列。我们的调整将是一个可以包含的值，以便在满足所述条件时，每日余额和调整的总和将为1

如果我们查看OP给出的计算运行次数，我们会发现“工作”日前一个“非工作”日的运行总数的值为我们提供了所需的数量，如果颠倒，则总和为零，并导致下一个工作日的运行总数增加1。这是我们的期望行为
Most Recent Date Prior to Work = 

CALCULATE(
Max(Leave[Date]),
FILTER(
   ALLEXCEPT(Leave, Leave[Id]),
   Leave[Date] = EARLIER(Leave[Date]) -1 && Leave[Type] <> "Working" && Earlier(Leave[Type]) = "Working"
))

Most Recent Date Prior to Work Complete = 

CALCULATE(
Max(Leave[Most Recent Date Prior to Work]),
FILTER(
   ALLEXCEPT(Leave, Leave[Id]),
   Leave[Date] <= EARLIER(Leave[Date])
))

Daily Balance Adjustment = 

CALCULATE(
SUM(Leave[Running Daily Balance]),
FILTER(
   ALLEXCEPT(Leave, Leave[Id]),
   Leave[Date] = EARLIER(Leave[Most Recent Date Prior to Work Complete])
))

Adjusted Daily Balance = Leave[Running Daily Balance] - Leave[Daily Balance Adjustment]

Grouped RDB = 

CALCULATE(
SUM(Leave[Daily Balance]),
FILTER(
   ALLEXCEPT(Leave, Leave[Id], Leave[Most Recent Date Prior to Work Complete]),
   Leave[Date] <= EARLIER(Leave[Date]) 
))

Grouped RDB Adjustment = 

VAR CalculatedAdjustment =
CALCULATE(
SUM(Leave[Grouped RDB]),
FILTER(
   ALLEXCEPT(Leave, Leave[Id]),
   Leave[Date] IN SELECTCOLUMNS(
        FILTER(
            Leave,
            Leave[Most Recent Date Prior to Work] <> BLANK() &&
            Leave[id] = EARLIER(Leave[Id])), "MRDPtW", Leave[Most Recent Date Prior to Work]) &&
   Leave[Most Recent Date Prior to Work Complete] < EARLIER(Leave[Most Recent Date Prior to Work Complete]) &&
   Leave[Most Recent Date Prior to Work Complete] <> Blank()
))

RETURN if (CalculatedAdjustment > 0, CalculatedAdjustment, 0)

Adjusted Running Daily Balance = Leave[Grouped RDB] + Leave[Grouped RDB Adjustment]