पावर बीआई डेस्कटॉप डैक्स कुल कॉलम को चालू करता है


9

मेरे पास एक टेबल है जहां हर व्यक्ति का साल के हर दिन का रिकॉर्ड होता है। मैंने इस फ़ंक्शन का उपयोग दैनिक बैलेंस कॉलम के आधार पर एक रनिंग टोटल प्राप्त करने के लिए किया

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

लेकिन मुझे टाइप 1 से रिस्टार्ट करने के लिए रनिंग टोटल की जरूरत है यदि टाइप = वर्किंग और डेली बैलेंस की रनिंग शून्य से कम है और पिछली रो का टाइप वर्किंग के बराबर नहीं है। नीचे एक्सेल से एक स्क्रीन शॉट दिया गया है। आवश्यक फ़ंक्शन कॉलम वह है जो मुझे प्राप्त करने की आवश्यकता है।

यहां छवि विवरण दर्ज करें


1
5 नवंबर, व्यक्ति 1 के लिए पंक्ति में, मान लें कि हमारे परीक्षण डेटा में एक रिक्त प्रकार था। 6 नवंबर को 'आवश्यक फ़ंक्शन' 1 या 2 लौटाएगा?
रयान बी।

यह 2 नवंबर 6 के लिए वापस आ जाएगा। "रीसेट" नहीं होगा क्योंकि 5 नवंबर 1 होगा (नकारात्मक संख्या नहीं)। आपके विस्तृत पोस्ट के लिए धन्यवाद। मैं आज समीक्षा कर रहा हूं
LynseyC

जवाबों:


1

यह न केवल एक शर्त के साथ चलने वाला कुल है, बल्कि एक नेस्टेड / क्लस्टर्ड भी है, क्योंकि आईडी-स्तर पर तर्क को लागू करना है। बड़ी तालिकाओं के लिए, D इसे DAX की तुलना में बेहतर है, क्योंकि यह ज्यादा RAM का उपयोग नहीं करता है। (मैंने इसके बारे में यहाँ ब्लॉग किया है: Blogpost का लिंक

निम्न फ़ंक्शन वर्तमान मामले में उस तर्क को स्वीकार करता है और आईडी-स्तर पर लागू किया जाना है: (आवश्यक कॉलम नाम हैं: "प्रकार", "दैनिक भत्ता", "समायोजन")

(MyTable as table) => let SelectJustWhatsNeeded = Table.SelectColumns(MyTable,{"Type", "Daily Allowance", "Adjustments"}), ReplaceNulls = Table.ReplaceValue(SelectJustWhatsNeeded,null,0,Replacer.ReplaceValue,{"Adjustments"}), #"Merged Columns" = Table.CombineColumns(ReplaceNulls,{"Daily Allowance", "Adjustments"}, List.Sum,"Amount"), TransformToList = List.Buffer(Table.ToRecords(#"Merged Columns")), ConditionalRunningTotal = List.Skip(List.Generate( () => [Type = TransformToList{0}[Type], Result = 0, Counter = 0], each [Counter] <= List.Count(TransformToList), each [ Result = if TransformToList{[Counter]}[Type] = "working" and [Result] < 0 and [Type] <> "working" then TransformToList{[Counter]}[Amount] else TransformToList{[Counter]}[Amount] + [Result] , Type = TransformToList{[Counter]}[Type], Counter = [Counter] + 1 ], each [Result] )), Custom1 = Table.FromColumns( Table.ToColumns(MyTable) & {ConditionalRunningTotal}, Table.ColumnNames(MyTable) & {"Result"} ) in Custom1


इससे समस्या का समाधान हो गया है। पूरी तरह से काम करता है और रिपोर्ट को धीमा नहीं किया है। धन्यवाद
LynseyC

5

अवलोकन

यह पावरबैंक को करने के लिए कहने के लिए एक चुनौतीपूर्ण बात है, इसलिए एक कठिन दृष्टिकोण को ढूंढना मुश्किल हो सकता है।

सबसे बड़ा मुद्दा यह है कि पावरबीआई का डेटा मॉडल एक रनिंग टैली की अवधारणा का समर्थन नहीं करता है - कम से कम जिस तरह से हम इसे एक्सेल में करते हैं। एक्सेल में, एक कॉलम मानों को संदर्भित कर सकता है जो उसी कॉलम की 'पिछली पंक्ति' में होता है और फिर एक अलग कॉलम में सूचीबद्ध कुछ 'दैनिक परिवर्तन' द्वारा समायोजित किया जाता है।

PowerBI केवल कुछ उप-पंक्तियों में सभी दैनिक परिवर्तनों को जोड़कर इसका अनुकरण कर सकता है। हम अपनी वर्तमान पंक्ति में दिनांक मान लेते हैं और एक फ़िल्टर की गई तालिका बनाते हैं, जहां सभी तिथियां इस वर्तमान पंक्ति की तारीख से कम होती हैं, और फिर उस सबसेट से सभी दैनिक परिवर्तनों को जोड़ते हैं। यह एक सूक्ष्म अंतर प्रतीत हो सकता है, लेकिन यह काफी महत्वपूर्ण है:

इसका मतलब यह है कि हमारे चलने वाले कुल को 'ओवरराइड' करने का कोई तरीका नहीं है। केवल जो गणित किया जा रहा है वह दैनिक परिवर्तन वाले कॉलम पर हो रहा है - 'कुल चलने' वाला कॉलम केवल एक परिणाम है - इसका उपयोग किसी भी बाद की पंक्ति की गणना में नहीं किया जाता है।

हमें 'रीसेट' की अवधारणा को छोड़ना चाहिए और इसके बजाय एक कॉलम बनाने की कल्पना करनी चाहिए जिसमें 'समायोजन' का मूल्य हो। हमारा समायोजन एक मूल्य होगा जिसे शामिल किया जा सकता है ताकि जब वर्णित शर्तों को पूरा किया जाए, तो दैनिक शेष और समायोजन की कुल राशि 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"
))

