Source: https://patents.google.com/patent/US20070271227A1/en
Timestamp: 2018-06-19 12:45:37
Document Index: 640552352

Matched Legal Cases: ['art(1', 'art(2', 'art(2', 'art(2', 'art(1', 'art(1', 'art(2', 'art(2', 'art(2']

US20070271227A1 - Apparatus and method for recursively rationalizing data source queries - Google Patents
Apparatus and method for recursively rationalizing data source queries Download PDF
US20070271227A1
US20070271227A1 US11435554 US43555406A US2007271227A1 US 20070271227 A1 US20070271227 A1 US 20070271227A1 US 11435554 US11435554 US 11435554 US 43555406 A US43555406 A US 43555406A US 2007271227 A1 US2007271227 A1 US 2007271227A1
US11435554
US7698257B2 (en )
Soroush Momen-Pour
Reuben Michael Arthur Cox
SELECT Axis Dimensions Members ON COLUMNS,
Axis Dimensions Members ON ROWS
WHERE Sliced Dimensions Members
The “Axis Dimensions Members” specify which columns and rows to select. The “Sliced Dimensions Members” specify which slice of the cube to select.
Generator is an expression in a multidimensional query language that can generate a query for one or more members of a data source without explicit specification of the one or more members. Thus, a generator is a generalized expression of specific data source elements. The generators can be for a hierarchy, a level, a family, a descendent tree, or for except logic. For MDX the generator include the following: “Hierarchy.Members” as a generator to a hierarchy, “Level.Members” as a generator to a level, “Member.Children” as a generator to a family, and “Descendants(Member, Level, Self)” as a generator to a decent tree. For MDX the Except logic generator is “Except(x, y)”, where x, y are lists of members, or generators to families, or descendent trees. Here x is the generator to members to be included, and y is the generator to members to be excluded.
AB Rationalized Query = “ ”
AC if( Number of Member(Simple Query) = = Number
AD Rationalized Query = “Heirachy.members( )”
AE Simple Query = Simple Query − members(Heirachy)
AF Exit Rationalization
AG else foreach Level in Hierarchy; incrementing by level from first
AH Intersecting Set = intersection(Hierarchy, Simple Query)
AI if(Number of Member(Intersecting Set) = = Number of
AJ Rationalized Query = Rationalized Query +
AK Simple Query = Simple Query − members at level(Level)
AL if( Number of Member(Simple Query) = = 0 )
AM Exit Rationalization
AN end-if
AO end-if
AP end-foreach
AQ else call Recursive Rationalization Process (Simple Query,
AR Exit Rationalization
BA threshold = 0.5
BB MembersToAddNow = MembersToAddLater = Null;
BC create map Map(object:(integer, one or more objects)
BD foreach Object in the Members
BE if(parent(Object) = Null)
BF MembersToAddNow += Object
BG end-if
BH if( ! parent(object) in map)
BI Map[parent(Object)].mapPart(1) = numberOfChildren(parent(Object))
BJ Map[parent(Object)].mapPart(2) = Children(parent(Object))
BK else
BL Map[parent(Object)].mapPart(2) += Object
BM end-if
BN end-foreach
BO foreach Key in the Map
BP if( number(Map[Key].mapPart(2)) = = Map[Key].mapPart(1) )
BQ MembersToAddLater += Key
BR elseif (Map[Key].mapPart(1) − number(Map[Key].mapPart(2)) <
BS ExceptList = children(Key) − Map[Key].mapPart(2)
BT if( IterationIndex = = 0)
BU RationalizedQuery += “Except(Key, ExceptList)”
BV elseif( IterationIndex = = 1)
BW Decendents = Null
BX foreach Object in ExceptList
BY Decendents += (nameOfObject(Object + “.children()”)
BZ end foreach
BAA RationalizedQuery += “Except(Key, Decendents)”
BAB else
BAC Decendents = Null
BAD foreach object in ExceptList
BAE Decendents += “descendents(nameOfObject(Object),
BAF level(depth(key) + IterationIndex + 1), self)”
BAG end foreach
BAH RationalizedQuery += “Except(Key, Decendents)”
BAI end-if
BAJ else
BAK MembersToAddNow += Map[Key].mapPart(2);
BAO Recursive Rationalization Process (MembersToAddLater,
BAP end-if
CA if( IterationIndex = = 0)
CB foreach Object in MembersToAddNow
CC RationalizedQuery += “nameOfObject(Object”)
CD end-foreach
CE elseif( IterationIndex = = 1)
CF foreach Object in MembersToAddNow
CG RationalizedQuery +=
CH end-foreach
CI else
CJ foreach member in MembersToAddNow
CK RationalizedQuery +=
CL end-foreach
CM end-if
CUSTOMER 36578, CUSTOMER 15487, CUS- 58697,
CUSTOMER 65454, CUSTOMER 45656, CUS- 98662,
CUSTOMER 65656, CUSTOMER 54565, CUS- 21545,
CUSTOMER 35663
The simple query to the data source would recite each of these objects.
After a first invocation of the recursive rationalization process, the rationalized query replaces clusters of parents and children with a generator to the same. The parents and children in clusters 602A, 602B, and 602C are replaced with generators “HUNTSVILE.CHILDREN”, “IRVINE.CHILDREN”, and “SANTA_ANA.CHILDREN”. Except logic is applied to replace the customers in clusters 604A with “EXCEPT(AL.CHILDREN, {HUNTSVILE})”. Only “CUSTOMER 35663” remains in the simple query. The remaining elements of the simple query can be with the rationalized query for the purposes of making a query to a data source. Otherwise, another call to the recursive process is made.
HUNTSVILE.CHILDREN, EXCEPT(AL.CHILDREN, {HUNTSVILE}), DESCENDANTS(CA, LEVEL 5, SELF), CUSTOMER 35663
Here “IRVINE.CHILDREN”, and “SANTA_ANA.CHILDREN” have been replaced with a generator to the decedents of CA, “DESCENDANTS(CA, LEVEL 5, SELF)” specifying the level “5” and that only the decedents at level 5 be included (parameter “SELF”).
1. A computer readable medium storing computer executable instructions, comprising executable instructions to:
receive a multidimensional data source query; and
invoke a recursive process to replace an element of the multidimensional data source query with a generator to create a rationalized query.
2. The computer readable medium of claim 1 further comprising executable instructions to return data associated with the rationalized query.
5. The computer readable medium of claim 1 further comprising executable instructions to replace a descendent tree of elements in the multidimensional data source query with a generator corresponding to the descendent tree, wherein the descendent tree includes a root and a plurality of descendents on one or more levels.
6. The computer readable medium of claim 1 further comprising executable instructions to convert a collection of objects referencing data in the multidimensional data source into the multidimensional data source query.
7. The computer readable medium of claim 1 wherein the multidimensional data source is an OLAP data source and the rationalized query is in Multidimensional Expressions (MDX).
8. The computer readable medium of claim 1 further comprising executable instructions to query the multidimensional data source with the rationalized query.
9. The computer readable medium of claim 8 further comprising executable instructions to order the results of the query to the multidimensional data source.
10. The computer readable medium of claim 1 wherein the generator is a generator for a hierarchy or a level.
11. The computer readable medium of claim 1 wherein the generator is a generator for a family.
12. The computer readable medium of claim 1 wherein the generator is a generator for a descendent tree.
13. The computer readable medium of claim 1 further comprising executable instructions to:
remove one or more elements from the multidimensional data source query by replacing the one or more elements with a generator defining a plurality of members to be excluded from the rationalized query and wherein the generator is a generator for except logic.
converting a plurality of objects, each object including metadata associated with a piece of data in a multidimensional data source, into a query to the multidimensional data source; and
rationalizing the query to create a rationalized query.
15. The method of claim 14 further comprising running the rationalized query against the multidimensional data source.
16. The method of claim 15 further comprising returning a set of results associated with the rationalized query.
17. A computer readable medium storing executable instructions, comprising executable instructions to:
receive a Multidimensional Expressions (MDX) query recursively rationalize the MDX query to form a rationalized query;
apply the rationalized query to a multidimensional data source to produce query results; and
18. The computer readable medium of claim 17 wherein the executable instructions to recursively rationalize the MDX query include executable instructions to substitute query elements with generators.
19. The computer readable medium of claim 18 wherein the generator corresponds to one of: a hierarchy, a level, a family, or a descendent tree.
20. The computer readable medium of claim 17 further comprising executable instructions to order the query results.
US11435554 2006-05-16 2006-05-16 Apparatus and method for recursively rationalizing data source queries Active 2026-10-23 US7698257B2 (en)
US11435554 US7698257B2 (en) 2006-05-16 2006-05-16 Apparatus and method for recursively rationalizing data source queries
PCT/US2007/067332 WO2007136959A3 (en) 2006-05-16 2007-04-24 Apparatus and method for recursively rationalizing data source queries
US20070271227A1 true true US20070271227A1 (en) 2007-11-22
US7698257B2 US7698257B2 (en) 2010-04-13
ID=38713144
US11435554 Active 2026-10-23 US7698257B2 (en) 2006-05-16 2006-05-16 Apparatus and method for recursively rationalizing data source queries
US (1) US7698257B2 (en)
WO (1) WO2007136959A3 (en)
CA2742315A1 (en) * 2008-10-31 2010-05-06 M-Factor, Inc. Method and apparatus for configurable model-independent decomposition of a business metric
WO2007136959A2 (en) 2007-11-29 application
US7698257B2 (en) 2010-04-13 grant
WO2007136959A3 (en) 2008-08-28 application
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:MOMEN-POUR, SOROUSH;COX, REUBEN MICHAEL ARTHUR;ARESKOUG, HENRIK;AND OTHERS;REEL/FRAME:018245/0411;SIGNING DATES FROM 20060515 TO 20060904
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:MOMEN-POUR, SOROUSH;COX, REUBEN MICHAEL ARTHUR;ARESKOUG, HENRIK;AND OTHERS;SIGNING DATES FROM 20060515 TO 20060904;REEL/FRAME:018245/0411