हमने हाल ही में एक SSAS सारणीबद्ध मॉडल बनाया है ताकि हमारे उपयोगकर्ता इसे PowerView के माध्यम से एक्सेस कर सकें। हमारे पास TotalActiveItemsसूत्र का उपयोग करने के लिए हमारे एक तथ्य तालिका पर एक उपाय है:
TotalActive:=COUNTAX(FILTER('Stats', ISBLANK([DeactDate]) = TRUE), 1)यह आवश्यकतानुसार काम करता है, लेकिन अब हमारा अनुरोध है कि प्रत्येक माह में शीर्ष 10 माता-पिता प्राप्त करें TotalActive।
संदर्भ के लिए, यहाँ हमारे मॉडल का हिस्सा है:
create table factStats
(
StatsID INT IDENTITY NOT NULL PRIMARY KEY,
DevID INT NOT NULL,
DeactDate DATETIME NULL,
BillDateTimeID BIGINT NOT NULL,
CustID INT NOT NULL,
ParentID INT NOT NULL
);
create table dimCust
(
CustID INT NOT NULL PRIMARY KEY,
CustName varchar(150) NOT NULL
);
create table dimParent
(
ParentID INT NOT NULL PRIMARY KEY,
ParentName varchar(100) NOT NULL
);
create table dimDateTime
(
DateTimeID BIGINT NOT NULL PRIMARY KEY
);
एसक्यूएल फिडल टेबल और नमूना डेटा के साथ।
factStatsमेज पर FKS है DevID, CustID, BillDateTimeID, और ParentID। हमारे पास जो अनुरोध है वह या तो Top 10 Parentsप्रत्येक के BillDateTimeIDआधार पर गणना करने या स्टोर करने के लिए है TotalActive और शीर्ष 10 में सब कुछ शामिल नहीं है जो निम्नलिखित के समान लुढ़का हुआ श्रेणी में है:
+----------------+------------+------+
| BillDateTimeID | Parent | Rank |
+----------------+------------+------+
| 20140801 | Jim | 1 |
| 20140801 | Bob | 2 |
| 20140801 | All Others | 3 |
+----------------+------------+------+
मैं आसानी से विंडो फ़ंक्शन का उपयोग करते हुए SQL में इसे पूरा कर सकता हूं लेकिन SSAS के लिए इसे पुन: पेश करने की कोशिश करना मुश्किल है। SQL में, हमें परिणाम का उपयोग करना होगा:
;with Total as
(
select
ParentID,
BillDateTimeID,
sum(case when DeactDate is null then 1 else 0 end) TotalActive
from factStats
group by ParentID, BillDateTimeID
),
PRank as
(
select
ParentID,
BillDateTimeID,
TotalActive,
row_number() over(partition by BillDateTimeID
order by TotalActive desc) pr
from total
)
select
parentid,
BillDateTimeID,
TotalActive,
pr
from prank
where pr <= 2
union all
select
0,
BillDateTimeID,
sum(TotalActive) TotalActive,
3
from prank
where pr > 2
group by BillDateTimeID
order by BillDateTimeID desc, pr;
मैंने परिणाम प्राप्त करने के लिए कई अलग-अलग तरीकों की कोशिश की है लेकिन हर एक का मुद्दा रहा है। मेरे प्रयास नीचे हैं।
प्रारंभ में, मैं कुछ हद तक MDX क्वेरी का उपयोग करके डेटा प्राप्त करने में सक्षम था, लेकिन तब कोई सुराग नहीं था कि इसे हमारे सारणीबद्ध मॉडल में कैसे शामिल किया जाए। संदर्भ के लिए MDX क्वेरी है:
with
set [Top10Parent] AS
(
(TOPCOUNT({ORDER(({[Parent].[Parent Name].[Parent Name]}),
([Measures].[Total Count]), BDESC)}, 10))
)
MEMBER [Parent].[Parent Name].[Others] AS
(
AGGREGATE(EXCEPT([Parent].[Parent Name].[Parent Name], [Top10Parent]))
)
select
[Measures].[Total Count] on columns,
{[Top10Parent]}+ {[Parent].[Parent Name].[Others]} on Rows
from [OurModel]
where {[Date and Time].[Month and Year].[Month and Year].[Jul 2014]};
बेशक, इसने मुझे केवल एक महीने के लिए परिणाम दिया, न कि हर महीने।
जब मुझे एहसास हुआ कि MDX क्वेरी काम नहीं करेगी, तो हमने factStatsटॉप 10 में और आइटम को लुढ़के हुए मूल्य में फ़्लैग करने के लिए एक नया कॉलम शामिल करने के लिए हमारी तालिका को बदलकर शुरू किया ।
alter table factStats
add Top10ParentID INT NOT NULL
constraint DF_factStats default (0);
डिफ़ॉल्ट बाधा शीर्ष 10 के लिए हमारे "लुढ़का हुआ" मूल्य को संदर्भित करता है।
# 1 प्रयास करें: मैंने पेरेंटिड, नाम और रैंक को संग्रहीत करने के लिए नई शीर्ष 10 तालिका बनाई है:
create table dimTop10Parent
(
Top10ParentID INT NOT NULL PRIMARY KEY,
ParentName varchar(100) NOT NULL,
Parent_Rank INT NOT NULL
);
यह तालिका तब हमारे द्वारा कुल सक्रिय वस्तुओं पर आधारित नए शीर्ष 10 माता-पिता के साथ हमारे मॉडल को ताज़ा करने के लिए हर बार आबादी होगी। Parent_Rankस्तंभ तो हमारे सारणीबद्ध मॉडल में छिपा हुआ और छँटाई के लिए विशेष रूप से इस्तेमाल किया जाता है। यह महान काम करता है, सिवाय इसके कि हमारे पास ऐतिहासिक रूप से शीर्ष 10 प्राप्त करने की क्षमता नहीं है क्योंकि यह एक महीने से महीने के आधार पर नहीं है।
# 2 प्रयास करें : शीर्ष 10 को संग्रहीत करने के लिए एक नई तालिका बनाएं लेकिन प्राथमिक कुंजी में Top10ParentID और BillingDateTimeID दोनों शामिल होंगे।
create table dimTop10Parent
(
Top10ParentID INT NOT NULL,
ParentName varchar(100) NOT NULL,
Parent_Rank INT NOT NULL,
BillDateTimeID BIGINT NOT NULL
);
इसके साथ समस्या यह है कि हम टैब्लेट मॉडल में dimTop10Parent में दो भाग PK के लिए factStats सिंगल FK के बीच संबंध नहीं बना सकते हैं।
# 3 प्रयास करें : नई तालिका बनाएं लेकिन PK के रूप में एक पहचान का उपयोग करें।
create table dimTop10Parent
(
Top10ID INT IDENTITY NOT NULL PRIMARY KEY,
Top10ParentID INT NOT NULL,
ParentName varchar(100) NOT NULL,
Parent_Rank INT NOT NULL,
BillDateTimeID BIGINT NOT NULL
);
factStatsतालिका स्टोर करेगा Top10IDमूल्य जो प्रत्येक पंक्ति के लिए अद्वितीय हो जाएगा। मैंने सोचा था कि यह मेरी समस्या को हल कर देगा, लेकिन ऐसा नहीं हुआ क्योंकि हम अब Parent_Rankमॉडल द्वारा छाँट नहीं सकते हैं , यह एक त्रुटि फेंकता है:
ParentName को Parent_Rank द्वारा सॉर्ट नहीं किया जा सकता क्योंकि ParentName में कम से कम एक मान Parent_Rank में कई विशिष्ट मान हैं। उदाहरण के लिए, आप [क्षेत्र] द्वारा [शहर] को क्रमबद्ध कर सकते हैं क्योंकि प्रत्येक शहर के लिए केवल एक ही क्षेत्र है, लेकिन आप [क्षेत्र] द्वारा [क्षेत्र] को नहीं छांट सकते क्योंकि प्रत्येक क्षेत्र के लिए कई शहर हैं।
नमूना डेटा का उपयोग करते हुए अंतिम परिणाम के समान होना चाहिए (यह एक 3 लुढ़का के साथ शीर्ष 2 दिखा रहा है):
| PARENTNAME | BILLDATETIMEID | TOTALACTIVE | PR |
|------------|----------------|-------------|----|
| FDN | 201408010000 | 11 | 1 |
| FDO | 201408010000 | 3 | 2 |
| All Others | 201408010000 | 5 | 3 |
| FDN | 201407010000 | 12 | 1 |
| EVOD | 201407010000 | 2 | 2 |
| All Others | 201407010000 | 5 | 3 |
इस बिंदु पर, मैं इस अंतिम परिणाम को प्राप्त करने के तरीके के नुकसान पर हूं। मैं इसे प्राप्त करने के लिए आवश्यकतानुसार तालिकाओं को बदल सकता हूं, मैं फॉर्मूला, माप, आदि का उपयोग करके मॉडल को बदल सकता हूं। मैंने DAX सूत्रों 1 , 2 , 3 का उपयोग करके रैंकिंग के बारे में पढ़ा है , लेकिन मैं अपना सिर इधर-उधर लपेटने के लिए प्रतीत नहीं हो सकता उन्हें पर्याप्त रूप से परिणाम प्राप्त करने में सक्षम होने के लिए पर्याप्त है।
मैं किसी भी महीने के लिए इस शीर्ष 10 की गणना / भंडारण कैसे कर सकता हूं और अभी भी हमारे सारणीबद्ध मॉडल में आवश्यकतानुसार डेटा को विभाजित करने में सक्षम हो सकता हूं?