यह पंक्ति और फ़िल्टर संदर्भों के बीच अंतर जानने में मदद करता है और इस गणना का पालन करने के लिए EARLIER कैसे संचालित होता है। इस परिदृश्य में, आप "EARLIER" के बारे में सोच सकते हैं, जिसका अर्थ है "यह संदर्भ वर्तमान पंक्ति में मान को इंगित करता है" और अन्यथा "ALLEXCEPT (छोड़ें, छोड़ दें [Id])" द्वारा लौटाए गए संपूर्ण तालिका के संदर्भ बिंदु। जिस तरह से, हम उन स्थानों को खोजते हैं जहाँ वर्तमान पंक्ति में "कार्य" है और पूर्व दिवस की पंक्ति में कुछ अन्य प्रकार हैं।

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])
))

यह गणना एक 'फिल डाउन' प्रकार के ऑपरेशन का अनुकरण करती है। यह कहता है, "जब उन सभी पंक्तियों को देख रहे हैं जिनकी तारीख THIS पंक्ति की तारीख से पहले है, तो 'सबसे हाल की तारीख से पहले कार्य करने के लिए सबसे बड़ा मूल्य लौटाएं।"

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]

और अंत में हम अंतिम परिणाम के लिए हमारे चलने वाले कुल में समायोजन लागू करते हैं।

समस्या

यह दृष्टिकोण यह पता लगाने में विफल रहता है कि गिनती को तब तक रीसेट नहीं किया जाना चाहिए जब तक कि चलने वाला दैनिक संतुलन शून्य से नीचे न हो। मुझे पहले गलत साबित किया गया है, लेकिन मैं कहूंगा कि यह केवल DAX में पूरा नहीं किया जा सकता क्योंकि यह एक परिपत्र निर्भरता बनाता है। अनिवार्य रूप से, आप एक आवश्यकता बनाते हैं: एकत्रीकरण में क्या शामिल होना चाहिए यह निर्धारित करने के लिए एकत्रित मूल्य का उपयोग करें।

इसलिए जब तक मैं आपको ला सकता हूं। आशा है ये मदद करेगा।


1
आपके अंतिम बिंदु के बारे में, मेरा मानना ​​है कि आप सही हैं। DAX पुनरावृत्ति नहीं कर सकता।
एलेक्सिस ओल्सन

3

आशा है कि अगली बार आप एक सीएसवी या कोड पेस्ट करेंगे जो चित्र के बजाय नमूना डेटा उत्पन्न करता है। :)

मुझे केवल सुझाव दें कि आप इसके बजाय 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

मुझे यकीन नहीं है कि यह हर परिदृश्य को कवर करता है, लेकिन यह सही दृष्टिकोण की तरह लगता है।
माइक हनी

मुझे यह काम करने के लिए तभी मिल सकता है जब प्रत्येक व्यक्ति के लिए पहला प्रकार काम कर रहा हो। DAX उदाहरणों के साथ भी यह कार्यशील गति के लिए नंबरिंग को पुनरारंभ करता है जब पिछली पंक्ति के लिए संचयी कुल एक सकारात्मक संख्या होती है। मुझे लगता है कि मेरी तस्वीर भ्रामक थी क्योंकि इसमें केवल यह परिदृश्य था। मुझे ऐसे समय में शामिल करना चाहिए जब प्रकार काम करने के लिए बदल गया लेकिन पिछली पंक्ति कुल सकारात्मक थी।
LynseyC

@LynseyC अच्छी तरह से, यह कोड सही और पूर्ण समाधान नहीं है, निश्चित रूप से, बल्कि उन तरीकों का एक उदाहरण है, जिनका उपयोग किया जा सकता है। बस अपने परिदृश्य के लिए संशोधित करें।
यूजीन

@LynseyC भी, DAX के बजाय PowerQuery में इस गणित को करने वाले फायदों में से एक डेटा मॉडल से अस्थायी कॉलम रखने का एक आसान तरीका है।
यूजीन

3

मुझे लगता है कि मेरे पास है!

यहाँ परिणाम है, मेरे द्वारा पहले पोस्ट किए गए समाधान पर निर्माण: (डेटा को अधिक "काम / कोई काम नहीं" व्यवहार और उपयोग के लिए दिखाने के लिए संशोधित किया गया है)

परिणाम

यहां छवि विवरण दर्ज करें

विवरण

(1) ड्रॉप "एडजस्टेड रनिंग डेली बैलेंस" और "डेली बैलेंस एडजस्टमेंट" कोलम्स। हम एक पल में एक कम कदम के साथ एक ही परिणाम प्राप्त करेंगे।

(2) निम्नलिखित कॉलम बनाएं (RDB = "दैनिक बैलेंस चल रहा है") ...

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]) 
))

"सबसे हाल की तारीख से पहले काम पूरा करने के लिए" बनाने के बाद, हमारे पास वास्तव में हमारे 'रीसेट' करने के लिए आवश्यक टुकड़ा है जो मैंने दावा किया था कि यह पहले असंभव था। इस फ़ील्ड को फ़िल्टर करके, हमारे पास प्रत्येक स्लाइस को '1' पर शुरू करने का अवसर है

(३) हमारे पास अभी भी यही समस्या है, हम अपने कॉलम में परिणाम को नहीं देख सकते हैं और इसका उपयोग यह तय करने के लिए कर सकते हैं कि बाद में उसी कॉलम में क्या करें। लेकिन हम एक नया समायोजन कॉलम बना सकते हैं जो उस जानकारी को रखेगा! और हमारे पास पहले से ही 'सबसे हाल की तारीख से पहले काम करने के लिए' का संदर्भ है - यह पिछले समूह में आखिरी दिन है ... हमें जो जानकारी चाहिए, उसके साथ पंक्ति!

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)

इसलिए हम प्रत्येक में अंतिम दिन देखते हैं पूर्व समूह और यदि उन समायोजन के कुल योग का एक सकारात्मक मूल्य है जो हम इसे लागू करते हैं और यदि यह नकारात्मक है तो हम इसे इसके बजाय अकेले छोड़ देते हैं। इसके अलावा, अगर हमारे व्यक्ति के पहले कुछ दिन गैर-कामकाजी दिन हैं, तो हम नहीं चाहते हैं कि हमारे समायोजन में शुरुआती नकारात्मक सा बिलकुल भी कम हो जाए, क्योंकि यह फिल्टर भी हो जाता है।

(4) यह अंतिम चरण समायोजन को अंतिम परिणाम में लाएगा। दो नए कॉलमों को समेटें और अंत में हमारा एडजस्टेड रनिंग डेली बैलेंस होना चाहिए। देखा!

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

हमने इस परिणाम के साथ बहुत सारे अतिरिक्त कॉलम बनाए, जो आमतौर पर मेरा पसंदीदा काम नहीं है। लेकिन, यह एक मुश्किल था।


हाय @Ryan बी। यह मेरे संगठन में 200 से अधिक लोगों के लिए पूरी तरह से काम करता है, लेकिन एक काम नहीं कर रहा है। मैंने कोड को स्वयं बदलने की कोशिश की है, लेकिन समस्या को हल करने के लिए मुझे कुछ भी नहीं मिला। मुझे लगता है कि ऐसा इसलिए है क्योंकि उन्होंने लंबे समय तक काम किया है और फिर अधिक समय निकालने से ठीक एक दिन पहले काम किया है। मैंने समस्या दिखाने के लिए एक छवि से जोड़ा है। धन्यवाद छवि
LynseyC

मैंने "समूहीकृत आरडीबी समायोजन" उपाय को संशोधित किया है, ताकि इसे कई "काम / कोई काम नहीं" चक्रों पर छुट्टी के बड़े accruals पास करना चाहिए।
रयान बी

2
नमस्ते, सभी प्रयास के लिए धन्यवाद, बहुत सराहना की। दुर्भाग्य से संशोधन ने समस्या का समाधान नहीं किया। हालाँकि अगर मैंने फ़िल्टर में अंतिम स्थिति को हटा दिया "छोड़ो [सबसे हाल की तारीख से पहले काम पूरा करने के लिए] <> ब्लैंक ()" तो यह समस्या हल हो गई लेकिन फिर इसने मूल लोगों के
बछड़ों को

गोली मार। खैर, मुझे आशा है कि आप कुछ ऐसा पा सकते हैं जो काम करता है।
रयान बी।

2

कुछ समय लगा, लेकिन मैं वर्कअराउंड के साथ आने में सक्षम था। यह मानते हुए कि ब्लॉक्स के लिए बैलेंस वैल्यू हमेशा -1 है और वैल्यू "वर्किंग" के लिए 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

ध्यान रखें, यह एक तैयार उत्पाद नहीं हो सकता है क्योंकि मैंने एक छोटे नमूने के साथ काम किया था, लेकिन यह आपको शुरू करना चाहिए। उम्मीद है की यह मदद करेगा।


धन्यवाद @ CR7SMS टाइपिंग = कार्य करने पर यह टोटल रनिंग को फिर से शुरू करता है लेकिन टाइप खाली होने पर रनिंग टोटल काम नहीं करता है। 7 Nov के लिए यह 3 तक कम हो जाता है लेकिन फिर 8-14 Nov से यह -2 लौटता है। क्या आप प्रकार रिक्त होने पर काम करने के लिए दौड़ने के लिए कोड में संशोधन के साथ मदद कर सकते हैं? धन्यवाद
LynseyC

हाय Lynsey, मैं एक अलग गणना की कोशिश की। मैंने इसे एक और उत्तर के रूप में जोड़ा है क्योंकि गणना थोड़ी लंबी थी। लेकिन उम्मीद है कि नई गणना काम करती है।
CR7SMS

@ CR7SMS कृपया किसी एक प्रश्न के एक से अधिक उत्तरों को जोड़ने से बचें। यह अन्य उपयोगकर्ताओं को भ्रमित करता है जो समान समस्या / समाधान खोज सकते हैं और यह अच्छा नहीं है। इसके बजाय, आपको एक उत्तर के समाधान के रूप में जो कुछ भी हो सकता है, उसे जोड़ना चाहिए और हर अलग पहलू को खंडों में विभाजित करना चाहिए।
क्रिस्टोस लिट्रास

2

गणना थोड़ी लंबी है, लेकिन मुझे लगता है कि मैं जिस नमूना डेटा का उपयोग कर रहा हूं, उसमें यह काम कर रहा है। इसे आजमाइए:

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

मैंने यहाँ चरों का एक गुच्छा प्रयोग किया है। आप शायद एक छोटे संस्करण के साथ आ सकते हैं। मूल रूप से विचार "कार्य" की पिछली पहली घटना को खोजने के लिए है कि गणना कहां से शुरू करें। यह "Prev_Blank2" चर में गणना की जाती है। एक बार जब हम शुरुआती बिंदु जानते हैं (यह यहां 1 से शुरू होता है), तो हम बस Prev_Blank2 और वर्तमान रिकॉर्ड की तारीख के बीच "कार्य" या रिक्त () के साथ दिनों की संख्या की गणना कर सकते हैं। इन दिनों का उपयोग करते हुए, हम कुल चलाने के लिए अंतिम मूल्य वापस कर सकते हैं।

उम्मीद है इससे काम होगा ;)

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.