MDX函数（官方顺序）
1. AddCalculatedMembers (MDX)
返回通过将计算成员添加到指定集而生成的集。
语法：
AddCalculatedMembers(Set_Expression)
参数：
Set_Expression
返回集的有效多维表达式 (MDX)。
默认情况下，MDX在解析集函数时会排除计算成员。AddCalculatedMembers 函数会检查 Set_Expression, 中所指定的集表达式，并包括与该集表达式作用域内所含成员处于同级的计算成员。
此函数只能与一维集表达式一起使用。
示例：
示例1：
-- This query returns the calculated members for the cube
-- by retrieving all members, and then excluding non-calculated members.
SELECT
AddCalculatedMembers(
{[Measures].Members}
)-[Measures].Members ON COLUMNS
FROM [Adventure Works]
示例2：
从 Adventure Works 多维数据集中除了返回 Measures 维度中的所有计算成员外，还返回 Measures.[Unit Price] 成员。
SELECT
AddCalculatedMembers({Measures.[Unit Price]}) ON COLUMNS
FROM
[Adventure Works]
2. Aggregate (MDX)
返回一个数字，该数字是通过对集表达式返回的单元进行聚合而算出的。 如果未提供数值表达式，此函数将使用为每个度量值指定的默认聚合运算符来聚合当前查询上下文中的每个度量值。 如果指定了数值表达式，此函数将先计算指定集中的每个单元的数值表达式，然后再求和。
语法：
Aggregate(Set_Expression [ ,Numeric_Expression ])
参数：
Set_Expression
返回集的有效多维表达式 (MDX)。
Numeric_Expression
通常是单元坐标（返回数字）的多维表达式 (MDX) 的有效数值表达式。
注释：
如果指定了一组空元组或一个空集，则此函数返回一个空值。
下表说明了与不同的聚合函数结合使用时 Aggregate 函数的行为有何不同。
|
聚合运算符 |
结果 |
|
Sum |
返回对集求得的值之和。 |
|
Count |
返回对集求得的值数。 |
|
Max |
返回对集求得的最大值。 |
|
Min |
返回对集求得的最小值。 |
|
半累加性聚合函数 |
返回将形状投影到时间轴后，对集进行的半累加性计算。 |
|
非重复计数 |
当切片器轴包括某个集时，构成子多维数据集的事实数据的聚合。 为集的每个成员返回非重复计数。 结果取决于正在聚合的单元的安全性而不是需要计算的单元的安全性。 集的单元安全性生成错误；低于指定集的粒度的单元安全性将被忽略。 对集进行计算会生成错误。 集粒度以下的计算将被忽略。 当集包含一个成员及其一个或多个子级时，对该集进行的非重复计数将返回跨越子成员事实数据范围的非重复计数。 |
|
不能聚合的属性 |
返回值之和。 |
|
混合式聚合函数 |
不支持这种聚合函数，将生成错误。 |
|
一元运算符 |
不遵从；通过求和聚合值。 |
|
计算度量值 |
设置求解次序以确保应用计算度量值。 |
|
计算成员 |
应用一般规则，即最后一个求解次序优先。 |
|
分配 |
分配根据度量值聚合函数聚合。 如果度量值聚合函数是非重复计数，则对分配求和。 |
示例：
示例1：
下面的示例将从 Adventure Works 多维数据集中返回在 2003 日历年前八个月（包含在 Date 维度中）聚合的 Measures.[Order Quantity] 成员之和。
WITH MEMBER [Date].[Calendar].[First8Months2003] AS
Aggregate(
PeriodsToDate(
[Date].[Calendar].[Calendar Year],
[Date].[Calendar].[Month].[August 2003]
)
)
SELECT
[Date].[Calendar].[First8Months2003] ON COLUMNS,
[Product].[Category].Children ON ROWS
FROM
[Adventure Works]
WHERE
[Measures].[Order Quantity]
示例2：下面的示例对 2003 日历年第二个半期的前两个月聚合。
WITH MEMBER [Date].[Calendar].[First2MonthsSecondSemester2003] AS
Aggregate(
PeriodsToDate(
[Date].[Calendar].[Calendar Semester],
[Date].[Calendar].[Month].[August 2003]
)
)
SELECT
[Date].[Calendar].[First2MonthsSecondSemester2003] ON COLUMNS,
[Product].[Category].Children ON ROWS
FROM
[Adventure Works]
WHERE
[Measures].[Order Quantity]
示例3：
下面的示例根据用 Aggregate 函数计算的用户选择的 State-Province 成员值，返回上一个时期销售额下滑的分销商的计数。 Hierarchize 和DrillDownLevel 函数用于为 Product 维度中销售额下滑的产品类别返回值。
WITH MEMBER Measures.[Declining Reseller Sales] AS
Count(
Filter(
Existing(Reseller.Reseller.Reseller),
[Measures].[Reseller Sales Amount] < ([Measures].[Reseller Sales Amount],
[Date].Calendar.PrevMember)
)
)
MEMBER [Geography].[State-Province].x AS
Aggregate (
{[Geography].[State-Province].&[WA]&[US],
[Geography].[State-Province].&[OR]&[US] }
)
SELECT NON EMPTY Hierarchize (
AddCalculatedMembers (
{DrillDownLevel({[Product].[All Products]})}
)
)
DIMENSION PROPERTIES PARENT_UNIQUE_NAME ON COLUMNS
FROM [Adventure Works]
WHERE ([Geography].[State-Province].x,
[Date].[Calendar].[Calendar Quarter].&[2003]&[4],
[Measures].[Declining Reseller Sales])
3. AllMembers (MDX)
计算层次结构或级别表达式，并返回一个包含指定层次结构或级别的所有成员的集，该集包含层次结构或级别的所有计算成员。
语法：
Hierarchy syntax
Hierarchy_Expression.AllMembers
Level syntax
Level_Expression.AllMembers
参数：
Hierarchy_Expression
返回层次结构的有效多维表达式 (MDX)。
Level_Expression
返回级别的有效多维表达式 (MDX)。
注释：
AllMembers 函数返回的集包含指定层次结构或者级别的所有成员（包括计算成员）。 即使指定的层次结构或级别不包含可见的成员，AllMembers 函数仍然会返回计算成员。
|
重要提示： |
|
如果维度仅包含单个可见层次结构，由于在此情况下维度名称将解析为其唯一可见的层次结构，所以既可以通过维度名称也可以通过层次结构名称来引用该层次。 例如，因为 Measures.AllMembers 解析为 Measures 维度中唯一的层次结构，所以它是有效的 MDX 表达式。 |
|
注意 |
|
AllMembers 函数在语义上与 AddCalculatedMembers (MDX) 函数相似。 |
示例：
示例1：
下例从 Adventure Works 多维数据集中返回列轴上 [Date].[Calendar Year] 属性层次结构中的所有成员（包括计算成员）以及行轴上 [Product].[Model Name] 属性层次结构的所有子级集。
SELECT
[Date].[Calendar Year].AllMembers ON COLUMNS,
[Product].[Model Name].Children ON ROWS
FROM
[Adventure Works]
示例2
下例从 Adventure Works 多维数据集中返回列轴上度量值维度的所有成员（包括所有计算成员）以及行轴上的 [Product].[Model Name] 属性层次结构的所有子级集
SELECT
Measures.AllMembers ON COLUMNS,
[Product].[Model Name].Children ON ROWS
FROM
[Adventure Works]
4. Ancestor (MDX)
此函数返回指定成员在指定级别或距离处的祖先
语法：
Level syntax
Ancestor(Member_Expression, Level_Expression)
Numeric syntax
Ancestor(Member_Expression, Distance)
参数：
Member_Expression
返回成员的有效多维表达式 (MDX)。
Level_Expression
返回级别的有效多维表达式 (MDX)。
Distance
指定距指定成员距离的有效数值表达式。
注释：
使用 Ancestor 函数时，应为该函数提供 MDX 成员表达式，并提供该成员的祖先所在级别的 MDX 表达式或表示该成员之上有几个级别的数值表达式。 借助此信息，Ancestors 函数将返回该级别处的祖先成员。
|
注意 |
|
若要返回包含祖先成员的集，而不只是祖先成员，请使用 Ancestors (MDX) 函数 |
如果指定了级别表达式，则 Ancestor 函数返回指定成员在指定级别处的祖先。 如果指定成员与指定级别不在同一个层次结构中，该函数将返回错误。
如果指定了距离，则 Ancestor 函数返回层次结构中比成员表达式高出指定步骤数的指定成员的祖先。 可以将成员指定为属性层次结构的成员或用户定义层次结构的成员，有时还可以指定为父子层次结构的成员。 数值 1 返回成员的父成员，数值 2 返回成员的祖父成员（如果存在）。 数值 0 返回成员本身。
|
注意 |
|
Ancestor 函数的这一形式适用于父成员级别未知或无法命名的情况。 |
示例：
示例1：
下面的示例使用一个级别表达式，并返回 Australia 中每个 State-Province 的 Internet Sales Amount 及其占 Australia 总 Internet Sales Amount 的百分比。
WITH MEMBER Measures.x AS [Measures].[Internet Sales Amount] /
(
[Measures].[Internet Sales Amount],
Ancestor
(
[Customer].[Customer Geography].CurrentMember,
[Customer].[Customer Geography].[Country]
)
), FORMAT_STRING = '0%'
SELECT {[Measures].[Internet Sales Amount], Measures.x} ON 0,
{
Descendants
(
[Customer].[Customer Geography].[Country].&[Australia],
[Customer].[Customer Geography].[State-Province], SELF
)
} ON 1
FROM [Adventure Works]
示例2：
下面的示例使用一个数值表达式，并返回 Australia 中每个 State-Province 的 Internet Sales Amount 及其占所有国家总 Internet Sales Amount 的百分比。
WITH MEMBER Measures.x AS [Measures].[Internet Sales Amount] /
(
[Measures].[Internet Sales Amount],
Ancestor
([Customer].[Customer Geography].CurrentMember, 2)
), FORMAT_STRING = '0%'
SELECT {[Measures].[Internet Sales Amount], Measures.x} ON 0,
{
Descendants
(
[Customer].[Customer Geography].[Country].&[Australia],
[Customer].[Customer Geography].[State-Province], SELF
)
} ON 1
FROM [Adventure Works]
5. Ancestors (MDX)
此函数返回指定成员在指定级别或距离处的所有祖先的集。 使用 Microsoft SQL Server Analysis Services 时，返回的集将总是由单个成员组成，Analysis Services 不支持单个成员具有多个父成员。
语法：
Level syntax
Ancestors(Member_Expression, Level_Expression)
Numeric syntax
Ancestors(Member_Expression, Distance)
参数:
Member_Expression
返回成员的有效多维表达式 (MDX)。
Level_Expression
返回级别的有效多维表达式 (MDX)。
Distance
指定距指定成员距离的有效数值表达式。
注释：
使用 Ancestors 函数时，应为该函数提供 MDX 成员表达式，并提供该成员的祖先所在级别的 MDX 表达式或表示该成员之上有几个级别的数值表达式。 借助此信息，Ancestors 函数将返回该级别处的成员集，它是由一个成员组成的集。
注意：
若要返回祖先成员而不是祖先集，请使用 Ancestor 函数。
如果指定了级别表达式，则 Ancestors 函数返回指定成员在指定级别处的所有祖先的集。 如果指定成员与指定级别不在同一个层次结构中，该函数将返回错误。
如果指定了距离，则 Ancestors 函数返回层次结构中比成员表达式高出指定步骤数的所有成员的集。 可以将成员指定为属性层次结构的成员或用户定义层次结构的成员，有时还可以指定为父子层次结构的成员。 数值 1 返回父级别处的成员集，数值 2 返回祖父级别处（如果存在）的成员集。数值 0 返回仅包含成员本身的集。
注意：
Ancestors 函数的这一形式适用于父成员级别未知或无法命名的情况。
示例：
示例1：
下面的示例使用 Ancestors 函数返回成员、其父成员及祖父成员的 Internet Sales Amount 度量值。 此例使用级别表达式指定要返回的级别。 这些级别与成员表达式中指定的成员在同一个层次结构中。
SELECT {
Ancestors([Product].[Product Categories].[Product].[Mountain-100 Silver, 38],[Product].[Product Categories].[Category]),
Ancestors([Product].[Product Categories].[Product].[Mountain-100 Silver, 38],[Product].[Product Categories].[Subcategory]),
Ancestors([Product].[Product Categories].[Product].[Mountain-100 Silver, 38],[Product].[Product Categories].[Product])
} ON 0,
[Measures].[Internet Sales Amount] ON 1
FROM [Adventure Works]
示例2：
下面的示例使用 Ancestors 函数返回成员、其父成员及祖父成员的 Internet Sales Amount 度量值。 此例使用数值表达式指定要返回的级别。 这些级别与成员表达式中指定的成员在同一个层次结构中。
SELECT {
Ancestors(
[Product].[Product Categories].[Product].[Mountain-100 Silver, 38],2
),
Ancestors(
[Product].[Product Categories].[Product].[Mountain-100 Silver, 38],1
),
Ancestors(
[Product].[Product Categories].[Product].[Mountain-100 Silver, 38],0
)
} ON 0,
[Measures].[Internet Sales Amount] ON 1
FROM [Adventure Works]
示例3：
下面的示例使用 Ancestors 函数返回属性层次结构成员的父成员的 Internet Sales Amount 度量值。 此例使用数值表达式指定要返回的级别。 由于成员表达式中的成员是属性层次结构的成员，因此其父成员是“(全部)”级别。
SELECT {
Ancestors(
[Product].[Product].[Mountain-100 Silver, 38],1
)
} ON 0,
[Measures].[Internet Sales Amount] ON 1
FROM [Adventure Works]
6. Ascendants (MDX)
返回指定成员的祖先集，包括该成员本身。
语法：
Ascendants(Member_Expression)
参数：
Member_Expression
返回成员的有效多维表达式 (MDX)。
注释：
Ascendants 函数返回从某一成员本身向上直到该成员的层次结构顶层的该成员的所有祖先；更具体来讲，它对指定成员的层次结构执行后序遍历，然后在集中返回与该成员相关的所有祖先成员，其中包括该成员本身。 这与 Ancestor 函数相反，后者返回位于特定级别的特定祖先成员或祖先。
示例：
下面的示例从 Adventure Works 多维数据集中返回 [Sales Territory].[Northwest] 成员的分销商订单计数以及该成员的所有祖先。 Ascendants函数构造的集包括 [Sales Territory].[Northwest] 成员及其在 ROWS 轴上的祖先。
SELECT
Measures.[Reseller Order Count] ON COLUMNS,
Order(
Ascendants(
[Sales Territory].[Northwest]
),
DESC
) ON ROWS
FROM
[Adventure Works]
7. Avg (MDX)
对集求值，并返回该集中的单元的非空值的平均值，此平均值是对该集中的度量值或指定度量值求得的平均值。
语法：
Avg( Set_Expression [ , Numeric_Expression ] )
参数：
Set_Expression
返回集的有效多维表达式 (MDX)
Numeric_Expression
有效的数值表达式，通常为返回数值的单元坐标的多维表达式 (MDX)。
注释：
如果指定了一组空元组或一个空集，则 Avg 函数返回一个空值。
Avg 函数首先计算指定集中的所有单元值之和，然后将计算出的和除以该集中的非空单元数，从而计算出指定集单元中的非空值的平均值。
|
注释： |
|
计算一组数值的平均值时，Analysis Services 将忽略 Null 值。 |
如果未指定特定数值表达式（通常为度量值），则 Avg 函数在当前查询上下文中计算每个度量值的平均值。 如果指定了度量值，则 Avg 函数首先计算该集的度量值，然后对指定的度量值计算平均值。
注释：
在计算成员语句中使用 CurrentMember 函数时，必须指定数值表达式，因为在这种查询上下文的当前坐标中不存在任何默认度量值。
若要强制包含空单元，应用程序必须使用 CoalesceEmpty 函数，或指定一个有效的 Numeric_Expression 以提供零 (0) 作为空值。 有关空单元的详细信息，请参阅 OLE DB 文档。
示例：
示例1：
下面的示例对指定集返回度量值的平均值。 请注意，指定度量值可以是指定集的成员的默认度量值，也可以是指定的度量值。
WITH SET [NW Region] AS
{[Geography].[State-Province].[Washington]
, [Geography].[State-Province].[Oregon]
, [Geography].[State-Province].[Idaho]}
MEMBER [Geography].[Geography].[NW Region Avg] AS
AVG ([NW Region]
--Uncomment the line below to get an average by Reseller Gross Profit Margin
--otherwise the average will be by whatever the default measure is in the cube,
--or whatever measure is specified in the query
--, [Measures].[Reseller Gross Profit Margin]
)
SELECT [Date].[Calendar Year].[Calendar Year].Members ON 0
FROM [Adventure Works]
WHERE ([Geography].[Geography].[NW Region Avg])
示例2：
以下示例从 Adventure Works 多维数据集中返回 Measures.[Gross Profit Margin] 度量值的日平均值，该值是根据 2003 会计年度中每个月的所有日期计算出的。 Avg 函数从 [Ship Date].[Fiscal Time] 层次结构中每个月所包含的所有日期的集中计算平均值。 第一种形式的计算演示 Avg 将未记录任何销售额的天数从平均值计算中排除的默认行为，第二种形式的计算演示如何将没有销售额的天数包含在平均值计算中。
WITH MEMBER Measures.[Avg Gross Profit Margin] AS
Avg(
Descendants(
[Ship Date].[Fiscal].CurrentMember,
[Ship Date].[Fiscal].[Date]
),
Measures.[Gross Profit Margin]
), format_String='percent'
MEMBER Measures.[Avg Gross Profit Margin Including Empty Days] AS
Avg(
Descendants(
[Ship Date].[Fiscal].CurrentMember,
[Ship Date].[Fiscal].[Date]
),
CoalesceEmpty(Measures.[Gross Profit Margin],0)
), Format_String='percent'
SELECT
{Measures.[Avg Gross Profit Margin],Measures.[Avg Gross Profit Margin Including Empty Days]} ON COLUMNS,
[Ship Date].[Fiscal].[Fiscal Year].Members ON ROWS
FROM
[Adventure Works]
WHERE([Product].[Product Categories].[Product].&[344])
示例3：
以下示例将从 Adventure Works 多维数据集中返回 Measures.[Gross Profit Margin] 度量值的日平均值，该值是根据 2003 会计年度中每个半期的所有日期计算出来的。
WITH MEMBER Measures.[Avg Gross Profit Margin] AS
Avg(
Descendants(
[Ship Date].[Fiscal].CurrentMember,
[Ship Date].[Fiscal].[Date]
),
Measures.[Gross Profit Margin]
)
SELECT
Measures.[Avg Gross Profit Margin] ON COLUMNS,
[Ship Date].[Fiscal].[Fiscal Year].[FY 2003].Children ON ROWS
FROM
[Adventure Works]
8. Axis (MDX)
返回指定轴上的元组集。
语法：
Axis(Axis_Number)
参数：
Axis_Number
指定轴号的有效数值表达式。
注释：
Axis 函数使用某个轴的从零开始的位置返回轴上的元组集。 例如，Axis(0) 返回 COLUMNS 轴，Axis(1) 返回 ROWS 轴，等等。 Axis 函数不能用于筛选轴。 此函数可用于使计算成员识别正在运行的查询的上下文。 例如，您可能需要一个计算成员，该成员仅提供行轴上所选那些成员的总和。它还可用于使一个轴的定义依赖于另一个轴的定义。 例如，根据列轴上第一项的值对行轴的内容进行排序。
|
注意 |
|
轴只能引用先前的某个轴。 例如，对 COLUMNS 轴求值后，必然出现 Axis(0)（例如，在 ROW 或 PAGE 轴上）。 |
示例：
示例1：
以下示例查询说明如何使用 Axis 函数：
WITH MEMBER MEASURES.AXISDEMO AS
SETTOSTR(AXIS(1))
SELECT MEASURES.AXISDEMO ON 0,
[Date].[Calendar Year].MEMBERS ON 1
FROM [Adventure Works]
示例2：
以下示例说明如何在计算成员内使用 Axis 函数：
WITH MEMBER MEASURES.AXISDEMO AS
SUM(AXIS(1), [Measures].[Internet Sales Amount])
SELECT {[Measures].[Internet Sales Amount],MEASURES.AXISDEMO} ON 0,
{[Date].[Calendar Year].&[2003], [Date].[Calendar Year].&[2004]} ON 1
FROM [Adventure Works]
9. BottomCount (MDX)
按升序对集进行排序，并返回指定集中具有最小值的指定数目的元组。
语法：
BottomCount(Set_Expression, Count [,Numeric_Expression])
参数：
Set_Expression
返回集的有效多维表达式 (MDX)。
Count
指定要返回的元组数的有效数值表达式。
Numeric_Expression
一个有效的数值表达式，通常为返回一个数值的单元坐标的多维表达式 (MDX)。
注释：
如果指定了数值表达式，则此函数根据在指定集中计算出的指定数值表达式的值，对指定集中的元组按升序进行排序。 然后，BottomCount 函数将返回具有最小值的、指定数目的元组。
|
重要提示 |
|
与 TopCount 函数一样，BottomCount 函数总是会打乱层次结构。 |
如果未指定数值表达式，则函数按照自然顺序返回成员集，而不进行任何排序，其行为如同 Tail (MDX) 函数。
示例：
下例将返回每个日历年中最后五个“产品子类别”销售额的“分销商订单数量”度量值，并根据“分销商销售额”度量值进行排序。
SELECT BottomCount([Product].[Product Categories].[Subcategory].Members
, 10
, [Measures].[Reseller Sales Amount]) ON 0,
[Date].[Calendar].[Calendar Year].Members ON 1
FROM
[Adventure Works]
WHERE
[Measures].[Reseller Order Quantity]
10 . BottomPercent (MDX)
按升序对集进行排序，并返回一个最小值元组集，该元组集的累积合计等于或大于指定的百分比。
语法：
BottomPercent(Set_Expression, Percentage, Numeric_Expression)
参数：
Set_Expression
返回集的有效多维表达式 (MDX)。
Percentage
指定要返回的元组数的有效数值表达式。
Numeric_Expression
有效数值表达式，通常为返回数值的单元坐标的多维表达式 (MDX)。
注释：
BottomPercent 函数对指定集求得的指定数值表达式求和，同时对指定集按升序排序。 然后，该函数返回合计值累积百分比至少达到指定百分比的最小值元素。 该函数返回累积合计至少达到指定百分比的最小子集。 返回的元素从大到小排序。
|
重要提示 |
|
与 TopPercent 函数一样，BottomPercent 函数总是会打乱层次结构。 有关详细信息，请参阅 Order 函数。 |
示例：
示例1：
下面的示例返回 2003 会计年度 Geography 维度 Geography 层次结构中 City 级别的最小成员集（对于 Bike 类别），其 Reseller Sales Amount 度量值的累积合计至少是累积合计的 15%（从具有最小销售额的集的成员开始）。
SELECT
[Product].[Product Categories].Bikes ON 0,
BottomPercent
({[Geography].[Geography].[City].Members}
, 15
, ([Measures].[Reseller Sales Amount],[Product].[Product Categories].Bikes)
) ON 1
FROM [Adventure Works]
WHERE ([Measures].[Reseller Sales Amount],[Date].[Fiscal].[Fiscal Year].[FY 2003])
11 . BottomSum (MDX)
按升序对指定集进行排序，并返回一个最小值元组集，这些元组的和等于或小于指定值。
语法：
BottomSum(Set_Expression, Value, Numeric_Expression)
参数：
Set_Expression
返回集的有效多维表达式 (MDX)。
Value
指定与每个元组相比较的值的有效数值表达式。
Numeric_Expression
有效数值表达式，通常是一个关于单元坐标（返回数值）的 MDX（多维表达式）表达式。
注释：
BottomSum 函数对指定集中的指定度量值求和，同时对指定集按升序排序。 然后，此函数返回最小值元素，其指定数值表达式的合计至少为指定值（和）。 此函数返回集的最小子集，其累积合计至少为指定值。 返回的元素按从小到大的顺序排列。
|
重要提示 |
|
与 TopSum 函数一样，BottomSum 函数总是会打乱层次结构。 |
示例：
以下示例返回 2003 会计年度 Geography 维度 Geography 层次结构中 City 级别的最小成员集（对于 Bike 类别），其使用 Reseller Sales Amount 度量值的累积合计至少是 50,000（从具有最小销售额的集的成员开始）：
SELECT
[Product].[Product Categories].Bikes ON 0,
BottomSum
({[Geography].[Geography].[City].Members}
, 50000
, ([Measures].[Reseller Sales Amount],[Product].[Product Categories].Bikes)
) ON 1
FROM [Adventure Works]
WHERE([Measures].[Reseller Sales Amount],[Date].[Fiscal].[Fiscal Year].[FY 2003])
12 . CalculationCurrentPass (MDX)
针对指定的查询上下文返回多维数据集的当前计算传递。
语法：
CalculationCurrentPass()
注释：
CalculationCurrentPass 函数针对当前查询上下文返回计算传递的索引（从零开始计算）。 对于 SQL Server Analysis Services 中的自动递归解决方法，此函数的用处不大。
13 . CalculationPassValue (MDX)
返回用多维表达式 (MDX) 对多维数据集的指定计算传递求得的数值或字符串值。
语法：
Numeric syntax
CalculationPassValue(Numeric_Expression,Pass_Value [, ABSOLUTE | RELATIVE [,ALL]])
String syntax
CalculationPassValue(String_Expression ,Pass_Value [, ABSOLUTE | RELATIVE [,ALL]])
参数：
Numeric_Expression
通常是单元坐标（返回数字）的多维表达式 (MDX) 的有效数值表达式。
String_Expression
一个有效的字符串表达式，通常为返回一个数字（表示为字符串）的单元坐标的有效多维表达式 (MDX)。
Pass_Value
指定计算传递数的有效数值表达式。
ABSOLUTE
一个访问标志值，规定 Pass_Value 参数包含计算传递的从零开始的索引。 如果未指定访问标志值，则 ABSOLUTE 将作为默认访问标志值。
RELATIVE
一个访问标志值，规定 Pass_Value 参数包含从触发计算的计算传递开始的相对偏移量。 如果偏移量解析为某个小于 0 的计算传递索引，则使用计算传递 0，并且不会出错。
ALL
如果设置此标志，则除了存储引擎加载的值外，其余值均为空值。 如果未设置此标志，则聚合这些值而不进行任何计算
注释：
如果提供了数值表达式，则函数通过计算指定计算传递中的指定 MDX 数值表达式来返回一个数值，或者通过访问标志以及访问标志修饰符对其进行修改。
如果提供了字符串表达式，则函数通过计算指定计算传递中的指定 MDX 字符串表达式来返回一个字符串值，或者通过访问标志以及访问标志修饰符 . 对其进行更改
对于 SQL Server Analysis Services 中的自动递归解决方法，此函数的用处不大。
|
注意 |
|
只有管理员可以在 MDX 脚本中使用 CalculationPassValue 函数。 如果在不具有管理员特权的角色上下文中运行包含此函数的 MDX 脚本，则会发生错误。 |
14 . CASE 语句 (MDX)
允许您有条件地从多次比较中返回特定值。 有两种类型的 Case 语句：
简单 Case 语句将某个表达式与一组简单表达式进行比较，以返回特定的值。
搜索 Case 语句计算一组布尔表达式，以返回特定的值
语法：
Simple Case Statement
CASE [input_expression]
WHEN when_expression THEN when_true_result_expression
[...n]
[ELSE else_result_expression]
END
Search Case Statement
CASE
WHEN Boolean_expression THEN when_true_result_expression
[...n]
[ELSE else_result_expression]
END
参数：
input_expression
解析为标量值的多维表达式 (MDX)。
when_expression
用于计算 input_expression 的指定标量值，当计算结果为 True 时，返回 else_result_expression 的标量值。
when_true_result_expression
当 WHEN 子句计算结果为 True 时返回的标量值。
else_result_expression
当没有任何 WHEN 子句的计算结果为 True 时返回的标量值。
Boolean_expression
计算结果为标量值的 MDX 表达式。
注释：
如果没有 ELSE 子句，而且所有 WHEN 子句的计算结果都为 False，则结果是空单元。
简单 Case 表达式
MDX 通过将 input_expression 解析为标量值来计算简单 Case 表达式。 然后，将该标量值与 when_expression 的标量值进行比较。 如果这两个标量值匹配，则 CASE 语句返回 when_true_expression 的值。 如果这两个标量值不匹配，则计算下一个 WHEN 子句。 如果所有的 WHEN 子句计算结果均为 False，则返回来自 ELSE 子句的 else_result_expression 的值（如果存在 ELSE 子句）。
示例：
在下例中，对几个 WHEN 子句计算 Reseller Order Count 度量值，并且基于每年的 Reseller Order Count 度量值的值返回一个结果。 如果 Reseller Order Count 值与 WHEN 子句中的 when_expression 指定的标量值不匹配，则返回 else_result_expression 的标量值。
WITH MEMBER [Measures].x AS
CASE [Measures].[Reseller Order Count]
WHEN 0 THEN 'NONE'
WHEN 1 THEN 'SMALL'
WHEN 2 THEN 'SMALL'
WHEN 3 THEN 'MEDIUM'
WHEN 4 THEN 'MEDIUM'
WHEN 5 THEN 'LARGE'
WHEN 6 THEN 'LARGE'
ELSE 'VERY LARGE'
END
SELECT Calendar.[Calendar Year] on 0
, NON EMPTY [Geography].[Postal Code].Members ON 1
FROM [Adventure Works]
WHERE [Measures].x
Case 搜索表达式
若要使用 Case 表达式执行更为复杂的计算，请使用 Case 搜索表达式。 使用此搜索表达式的变体可以计算输入表达式是否位于一个值范围内。MDX 按 WHEN 子句出现在 CASE 语句中的顺序计算这些子句。
下例中，为每个 WHEN 子句针对指定的 Boolean_expression 计算 Reseller Order Count 度量值。 根据每年的 Reseller Order Count 度量值的值返回一个结果。 因为按照 WHEN 子句出现的顺序计算这些子句，所以可简单地将所有大于 6 的值赋值为“VERY LARGE”，而无需显式地指定每个值。 对于没有在 WHEN 子句内指定的 Reseller Order Count 值，则返回 else_result_expression 的标量值。
WITH MEMBER [Measures].x AS
CASE
WHEN [Measures].[Reseller Order Count] > 6 THEN 'VERY LARGE'
WHEN [Measures].[Reseller Order Count] > 4 THEN 'LARGE'
WHEN [Measures].[Reseller Order Count] > 2 THEN 'MEDIUM'
WHEN [Measures].[Reseller Order Count] > 0 THEN 'SMALL'
ELSE "NONE"
END
SELECT Calendar.[Calendar Year] on 0,
NON EMPTY [Geography].[Postal Code].Members on 1
FROM [Adventure Works]
WHERE [Measures].x
15 . Children（MDX）
返回指定成员的子成员集。
语法：
Member_Expression.Children
参数：
Member_Expression
返回成员的有效多维表达式 (MDX)。
注释：
Children 函数返回一个自然排序的集，该集包含指定成员的子成员。 如果指定的成员没有子成员，则此函数返回一个空集。
示例：
1 .下例将返回 Geography 维度中 Geography 层次结构的 United States 成员的子成员。SELECT [Geography].[Geography].[Country].&[United States].Children ON 0
FROM [Adventure Works]
2 . 下例从 Adventure Works 多维数据集中返回列轴上 Measures 维度的所有成员（包括所有计算成员）以及行轴上 [Product].[Model Name] 属性层次结构的所有子级集。
SELECT
Measures.AllMembers ON COLUMNS,
[Product].[Model Name].Children ON ROWS
FROM
[Adventure Works]
16 . ColsingPeriod(MDX)
返回指定成员在指定级别的后代中的最后一个同级成员
语法：
ClosingPeriod( [ Level_Expression [ ,Member_Expression ] ] )
参数：
Level_Expression
返回级别的有效多维表达式 (MDX)。
Member_Expression
返回成员的有效多维表达式 (MDX)
注释：
此函数主要用于具有 Time 类型的维度，但也可用于任何维度。
l 如果指定了级别表达式，ClosingPeriod 函数将使用包含指定级别的维度，并返回默认成员在指定级别处的后代中的最后一个同级成员。
l 如果同时指定了级别表达式和成员表达式，ClosingPeriod 函数将返回指定成员在指定级别处的后代中的最后一个同级成员。
l 如果级别表达式和成员表达式均未指定，ClosingPeriod 函数将使用多维数据集中 Time 类型维度（如果有）的默认级别和成员。
ClosingPeriod 函数等效于下面的 MDX 语句：
Tail(Descendants(Member_Expression, Level_Expression), 1).
|
注意 |
|
OpeningPeriod 函数与 ClosingPeriod 函数相似，只不过 OpeningPeriod 函数返回的是第一个同级而不是最后一个同级。 |
示例：
1.下面的示例返回 Date 维度（具有 Time 语义类型）的“FY2007”成员的默认度量值。 返回此成员是因为：“会计年度”级别是“(全部)”级别的第一个后代；“Fiscal”层次结构是默认层次结构（因为它是层次结构集合中的第一个用户定义的层次结构）；而且“FY 2007”成员是此层次结构在此级别处的最后一个同级成员。
SELECT ClosingPeriod() ON 0
FROM [Adventure Works]
2.下面的示例返回“November 30, 2006”成员在 Date.Date 属性层次结构的 Date.Date.Date 级别处的默认度量值。 此成员是 Date.Date 属性层次结构中“(全部)”级别的后代的最后一个同级成员。
SELECT ClosingPeriod ([Date].[Date].[Date]) ON 0
FROM [Adventure Works]
3.下例返回“December, 2003”成员的默认度量值。该成员是用户定义的层次结构“Calendar”中年份级别成员“2003”的后代的最后一个同级成员。
SELECT ClosingPeriod ([Date].[Calendar].[Month],[Date].[Calendar].[Calendar Year].&[2003]) ON 0
FROM [Adventure Works]
4．下面的示例返回“June, 2003”成员的默认度量值，该成员是用户定义的层次结构“Fiscal”中年份级别成员“2003”的后代的最后一个同级成员。
SELECT ClosingPeriod ([Date].[Fiscal].[Month],[Date].[Fiscal].[Fiscal Year].&[2003]) ON 0
FROM [Adventure Works]
17. CoalesceEmpty (MDX)
将空单元值转换为指定的非空单元值，该值可以是数字或字符串。
语法：
Numeric syntax
CoalesceEmpty( Numeric_Expression1 [ ,Numeric_Expression2,...n] )
String syntax
CoalesceEmpty(String_Expression1 [ ,String_Expression2,...n] )
参数：
Numeric_Expression1
通常是单元坐标（返回数字）的多维表达式 (MDX) 的有效数值表达式。
Numeric_Expression2
有效数值表达式，通常为指定的数值。
String_Expression1
有效字符串表达式，通常为返回字符串的单元坐标的多维表达式 (MDX)。
String_Expression2
有效字符串表达式，通常为指定的字符串值（该值被第一个字符串表达式返回的 NULL 代替）。
注释：
如果指定了一个或多个数值表达式，CoalesceEmpty 函数将返回可被解析为非空值的第一个（从左向右）数值表达式的值。 如果指定的所有数值表达式都不能被解析为非空值，则此函数返回空单元值。 通常情况下，第二个数值表达式的值是被第一个数值表达式返回的 NULL 代替的数值。
如果指定了一个或多个字符串表达式，此函数将返回可被解析为非空值的第一个（从左向右）字符串表达式的值。 如果指定的所有字符串表达式都不能被解析为非空值，则此函数返回空单元值。 通常情况下，第二个字符串表达式的值是被第一个字符串表达式返回的 NULL 代替的字符串值。
只能向 CoalesceEmpty 函数传递相同类型的值。 也就是说，指定的所有值表达式的值都必须为数值数据类型或空单元值，或者，指定的所有值表达式的值都必须为字符串数据类型或空单元值。 对此函数的一次调用不能同时包括数值表达式和字符串表达式。
有关空单元的详细信息，请参阅 OLE DB 文档。
示例：
下面的示例将查询 Adventure Works 多维数据集。 此示例将返回每个产品的订单数量以及按类别排列的订单数量百分比。 CoalesceEmpty 函数确保了在设置计算成员的格式时用零 (0) 来表示空值。
WITH
MEMBER [Measures].[Order Percent by Category] AS
CoalesceEmpty
(
([Product].[Product Categories].CurrentMember,
Measures.[Order Quantity]) /
(
Ancestor
( [Product].[Product Categories].CurrentMember,
[Product].[Product Categories].[Category]
), Measures.[Order Quantity]
), 0
), FORMAT_STRING='Percent'
SELECT
{Measures.[Order Quantity],
[Measures].[Order Percent by Category]} ON COLUMNS,
{[Product].[Product].Members} ON ROWS
FROM [Adventure Works]
WHERE {[Date].[Calendar Year].[Calendar Year].&[2003]}
18. Correlation (MDX)
返回对集求值的 X-Y 值对的关联系数。
语法：
Correlation( Set_Expression, Numeric_Expression_y [ ,Numeric_Expression_x ] )
参数：
Set_Expression
返回集的有效多维表达式 (MDX)。
Numeric_Expression_y
返回表示 Y 轴值的数字的有效数值表达式，通常是单元坐标的多维表达式 (MDX)。
Numeric_Expression_x
通常是单元坐标（返回代表 X 轴的值的数字）的多维表达式 (MDX) 的有效数值表达式。
注释：
Correlation 函数计算两对值的关联系数，其计算过程如下：先根据第一个数值表达式对指定集求和，以获取 Y 轴对应的值。 然后，此函数根据第二个数值表达式（如果存在）对指定集求值，以获取 X 轴对应的值。 如果未指定第二个数值表达式，则此函数使用指定集中单元的当前上下文作为 X 轴对应的值。
|
注意 |
|
Correlation 函数将忽略空单元，以及包含文本或逻辑值的单元。 但是，该函数可以包含值为零的单元。 |
19 . Count （维度）（MDX）
返回多维数据集中的层次结构数。
语法：
Dimensions.Count
注释：
返回多维数据集中的层次结构数，包括 [Measures].[Measures] 层次结构。
示例：
下面的示例返回 Adventure Works 多维数据集中的层次结构数。
WITH MEMBER measures.X AS
dimensions.count
SELECT Measures.X ON 0
FROM [Adventure Works]
20 . Count （层次结构级别）（MDX）
返回层次结构中的级别数。
语法：
Hierarchy_Expression.Levels.Count
参数：
Hierarchy_Expression
返回层次结构的有效多维表达式 (MDX)
注释:
返回层次结构中的级别数，包括 [All] 级别（如果存在）。
|
重要提示 |
|
如果维度只包含一个可见的层次结构，则可以通过此维度的名称或此层次结构的名称引用此层次结构，原因是此维度的名称会解析为它唯一可见的层次结构。 例如，Measures.Levels.Count 是一个有效的 MDX 表达式，这是因为它会解析为 Measures 维度中唯一的层次结构。 |
示例：
下面的示例返回 Adventure Works 多维数据集中 Product Categories 用户定义层次结构中的级别数计数。
WITH MEMBER measures.X AS
[Product].[Product Categories].Levels.Count
Select Measures.X ON 0
FROM [Adventure Works]
21．Count（集）
返回集中的单元数。
语法：
Standard syntax
Count(Set_Expression [ , ( EXCLUDEEMPTY | INCLUDEEMPTY ) ] )
Alternate syntax
Set_Expression.Count
参数：
Set_Expression
返回集的有效多维表达式 (MDX)
注释：
Count (Set) 函数包括还是排除空单元取决于所用的语法。 如果使用标准语法，则可以使用 EXCLUDEEMPTY 标志来排除空单元，也可以使用INCLUDEEMPTY 标志来包括空单元。 如果使用备用语法，则函数始终包括空单元。
若要从集计数中排除空单元，请使用标准语法和可选的 EXCLUDEEMPTY 标志。
|
注意 |
|
默认情况下，Count (Set) 函数会将空单元计算在内。 相反，OLE DB 中对集计数的 Count 函数默认情况下会排除空单元。 |
示例：
下例统计成员集中单元的数目，该成员集由“产品”维度中“型号名称”属性层次结构的子级构成。
WITH MEMBER measures.X AS
[Product].[Model Name].children.count
SELECT Measures.X ON 0
FROM [Adventure Works]
下例将 DrilldownLevel 函数与 Count 函数结合使用，统计“产品”维度中的产品数目。
Count(DrilldownLevel (
[Product].[Product].[Product]))
下例将 Count 函数与 Filter 函数以及其他多个函数结合使用，返回与以前日历季度相比销售额有所下降的分销商。 该查询使用 Aggregate 函数，支持选择多个地域成员，例如：从客户端应用程序中的下拉列表中进行选择。
WITH MEMBER Measures.[Declining Reseller Sales] AS
Count
(Filter
(Existing(Reseller.Reseller.Reseller),
[Measures].[Reseller Sales Amount]
< ([Measures].[Reseller Sales Amount],
[Date].Calendar.PrevMember)
)
)
MEMBER [Geography].[State-Province].x AS
Aggregate
( {[Geography].[State-Province].&[WA]&[US],
[Geography].[State-Province].&[OR]&[US] }
)
SELECT NON EMPTY HIERARCHIZE
(AddCalculatedMembers
({DrillDownLevel
({[Product].[All Products]})
})
) DIMENSION PROPERTIES PARENT_UNIQUE_NAME ON COLUMNS
FROM [Adventure Works]
WHERE ([Geography].[State-Province].x,
[Date].[Calendar].[Calendar Quarter].&[2003]&[4]
,[Measures].[Declining Reseller Sales])
22 . Count（元组）
返回元组中的维度数。
语法：
Tuple_Expression.Count
参数：
Tuple_Expression
返回元组的有效多维表达式 (MDX)。
注释:
返回元组中的维度数。
示例:
下面的查询中的计算度量值返回值 2，这是在元组 ([Measures].[Internet Sales Amount], [Date].[Calendar].[Calendar Year].&[2001]) 中提供的层次结构的数目：
WITH MEMBER MEASURES.COUNTTUPLE AS
COUNT(([Measures].[Internet Sales Amount], [Date].[Calendar].[Calendar Year].&[2001]))
SELECT MEASURES.COUNTTUPLE ON 0
FROM [Adventure Works]
23 . Cousin (MDX)
返回在父成员下方与指定子成员具有相同的相对位置的子成员。
语法：
Cousin( Member_Expression , Ancestor_Member_Expression )
参数：
Member_Expression
返回成员的有效多维表达式 (MDX)。
Ancestor_Member_Expression
返回祖先成员的有效多维表达式 (MDX) 成员表达式。
注释：
此函数按各级别内的成员的顺序和位置进行操作。 如果有两个层次结构，第一个层次结构有四个级别，第二个层次结构有五个级别，则第一个层次结构的第三个级别与第二个层次结构的第三个级别是同级。
示例：
下面的示例根据 2002 会计年度第四季度在
2003 会计年度中年级别上的祖先检索它的同级。 检索到的同级是 2003 会计年度第四季度。
SELECT Cousin
( [Date].[Fiscal].[Fiscal Quarter].[Q4 FY
2002],
[Date].[Fiscal].[FY 2003]
) ON 0
FROM [Adventure
Works]
下面的示例根据 2002 会计年度 7 月在 2004 会计年度第二季度中季度级别上的祖先检索它的同级。 检索到的同级是 2003 年 10 月。
SELECT Cousin
([Date].[Fiscal].[Month].[July 2002] ,
[Date].[Fiscal].[Fiscal Quarter].[Q2 FY
2004]
) ON 0
FROM [Adventure
Works]
24 . Covariance (MDX)
返回使用有偏差总体公式（除以 x-y 对的数目）对集求得的
x-y 值对的总体协方差。
语法：
Covariance(Set_Expression,Numeric_Expression_y
[ ,Numeric_Expression_x ] )
参数：
Set_Expression
返回集的有效多维表达式 (MDX)。
Numeric_Expression_y
返回表示 Y 轴值的数字的有效数值表达式，通常是单元坐标的多维表达式 (MDX)。
Numeric_Expression_x
有效的数值表达式，通常是单元坐标的多维表达式 (MDX)，它返回表示 x 轴值的数值。
注释：
Covariance 函数对指定的集计算第一个数值表达式，以获得 y 轴的值。 然后，此函数对指定的集计算第二个数值表达式（如果指定），以获得 x 轴的一组值。 如果未指定第二个数值表达式，则该函数使用指定集中单元的当前上下文作为 X 轴的值。
Covariance 函数使用有偏差总体公式。 这与 CovarianceN 函数相反，后者使用无偏差总体公式（除以 x-y 对的数目，然后再减 1）。
|
注意 |
|
Covariance 函数会忽略空单元以及包含文本或逻辑值的单元。 但是，该函数可以包含值为零的单元。 |
示例：
下面的示例说明如何使用
Covariance 函数：
WITH
MEMBER
[Measures].[CovarianceDemo] AS
COVARIANCE([Date].[Date].[Date].Members,
[Measures].[Internet Sales Amount], [Measures].[Internet Order Count])
SELECT
{[Measures].[CovarianceDemo]} ON 0
FROM
[Adventure Works]
25 . CovarianceN
通过使用无偏差总体公式（除以 x-y 对的数目），返回对集求得的
x-y 值对的样本协方差。
语法：
CovarianceN(Set_Expression,
Numeric_Expression_y [ ,Numeric_Expression_x ] )
参数：
Set_Expression
返回集的有效多维表达式 (MDX)。
Numeric_Expression_y
返回表示 Y 轴值的数字的有效数值表达式，通常是单元坐标的多维表达式 (MDX)。
Numeric_Expression_x
有效的数值表达式，通常是单元坐标的多维表达式 (MDX)，它返回表示 x 轴值的数值。
注释：
CovarianceN 函数根据第一个数值表达式计算指定的集，以获得 Y 轴的值。 然后，此函数对指定的集计算第二个数值表达式（如果指定），以获得 x 轴的一组值。 如果未指定第二个数值表达式，则该函数将使用指定集中单元的当前上下文作为 X 轴的值。
CovarianceN 函数使用无偏差总体公式。 这与使用有偏差总体公式（除以 X-Y 数值对）的 Covariance 函数相反。
|
注意 |
|
CovarianceN 函数将忽略空单元以及包含文本或逻辑值的单元。 但是，该函数可以包含值为零的单元。 |
26. Crossjoin (MDX)
返回一个或多个集的叉积。
语法：
Standard syntax
Crossjoin(Set_Expression1
,Set_Expression2 [,...n] )
Alternate syntax
Set_Expression1 *
Set_Expression2 [* ...n]
参数：
Set_Expression1
返回集的有效多维表达式 (MDX)。
Set_Expression2
返回集的有效多维表达式 (MDX)。
注释：
Crossjoin 函数返回两个或更多指定集的叉积。 所得集中元组的顺序取决于要联接的集的顺序以及其成员的顺序。 例如，如果第一个集由 {x1, x2,...,xn} 组成，第二个集由 {y1, y2, ..., yn} 组成，则这两个集的叉积为：
{(x1, y1), (x1,
y2),...,(x1, yn), (x2, y1), (x2, y2),...,
(x2, yn),..., (xn,
y1), (xn, y2),..., (xn, yn)}
|
重要提示 |
|
如果交叉联接中的集由同一维度中不同属性层次结构中的元组组成，此函数将只返回实际存在的那些元组。 有关详细信息，请参阅 MDX 中的重要概念 (Analysis Services)。 |
示例：
以下查询说明在查询的列轴和行轴上使用
Crossjoin 函数的简单示例：
SELECT
[Customer].[Country].Members
*
[Customer].[State-Province].Members
ON 0,
Crossjoin(
[Date].[Calendar
Year].Members,
[Product].[Category].[Category].Members)
ON 1
FROM [Adventure
Works]
WHERE
Measures.[Internet Sales Amount]
以下示例说明交叉联接同一维度中的不同层次结构时发生的自动筛选：
SELECT
Measures.[Internet
Sales Amount]
ON 0,
//Only the dates
in Calendar Years 2003 and 2004 will be returned here
Crossjoin(
{[Date].[Calendar
Year].&[2003], [Date].[Calendar Year].&[2004]},
[Date].[Date].[Date].Members)
ON 1
FROM [Adventure
Works]
以下三个示例返回相同的结果 -
United States 各州的 Internet Sales Amount（按州显示）。 前两个示例使用两个交叉联结语法，第三个示例演示了使用 WHERE 子句返回相同的信息。
示例 1
SELECT CROSSJOIN
(
{[Customer].[Country].[United States]},
[Customer].[State-Province].Members
) ON 0
FROM [Adventure
Works]
WHERE
Measures.[Internet Sales Amount]
示例 2
SELECT
[Customer].[Country].[United States] *
[Customer].[State-Province].Members
ON 0
FROM [Adventure
Works]
WHERE
Measures.[Internet Sales Amount]
示例 3
SELECT
[Customer].[State-Province].Members
ON 0
FROM [Adventure
Works]
WHERE
(Measures.[Internet Sales Amount],
[Customer].[Country].[United States])
27 . Current (MDX)
在迭代期间从集中返回当前的元组。
语法：
Set_Expression.Current
参数：
Set_Expression
返回集的有效多维表达式 (MDX)。
注释：
迭代过程的每一步中所操作的元组就是当前元组。 Current 函数返回该元组。 该函数仅在对集执行迭代的过程中有效。
遍历集的 MDX 函数包括 Generate 函数。
|
注意 |
|
该函数只能使用已命名的集（使用集别名或定义命名集）。 |
示例：
以下示例说明如何在 Generate 内部使用 Current 函数：
WITH
//Creates a set of
tuples consisting of all Calendar Years crossjoined with
//all Product
Categories
SET MyTuples AS
CROSSJOIN(
[Date].[Calendar
Year].[Calendar Year].MEMBERS,
[Product].[Category].[Category].MEMBERS)
//Iterates through
each tuple in the set and returns the name of the Calendar
//Year in each
tuple
MEMBER
MEASURES.CURRENTDEMO AS
GENERATE(MyTuples,
MyTuples.CURRENT.ITEM(0).NAME, ", ")
SELECT
MEASURES.CURRENTDEMO ON 0
FROM [Adventure
Works]
28 . CurrentMember (MDX)
在遍历过程中返回当前成员以及指定层次结构。
语法：
Hierarchy_Expression.CurrentMember
参数：
Hierarchy_Expression
返回层次结构的有效多维表达式 (MDX)。
注释：
遍历一组层次结构成员时，在遍历过程的每一步，所操作的成员就是当前成员。 CurrentMember 函数返回该成员。
|
重要提示 |
|
如果维度只包含一个可见的层次结构，则可以通过此维度的名称或此层次结构的名称引用此层次结构，原因是此维度的名称会解析为它唯一可见的层次结构。 例如，Measures.CurrentMember 是一个有效的 MDX 表达式，这是因为它会解析为 |
示例：
以下查询说明如何使用 Currentmember 来查找列、行和切片轴上层次结构中的当前成员：
WITH MEMBER
MEASURES.CURRENTDATE AS
[Date].[Calendar].CURRENTMEMBER.NAME
MEMBER
MEASURES.CURRENTPRODUCT AS
[Product].[Product
Categories].CURRENTMEMBER.NAME
MEMBER MEASURES.CURRENTMEASURE
AS
MEASURES.CURRENTMEMBER.NAME
MEMBER
MEASURES.CURRENTCUSTOMER AS
[Customer].[Customer
Geography].CURRENTMEMBER.NAME
SELECT
[Product].[Product
Categories].[Category].MEMBERS
*
{MEASURES.CURRENTDATE,
MEASURES.CURRENTPRODUCT,MEASURES.CURRENTMEASURE, MEASURES.CURRENTCUSTOMER}
ON 0,
[Date].[Calendar].MEMBERS
ON 1
FROM [Adventure
Works]
WHERE([Customer].[Customer
Geography].[Country].&[Australia])
当前成员在查询中的轴上使用的层次结构上进行更改。 因此，同一维度上未在轴上使用的其他层次结构上的当前成员也可以更改；此行为称为“自动共存”，MDX 中的重要概念 (Analysis Services)中提供了更多详细信息。 例如，下面的查询说明当
Calendar 层次结构上的当前成员显示在行轴上时，Date 维度的 Calendar Year 层次结构上的当前成员如何随 Calendar 层次结构上的当前成员更改：
WITH MEMBER
MEASURES.CURRENTYEAR AS
[Date].[Calendar
Year].CURRENTMEMBER.NAME
SELECT
{MEASURES.CURRENTYEAR}
ON 0,
[Date].[Calendar].MEMBERS
ON 1
FROM [Adventure
Works]
CurrentMember 对于使计算识别正在使用它们的查询的上下文是非常重要的。 以下示例将从 Adventure Works 多维数据集中返回每个产品的订单数量以及按类别和模型划分的订单数量的百分比。 CurrentMember 函数标识要在计算过程中使用其订单数量的产品。
WITH
MEMBER [Measures].[Order Percent by
Category] AS
CoalesceEmpty
(
([Product].[Product
Categories].CurrentMember,
Measures.[Order Quantity]) /
(
Ancestor
( [Product].[Product Categories].CurrentMember,
[Product].[Product
Categories].[Category]
), Measures.[Order Quantity]
), 0
), FORMAT_STRING='Percent'
SELECT
{Measures.[Order Quantity],
[Measures].[Order Percent by Category]}
ON COLUMNS,
{[Product].[Product].Members}
ON ROWS
FROM [Adventure
Works]
WHERE
{[Date].[Calendar Year].[Calendar Year].&[2003]}
29 . CurrentOrdinal (MDX)
返回迭代过程中集内的当前迭代数。
语法：
Set_Expression.CurrentOrdinal
参数：
Set_Expression
返回集的有效多维表达式 (MDX)。
注释：
当遍历一个集（例如使用 Filter (MDX) 或 Generate
(MDX) 函数）时，CurrentOrdinal 函数返回迭代数。
示例
以下简单示例说明如何将 CurrentOrdinal 与 Generate 一起使用来返回字符串，该字符串包含集中每项的名称以及它在该集中的位置：
WITH SET MySet AS
[Customer].[Customer Geography].[Country].MEMBERS
MEMBER
MEASURES.CURRENTORDINALDEMO AS
GENERATE(MySet,
CSTR(MySet.CURRENTORDINAL) + ") " + MySet.CURRENT.ITEM(0).NAME,
", ")
SELECT
MEASURES.CURRENTORDINALDEMO ON 0
FROM [Adventure
Works]
CurrentOrdinal 的实际用法仅限于非常复杂的计算。 下例将返回集中唯一产品的数目，其中使用了 Order 函数以在使用 Filter 函数前对非空元组进行排序。 CurrentOrdinal 函数用于比较和消除等同值。
WITH MEMBER
[Measures].[PrdTies] AS Count
(Filter
(Order
(NonEmpty
([Product].[Product].[Product].Members
, {[Measures].[Reseller Order
Quantity]}
)
, [Measures].[Reseller Order Quantity]
, BDESC
) AS OrdPrds
, NOT((OrdPrds.CurrentOrdinal <
OrdPrds.Count
AND [Measures].[Reseller Order Quantity]
=
( [Measures].[Reseller Order
Quantity]
, OrdPrds.Item
(OrdPrds.CurrentOrdinal
)
)
)
OR (OrdPrds.CurrentOrdinal > 1
AND [Measures].[Reseller Order
Quantity] =
([Measures].[Reseller Order
Quantity]
, OrdPrds.Item
(OrdPrds.CurrentOrdinal-2)
)
)
))
)
SELECT {[Measures].[PrdTies]}
ON 0
FROM [Adventure
Works]
30 . CustomData (MDX)
如果已定义，则返回 CustomData 连接字符串属性的值；否则，返回 null。
语法：
CustomData()
返回值：
CustomData 函数可以检索 CustomData 连接字符串属性并传递多维表达式 (MDX) 函数和语句将要使用的配置设置，例如，UserName
(MDX)和 CALL 语句 (MDX)。 例如，该函数可以用在动态安全表达式中，用于在 CustomData 连接字符串属性中选择允许的集成员或拒绝的集成员。
示例：
下面的查询显示某一计算度量值中 CustomData 函数返回的值：
WITH MEMBER
[Measures].CUSTOMDATADEMO AS CUSTOMDATA()
SELECT
[Measures].CUSTOMDATADEMO ON 0
FROM [Adventure
Works]
31 . DataMember (MDX)
返回系统生成的数据成员，它与某个维度的非叶成员相关联。
方法：
Member_Expression.DataMember
参数：
Member_Expression
返回成员的有效多维表达式 (MDX)。
注释：
该函数对任何层次结构中的非叶成员进行运算，且 UPDATE CUBE 语句 (MDX) 命令可以使用该函数直接向非叶成员而不是叶成员的后代写回数据。
|
注意 |
|
如果指定的成员为叶成员，或者如果非叶成员没有关联的数据成员，则返回指定的成员。 |
示例：
下面的示例在计算度量值中使用 DataMember 函数来显示各雇员的销售配额：
WITH MEMBER
measures.InvidualQuota AS
([Employee].[Employees].currentmember.datamember,
[Measures].[Sales Amount Quota])
,FORMAT_STRING='Currency'
SELECT
{[Measures].[Sales Amount Quota],[Measures].InvidualQuota} ON COLUMNS,
[Employee].[Employees].MEMBERS
ON ROWS
FROM [Adventure
Works]
32 . DefaultMember (MDX)
返回层次结构的默认成员。
语法：
Hierarchy_Expression.DefaultMember
参数：
Hierarchy_Expression
返回层次结构的有效多维表达式 (MDX)。
注释：
特性的默认成员用于在查询中不包括特性的情况下计算表达式。
示例：
下例结合使用 DefaultMember 函数和 Name 函数，返回
Adventure Works 多维数据集中的 Destination Currency 维度的默认成员。 例如，返回 US Dollar。 Name 函数不是用来返回度量值的默认属性（即 value），而是返回度量值的名称。
WITH MEMBER
Measures.x AS
[Destination Currency].[Destination
Currency].DefaultMember.Name
SELECT Measures.x
ON 0
FROM [Adventure
Works]
33 . Descendants (MDX)
返回成员在指定级别或距离上的后代集，可以选择包括或不包括其他级别的后代
语法：
Member expression
syntax using a level expression
Descendants(Member_Expression
[ , Level_Expression [ ,Desc_Flag ] ] )
Member expression
syntax using a numeric expression
Descendants(Member_Expression
[ , Distance [ ,Desc_Flag ] ] )
Set expression
syntax using a level expression
Descendants(Set_Expression
[ , Level_Expression [ ,Desc_Flag ] ] )
Member expression
syntax using a numeric expression
Descendants(Set_Expression
[ , Distance [ ,Desc_Flag ] ] )
参数：
Member_Expression
返回成员的有效多维表达式 (MDX)。
Set_Expression
返回集的有效多维表达式 (MDX)。
Level_Expression
返回级别的有效多维表达式 (MDX)。
Distance
指定与指定成员距离的有效数值表达式。
Desc_Flag
指定用于区分可能后代集的说明标志的有效字符串表达式。
注释：
如果指定了级别，Descendants 函数将返回一个后代集，其中包含指定成员的后代或指定集的成员的后代，这些后代处于所指定的级别，并且可以通过 Desc_Flag 中指定的标志来修改（可选）。
如果指定了 Distance，Descendants 函数将返回一个集，其中包含指定成员的后代或指定集的成员的后代，这些后代在指定成员的层次结构中与指定成员之间相距指定的级别数，并且可以通过 Desc_Flag 中指定的标志来修改（可选）。 通常情况下，此函数与 Distance 参数一同用于处理不规则的层次结构。 如果指定距离为零 (0)，该函数将返回仅由指定的成员或指定的集组成的集。
如果指定了集表达式，将针对该集中的每个成员分别解析 Descendants 函数，并重新创建该集。 也就是说，Descendants 函数所使用的语法的功能与
MDX Generate 函数相同。
如果未指定级别或距离，则通过为指定的成员（如果指定了成员）调用 Level 函数
(<<Member>>.Level)，或通过为指定的集（如果指定了集）中的每个成员调用 Level 函数来确定该函数使用的级别默认值。 如果未指定级别表达式、距离或标志，此函数将在假定使用了以下语法的情况下执行操作：
Descendants
(
Member_Expression
,
Member_Expression.Level
,
SELF_BEFORE_AFTER
)
如果指定了级别但未指定说明标志，此函数将在假定使用了以下语法的情况下执行操作：
Descendants
(
Member_Expression
,
Level_Expression,
SELF
)
通过更改说明标志的值，可以包括或排除位于指定级别或指定距离处的后代、位于指定级别或距离之前或之后（直到叶节点为止）的子成员以及位于任何级别或距离的叶子成员。 下表介绍了 Desc_Flag 参数中允许使用的标志。
|
标志 |
说明 |
|
SELF |
仅返回指定级别或指定距离处的后代成员。 如果指定级别为指定成员所在的级别，该函数将包括指定成员。 |
|
AFTER |
返回指定级别或指定距离处的所有从属级别的后代成员。 |
|
BEFORE |
返回指定成员和指定级别之间或指定距离内所有级别的后代成员。 它包括指定成员，但不包括指定级别或指定距离处的成员。 |
|
BEFORE_AND_AFTER |
返回指定成员所在级别的所有从属级别的后代成员。 它包括指定成员，但不包括指定级别或指定距离处的成员。 |
|
SELF_AND_AFTER |
返回指定级别或指定距离内的后代成员，以及指定级别或指定距离内的所有从属级别的后代成员。 |
|
SELF_AND_BEFORE |
返回指定级别或指定距离内的后代成员，以及指定成员和指定级别之间或指定距离内所有级别的后代成员（包括指定成员）。 |
|
SELF_BEFORE_AFTER |
返回指定成员所在级别的所有从属级别的后代成员（包括指定成员）。 |
|
LEAVES |
返回指定成员和指定级别之间或指定距离内的叶后代成员。 |
示例：
下面的示例返回指定成员 (United
States) 以及指定成员 (United States) 和指定级别 (City) 前一个级别的成员之间的成员。该示例返回指定成员 (United States) 本身以及 State-Province 级别（City 级别的前一个级别）的成员. 此示例包括注释参数，使您可以轻松地测试此函数的其他参数。
SELECT Descendants
([Geography].[Geography].[Country].&[United States]
//, [Geography].[Geography].[Country]
, [Geography].[Geography].[City]
//, [Geography].[Geography].Levels (3)
//, SELF
//, AFTER
, BEFORE
// BEFORE_AND_AFTER
//, SELF_AND_AFTER
//, SELF_AND_BEFORE
//,SELF_BEFORE_AFTER
//,LEAVES
) ON 0
FROM [Adventure
Works]
下面的示例将从 Adventure
Works 多维数据集中返回 Measures.[Gross Profit Margin] 度量值的日平均值，该值是根据 2003 财政年中每个月的所有日期计算出的。 Descendants 函数将返回根据 [Date].[Fiscal] 层次结构的当前成员确定的日期集。
WITH MEMBER
Measures.[Avg Gross Profit Margin] AS Avg
(
Descendants
(
[Date].[Fiscal].CurrentMember,
[Date].[Fiscal].[Date]
),
Measures.[Gross Profit Margin]
)
SELECT
Measures.[Avg Gross Profit Margin] ON
COLUMNS,
[Date].[Fiscal].[Month].Members ON ROWS
FROM [Adventure
Works]
WHERE
([Date].[Fiscal Year].&[2003])
下面的示例使用一个级别表达式，并返回
Australia 中每个 State-Province 的 Internet Sales Amount 及其占 Australia 总 Internet
Sales Amount 的百分比。 此示例使用 Item 函数从 Ancestors 函数返回的集中提取第一个（也是唯一的）元组。
WITH MEMBER
Measures.x AS
[Measures].[Internet Sales Amount] /
( [Measures].[Internet Sales Amount],
Ancestors
( [Customer].[Customer
Geography].CurrentMember,
[Customer].[Customer
Geography].[Country]
).Item (0)
), FORMAT_STRING = '0%'
SELECT {[Measures].[Internet
Sales Amount], Measures.x} ON 0,
{Descendants
( [Customer].[Customer
Geography].[Country].&[Australia],
[Customer].[Customer
Geography].[State-Province], SELF
)
} ON 1
FROM [Adventure
Works]
34 . Dimension (MDX)
返回包含指定成员、级别或层次结构的层次结构。
语法：
Hierarchy
syntax
Hierarchy_Expression.Dimension
Level syntax
Level_Expression.Dimension
Member
syntax
Member_Expression.Dimension
参数
Hierarchy_Expression
返回层次结构的有效多维表达式 (MDX)。
Level_Expression
返回级别的有效多维表达式 (MDX)。
Member_Expression
返回成员的有效多维表达式 (MDX)。
示例
下例将 Dimension 函数与 Name 函数结合使用，以返回指定成员的层次结构名称。
WITH member
measures.x as [Product].[Product Model Lines].[Model].&[HL Road
Tire].Dimension.Name
SELECT measures.x
on 0
FROM [Adventure
Works]
下例将 Dimension 函数与 Levels 和 Count 函数结合使用，以返回包含指定成员的层次结构中的级别数目。
WITH member
measures.x as [Product].[Product Model Lines].[Model].&[HL Road
Tire].Dimension.Levels.Count
SELECT measures.x
on 0
FROM [Adventure
Works]
下例将 Dimension 函数、Members 函数和 Count 函数结合使用，以返回包含指定成员的层次结构中的成员数目。
WITH member
measures.x as [Product].[Product Model Lines].[Model].&[HL Road
Tire].Dimension.Members.Count
SELECT measures.x
on 0
FROM [Adventure
Works]
35 . Dimensions (MDX)
返回数值表达式或字符串表达式指定的层次结构。
语法
Numeric expression
syntax
Dimensions(Hierarchy_Number)
String expression
syntax
Dimensions(Hierarchy_Name)
参数
Hierarchy_Number
指定层次结构号的有效数值表达式。
Hierarchy_Name
指定层次结构名称的有效字符串表达式。
注释
如果指定了层次结构号，则 Dimensions 函数返回一个层次结构，该层次结构在多维数据集中以零为基的位置就是指定的层次结构号。
如果指定了层次结构的名称，则 Dimensions 函数返回指定的层次结构。 通常情况下，这个字符串版本的 Dimensions 函数与用户定义的函数一起使用。
|
注意 |
|
Measures 维度始终由 Dimensions(0) 表示。 |
示例
下例使用 Dimensions 函数连同一个数值表达式和一个字符串表达式，返回指定层次结构的名称、级别计数和成员计数。
WITH MEMBER
Measures.x AS Dimensions
('[Product].[Product Model Lines]').Name
SELECT Measures.x
on 0
FROM [Adventure
Works]
WITH MEMBER
Measures.x AS Dimensions
('[Product].[Product Model
Lines]').Levels.Count
SELECT Measures.x
on 0
FROM [Adventure
Works]
WITH MEMBER
Measures.x AS Dimensions
('[Product].[Product Model
Lines]').Members.Count
SELECT Measures.x
on 0
FROM [Adventure
Works]
WITH MEMBER
Measures.x AS Dimensions(0).Name
SELECT Measures.x
on 0
FROM [Adventure
Works]
WITH MEMBER
Measures.x AS Dimensions(0).Levels.Count
SELECT measures.x
on 0
FROM [Adventure
Works]
WITH MEMBER
Measures.x AS Dimensions(0).Members.Count
SELECT measures.x
on 0
FROM [Adventure
Works]
36 . Distinct (MDX)
对指定的集求值，删除该集中的重复元组，然后返回结果集。
语法
Distinct(Set_Expression)
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
如果 Distinct 函数在指定的集中找到了重复的元组，则此函数只保留重复元组的第一个实例，同时保留该集原来的顺序。
示例
以下示例查询说明如何将 Distinct 函数与命名集一起使用，以及如何将该函数与 Count 函数一起使用来查找集中不同元组的数目：
WITH SET MySet AS
{[Customer].[Customer
Geography].[Country].&[Australia],[Customer].[Customer
Geography].[Country].&[Australia],
[Customer].[Customer
Geography].[Country].&[Canada],[Customer].[Customer
Geography].[Country].&[France],
[Customer].[Customer
Geography].[Country].&[United Kingdom],[Customer].[Customer
Geography].[Country].&[United Kingdom]}
MEMBER
MEASURES.SETCOUNT AS
COUNT(MySet)
MEMBER
MEASURES.SETDISTINCTCOUNT AS
COUNT(DISTINCT(MySet))
SELECT
{MEASURES.SETCOUNT, MEASURES.SETDISTINCTCOUNT} ON 0,
DISTINCT(MySet) ON
1
FROM [Adventure
Works]
37 . DistinctCount (MDX)
返回集中非重复的非空元组的数目。
语法
DistinctCount(Set_Expression)
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
注释
DistinctCount 函数等效于 Count(Distinct(Set_Expression),
EXCLUDEEMPTY)。
示例
以下查询说明如何使用
DistinctCount 函数：
WITH SET MySet AS
{[Customer].[Customer
Geography].[Country].&[Australia],[Customer].[Customer
Geography].[Country].&[Australia],
[Customer].[Customer
Geography].[Country].&[Canada],[Customer].[Customer
Geography].[Country].&[France],
[Customer].[Customer
Geography].[Country].&[United Kingdom],[Customer].[Customer
Geography].[Country].&[United Kingdom]}
*
{([Date].[Calendar].[Date].&[20010701],[Measures].[Internet
Sales Amount] )}
//Returns the
value 3 because Internet Sales Amount is null
//for the UK on
the date specified
MEMBER
MEASURES.SETDISTINCTCOUNT AS
DISTINCTCOUNT(MySet)
SELECT
{MEASURES.SETDISTINCTCOUNT} ON 0
FROM [Adventure
Works]
38 . 除 (MDX)
执行除法运算，并在被 0 除时返回备用结果或
BLANK()。
语法
Divide
(<numerator>, <denominator> [,<alternateresult>])
参数
numerator
被除数，即被除的数字。
denominator
除数，即除以的数字。
alternateresult
（可选）被零除而导致错误时返回的值。 如果没有提供，则默认值为
BLANK()。
注释
被 0 除时的备用结果必须是一个常量。
39 . DrilldownLevel (MDX)
将某个集的成员深化到该集中所表示的最低级别的下一个级别。
指定要在哪一个级别深化为可选，但如果要设置级别，可以使用 level expression 或 index level。 这两种参数互相排斥。 最后，如果计算成员出现在查询中，你可指定一个聚合以将这些成员包含在行集中。
语法
DrilldownLevel(Set_Expression
[,[Level_Expression] ,[Index]] [,INCLUDE_CALC_MEMBERS])
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Level_Expression
（可选）。 显式标识要深化的级别的
MDX 表达式。 如果指定了级别表达式，请跳过下面的索引参数。
Index
（可选）。 有效的数值表达式，它指定在集中要深化的层次结构编号。 你可使用索引级别而不是 Level_Expression 显式标识要深化的级别。
Include_Calc_Members
（可选）。 指示是否在深化级别包括计算成员（如果存在）的标志。
注释
DrilldownLevel 函数根据指定集中包含的成员，返回按层次结构排列的一组子成员。 指定集中原始成员的顺序将保持不变，只不过该函数的结果集中包含的所有子成员都位于其父成员下方并紧随其父成员。
根据多级别分层数据结构，你可显式选择要深化的级别。 有两种独占方式可指定级别。 第一种方法是使用返回级别的 MDX 表达式设置level_expression 参数，另一种方法是使用通过数字指定级别的数字表达式指定 index 参数。
如果指定了级别表达式，函数将只检索指定级别的成员的子成员，然后用这些子成员按层次结构顺序构造一个集。 如果指定了级别表达式且该级别没有成员，则忽略该级别表达式。
如果指定了索引值，此函数将基于从零开始的索引只检索指定集中引用的层次结构的下一最低级别成员的子成员，然后用这些子成员按层次结构顺序构造一个集。
如果级别表达式和索引值均未指定，此函数将只检索指定集中引用的第一个维度的最低级别成员的子成员，然后用这些子成员按层次结构顺序构造一个集。
通过查询 XMLA 属性
MdpropMdxDrillFunctions，您可以确认服务器为钻取功能提供的支持的级别；有关详细信息，请参阅支持的 XMLA 属性 (XMLA)。
示例
你可使用 Adventure Works 多维数据集在 SSMS 中的 MDX 查询窗口中尝试下面的示例。
示例 1 – 演示最简语法
第一个示例显示了 DrilldownLevel 的最简语法。 所需的唯一参数是集表达式。 请注意，运行此查询时，你应获取下一个级别的父 [All Categories] 和成员：[Accessories] 和 [Bikes] 等。 尽管这个示例很简单，但它演示了 DrilldownLevel 函数的基本用途，即深化到下一个级别。
SELECT
DRILLDOWNLEVEL({[Product].[Product Categories]} * {[Sales Territory].[Sales
Territory]}}) ON COLUMNS
FROM [Adventure
Works]
示例 2 – 使用显式索引级别的替代语法
此示例演示了替代语法，该语法通过数字表达式指定索引级别。 在本例中，索引级别是 0。 对于从零开始的索引，这是最低级别。
SELECT
DRILLDOWNLEVEL({[Product].[Product
Categories]} * {[Sales Territory].[Sales Territory]},,0) ON COLUMNS
FROM [Adventure
Works]
请注意，结果集与之前的查询完全相同。 通常，不必设置索引级别，除非你想要从特定级别开始深化。 将索引值设置为 1，然后设置为 2，重新运行之前的查询。 索引值设置为 1 时，你会看到深化从层次结构中的第二个级别开始。 索引值设置为 2 时，深化从第三个级别（本示例中的*别）开始。 数字表达式越高，索引级别越高。
示例 3 – 演示级别表达式
下面的示例显示如何使用级别表达式。 基于代表层次结构的集，使用级别表达式可让你在层次结构中选择开始深化的级别。
在本示例中，深化的级别从 [City] 开始，它是 DrilldownLevel 函数的第二个参数。 运行此查询时，深化从华盛顿和俄勒冈州的 [City] 级别开始。对于 DrilldownLevel 函数，结果集还包括下一个级别
[Postal codes] 的成员。
SELECT
[Measures].[Internet Sales Amount] ON COLUMNS,
NON EMPTY (
DRILLDOWNLEVEL(
{[Customer].[Customer
Geography].[Country].[United States],
DESCENDANTS(
{ [Customer].[Customer
Geography].[State-Province].[Washington],
[Customer].[Customer
Geography].[State-Province].[Oregon]},
[Customer].[Customer
Geography].[City]) } ,
[Customer].[Customer
Geography].[City] ) ) ON ROWS
FROM [Adventure
Works]
示例 4 – 包括计算成员
最后一个示例显示计算成员，当你添加 include_calculated_members 标志时，计算成员显示在结果集底部。 请注意，该标志被指定为第四个参数。
此示例有效的原因是计算成员所处的级别与非计算成员相同。 计算成员 [West Coast] 由来自 [United States] 的成员以及 [United States] 的下一个级别的所有成员组成。
WITH MEMBER
[Customer].[Customer
Geography].[Country].&[United States].[West Coast] AS
[Customer].[Customer
Geography].[State-Province].&[OR]&[US] +
[Customer].[Customer
Geography].[State-Province].&[WA]&[US] +
[Customer].[Customer
Geography].[State-Province].&[CA]&[US]
SELECT
[Measures].[Internet Order Count] ON 0,
DRILLDOWNLEVEL([Customer].[Customer
Geography].[Country].&[United States],,,INCLUDE_CALC_MEMBERS) on 1
FROM [Adventure
Works]
如果仅删除标志，然后重新运行该查询，你会得到与减去计算成员 [West Coast] 相同的结果。
40 . DrilldownLevelBottom (MDX)
将集中某一指定级别上的最底层成员深化到下一个级别。
语法
DrilldownLevelBottom(Set_Expression,
Count [,[<Level_Expression>]
[,[<Numeric_Expression>][,INCLUDE_CALC_MEMBERS]]])
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Count
指定要返回的元组数的有效数值表达式。
Level_Expression
返回级别的有效多维表达式 (MDX)。
Numeric_Expression
可选。 返回数字的有效数值表达式，通常为单元坐标的多维表达式 (MDX)。
Include_Calc_Members
可选。 将计算成员添加到深化结果的关键字。
注释
如果指定了数值表达式，则 DrilldownLevelBottom 函数根据对子成员集求得的指定值，对指定集中的每个成员的子成员按升序排序。 如果未指定数值表达式，则此函数根据由查询上下文决定的子成员集所表示的单元的值，对指定的集中每个成员的子成员按升序排序。此行为类似于 BottomCount 和 Tail (MDX) 函数，都以自然顺序返回一组成员，没有任何排序。
排序后，DrilldownLevelBottom 函数返回包含父成员以及在 Count 中指定数目的具有最小值的子成员的集。
DrilldownLevelBottom 函数与 DrilldownLevel 函数相似，但 DrilldownLevelBottom 函数不是返回包括指定级别上的每个成员的所有子成员，而是返回指定数目的最底层子成员。
通过查询 XMLA 属性
MdpropMdxDrillFunctions，您可以确认服务器为钻取功能提供的支持的级别；有关详细信息，请参阅支持的 XMLA 属性 (XMLA)。
示例
下面的示例将根据默认度量值返回产品类别级别的最后三个子成员。 在 Adventure Works 示例多维数据集中，Accessories 的最后三个子成员是 Tires and Tubes、Pumps 和 Panniers。 在 Management Studio 的 MDX 查询窗口中，你可导航到“产品 | 产品类别 | 成员 | 所有产品 | 附件”查看完整的列表。 你可增加计数参数以返回更多成员。
SELECT
DrilldownLevelBottom
([Product].[Product Categories].children,
3,
[Product].[Product Categories].[Category])
ON 0
FROM [Adventure Works]
下面的示例演示了 include_calc_members 标志的使用，该标识用于包括深化级别中的计算成员。 [Reseller Order Count] 度量值将添加到DrilldownLevelBottom 语句以确保该度量值对结果进行排序。 要查看计算成员，必须将计数至少增加到 9。
WITH MEMBER
[Product].[Product
Categories].[Category].&[3].[Premium Clothes] AS
[Product].[Product
Categories].[Subcategory].&[18] +
[Product].[Product
Categories].[Subcategory].&[21]
SELECT
[Measures].[Reseller Order Count] ON 0,
DRILLDOWNLEVELBOTTOM(
[Product].[Product Categories].children ,
9,
[Product].[Product Categories].[Category] ,
[Measures].[Reseller Order Count],
INCLUDE_CALC_MEMBERS ) ON 1
FROM [Adventure
Works]
41 . DrilldownLevelTop (MDX)
将集中某一指定级别上最顶端的成员深化到下一个级别。
语法
DrilldownLevelTop(<Set_Expression>,
<Count> [,[<Level_Expression>]
[,[<Numeric_Expression>][,INCLUDE_CALC_MEMBERS]]])
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Count
指定要返回的元组数的有效数值表达式。
Level_Expression
返回级别的有效多维表达式 (MDX)。
Numeric_Expression
返回数字的有效数值表达式，通常为单元坐标的多维表达式 (MDX)。
Include_Calc_Members
用于将计算成员添加到深化结果的关键字。
注释
如果指定了数值表达式，则 DrilldownLevelTop 函数根据对子成员集求得的数值表达式的值，对指定集中每个成员的子成员按降序排序。 如果未指定数值表达式，则此函数根据由查询上下文确定的子成员集所表示的单元值，对指定集中每个成员的子成员按降序排序。
排序后，DrilldownLevelTop 函数返回包含父成员以及在 Count, 中指定数量的具有最大值的子成员的集。
DrilldownLevelTop 函数与 DrilldownLevel 函数相似，但 DrilldownLevelTop 函数不是包括指定级别处每个成员的所有子成员，而是返回指定数目的最顶层子成员。
通过查询 XMLA 属性
MdpropMdxDrillFunctions，您可以确认服务器为钻取功能提供的支持的级别；有关详细信息，请参阅支持的 XMLA 属性 (XMLA)。
示例
下面的示例根据默认度量值返回产品类别级别的前三个子成员。 在 Adventure Works 示例多维数据集中，Accessories 的前三个子成员是Bike Racks、Bike Stands 和 Bottles and Cages。 在 Management Studio 的 MDX 查询窗口中，你可导航到“产品 | 产品类别 | 成员 | 所有产品 | 附件”查看完整的列表。 你可增加计数参数以返回更多成员。
SELECT
DrilldownLevelTop
([Product].[Product Categories].children,
3,
[Product].[Product Categories].[Category])
ON 0
FROM [Adventure Works]
下面的示例演示了 include_calc_members 标志的使用，该标识用于包括深化级别中的计算成员。 度量值 [Reseller Order Count] 包含在DrilldownLevelTop 语句中以确保返回的值将按该度量值排序。
WITH MEMBER
[Product].[Product
Categories].[Category].&[3].[Premium Clothes] AS
[Product].[Product
Categories].[Subcategory].&[18] +
[Product].[Product
Categories].[Subcategory].&[21]
SELECT
[Measures].[Reseller Order Count] ON 0,
DRILLDOWNLEVELTOP(
[Product].[Product Categories].children ,
2,
[Product].[Product Categories].[Category] ,
[Measures].[Reseller Order Count],
INCLUDE_CALC_MEMBERS ) ON 1
FROM [Adventure
Works]
42 . DrilldownMember (MDX)
深化第一个指定集与第二个指定集的交集中的成员。
该函数也可以通过使用第一个元组层次结构或者可选的指定层次结构，对一组元组进行深化。
语法
DrillDownMember(<Set_Expression1>,
<Set_Expression2> [,[<Target_Hierarchy>]]
[,[RECURSIVE][,INCLUDE_CALC_MEMBERS]])
参数
Set_Expression1
返回集的有效多维表达式 (MDX)。
Set_Expression2
返回集的有效多维表达式 (MDX)。
Target_Hierarchy
返回层次结构的有效多维表达式 (MDX)。
Recursive
指示集的递归比较的关键字。
Include_Calc_Members
用于使计算成员能够包括在深化结果中的关键字。
注释
该函数返回按层次结构排序的子成员集，并包括第一个集和第二个集的交集中的成员。 如果第一个集包含父成员以及一个或多个子成员，则不深化父成员。 第一个集可以具有任何维数，但第二个集必须包含一个一维集。 第一个集中的原始成员的顺序将保留，只不过该函数的结果集中包含的所有子成员都紧随在它们的父成员之后。 该函数将通过检索第一个集与第二个集的交集中的每个成员的子成员来构造结果集。 如果指定了RECURSIVE，该函数会继续将结果集的成员与第二个集中的成员进行递归比较，检索结果集与第二个集的交集中的每个成员的子成员，直到找遍结果集与第二个集的交集中的成员为止。
通过查询 XMLA 属性 MdpropMdxDrillFunctions ，您可以确认服务器为钻取功能提供的支持的级别；有关详细信息，请参阅 支持的 XMLA 属性 (XMLA)。
第一个集可以包含元组，但不能包含成员。 对元组的深化是一种 OLE
DB 扩展，这种深化将返回元组集而非成员集。
|
重要提示 |
|
当成员后面紧跟其子成员之一时，将不会深化该成员。 成员集中成员的顺序对于 |
示例
下例深化了 Australia 成员，它是第一个集与第二个集的交集成员。
SELECT
DrilldownMember
( [Geography].[Geography].Children,
{[Geography].[Geography].[Country].[Australia],
[Geography].[Geography].[State-Province].[New South Wales]}
)
ON 0
FROM [Adventure Works]
下例深化了 Australia 成员，它是第一个集与第二个集的交集成员。 但是，由于指定了 RECURSIVE 参数，该函数会继续将结果集的成员（State-Province 级别的成员）与第二个集中的成员进行递归比较，检索结果集（City 级别的成员）与第二个集的交集中的每个成员的子成员，直到找遍结果集与第二个集的交集中的成员为止。
SELECT
DrilldownMember
( [Geography].[Geography].Children,
{[Geography].[Geography].[Country].[Australia],
[Geography].[Geography].[State-Province].[New South Wales]}
,RECURSIVE)
ON 0
FROM [Adventure Works]
43 . DrilldownMemberBottom (MDX)
深化第一个指定集与第二个指定集的交集中的成员，并将结果集的成员数限制为指定数目。 该函数也可以通过使用第一个元组层次结构或者可选的指定层次结构，对一组元组进行深化。
语法
DrillDownMemberBottom(<Set_Expression1>,
<Set_Expression2>, <Count> [,[<Numeric_Expresion>]
[,[<Hierarchy>]] [,[RECURSIVE][,INCLUDE_CALC_MEMBERS]]])
参数
Set_Expression1
返回集的有效多维表达式 (MDX)。
Set_Expression2
返回集的有效多维表达式 (MDX)。
Count
指定要返回的元组数的有效数值表达式。
Numeric_Expression
返回数字的有效数值表达式，通常为单元坐标的多维表达式 (MDX)。
Hierarchy
返回层次结构的有效多维表达式 (MDX)。
Recursive
指示集的递归比较的关键字。
Include_Calc_Members
用于使计算成员能够包括在深化结果中的关键字。
注释
如果指定了数值表达式，DrilldownMemberBottom 函数将根据对子成员集计算此数值表达式所得到的值，对第一个集中每个成员的子成员按升序排序。 如果未指定数值表达式，此函数将根据由查询上下文决定的子成员集所表示的单元的值，对第一个集中每个成员的子成员按升序排序。 此行为类似于 BottomCount 和 Tail (MDX) 函数，都以自然顺序返回一组成员，没有任何排序。
排序后，DrilldownMemberBottom 函数返回一个集，该集包含父成员和一定数量（此数量在 Count 中指定）的子成员，这些子成员具有最小值，且同时包含在这两个集中。
如果指定了 RECURSIVE，此函数将按上述方式对第一个集进行排序，然后将第一个集的成员（它们按层次结构排列）与第二个集的成员进行递归比较。 此函数检索第一个集与第二个集的交集中每个成员的指定数目的最底层子成员。
第一个集可以包含元组，但不能包含成员。 元组的深化是 OLE DB
的扩展，它返回元组集而非成员集。
DrilldownMemberBottom 函数类似于 DrilldownMember 函数，但是 DrilldownMemberBottom 函数返回第一个集与第二个集的交集中每个成员的指定数目的最底层子成员，而不是包括交集中每个成员的所有子成员。
通过查询 XMLA 属性
MdpropMdxDrillFunctions，您可以确认服务器为钻取功能提供的支持的级别；有关详细信息，请参阅支持的 XMLA 属性 (XMLA)。
44 . DrilldownMemberTop (MDX)
深化第一个指定集与第二个指定集的交集中的成员，并将结果集的成员数限制为指定数目。 该函数也可以通过使用第一个元组层次结构或者可选的指定层次结构，对一组元组进行深化。
语法
DrillDownMemberTop(<Set_Expression1>,
<Set_Expression2>, <Count> [,[<Numeric_Expression>]
[,[<Hierarchy>]] [,[RECURSIVE][,INCLUDE_CALC_MEMBERS]]])
参数
Set_Expression1
返回集的有效多维表达式 (MDX)。
Set_Expression2
返回集的有效多维表达式 (MDX)。
Count
指定要返回的元组数的有效数值表达式。
Numeric_Expression
返回数字的有效数值表达式，通常为单元坐标的多维表达式 (MDX)。
Hierarchy
返回层次结构的有效多维表达式 (MDX)。
Recursive
指示集的递归比较的关键字。
Include_Calc_Members
用于使计算成员能够包括在深化结果中的关键字。
注释
如果指定了数值表达式，则 DrilldownMemberTop 函数根据对子成员集求得的数值表达式的值，对第一个集中每个成员的子成员按降序排序。如果未指定数值表达式，则此函数根据由查询上下文确定的子成员集所表示的单元值，对第一个集中每个成员的子成员按降序排序。 此行为类似于 TopCount 和 Head (MDX) 函数，都以自然顺序返回一组成员，没有任何排序。
排序后，DrilldownMemberTop 函数返回包含父成员以及 Count, 中指定数量的子成员的集，这些子成员具有最大值，且同时包含在两个集中。
如果指定了 RECURSIVE，则此函数将按上述方法对第一个集进行排序，然后将第一个集的成员（它们按层次结构排列）与第二个集的成员进行递归比较。此函数检索第一个集与第二个集的交集中每个成员的指定数目的最顶层子成员。
第一个集可以包含元组，但不能包含成员。 元组的深化是 OLE DB
的扩展，它返回元组集而非成员集。
DrilldownMemberTop 函数类似于 DrilldownMember 函数，但是 DrilldownMemberTop 函数返回第一个集与第二个集的交集中每个成员的指定数目的最顶层子成员，而不是包括交集中每个成员的所有子成员。
通过查询 XMLA 属性
MdpropMdxDrillFunctions，您可以确认服务器为钻取功能提供的支持的级别；有关详细信息，请参阅支持的 XMLA 属性 (XMLA)。
示例
下例深化了服装类别，返回已发货订单数量最多的三个服装子类别。
SELECT
DrilldownMemberTop ({[Product].[Product
Categories].[All Products],
[Product].[Product
Categories].[Category].Bikes,
[Product].[Product
Categories].[Category].Clothing},
{[Product].[Product
Categories].[Category].Clothing},
3,
[Measures].[Reseller
Order Quantity])
ON 0
FROM [Adventure
Works]
WHERE
[Measures].[Reseller Order Quantity]
45 . DrillupLevel (MDX)
浅化某个集在指定级别以下的成员。
语法
DrillupLevel(Set_Expression
[ , Level_Expression ] )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Level_Expression
返回级别的有效多维表达式 (MDX)。
注释
DrillupLevel 函数根据指定集中包括的成员，返回按层次结构组织的成员集。 指定集中的成员顺序将予以保留。
如果指定了级别表达式，则 DrillupLevel 函数只检索那些位于指定级别以上的成员，然后用它们来构造集。 如果指定了级别表达式但指定集中没有指定级别的成员，则返回指定的集。
如果未指定级别表达式，则此函数只检索那些比指定的集所引用的第一个维度的最低级别高一个级别的成员，然后用它们来构造集。
示例
下例将返回位于子类别级别之上第一个集中的成员集。
SELECT
DrillUpLevel
({[Product].[Product Categories].[All
Products]
,[Product].[Product
Categories].[Subcategory].&[32],
[Product].[Product
Categories].[Product].&[215]},
[Product].[Product Categories].[Subcategory]
)
ON 0
FROM [Adventure Works]
WHERE [Measures].[Internet Order Quantity]
46 . DrillupMember (MDX)
返回指定集中不是第二个指定集中成员的后代的成员。
语法
DrillupMember(Set_Expression1,
Set_Expression2)
参数
Set_Expression1
返回集的有效多维表达式 (MDX)。
Set_Expression2
返回集的有效多维表达式 (MDX)。
注释
DrillupMember 函数返回成员集，其中的成员是第一个集中的成员并且是第二个集中成员的后代。 第一个集可以具有任何维数，但第二个集必须包含一个一维集。 第一个集中的原始成员顺序会被保留。 此函数在构造集时仅包括位于第一个集中并且是第二个集中成员的直接后代的那些成员。如果第一个集中某成员的直接祖先不在第二个集中，则第一个集中的该成员包括在此函数返回的集中。 第一个集中位于第二个集中某个祖先成员之前的后代，也会包括在内。
第一个集可以包含元组，但不能包含成员。 元组的深化是 OLE DB
的扩展，它返回元组集而非成员集。
|
重要提示 |
|
只有后面紧跟子成员或后代的成员才会被浅化。 成员集中成员的顺序对于 |
示例
除了第二个集以外，以下三个示例都是相似的。 在第一个示例时，第二个集为
United States。 因此，从结果集中排除 Colorado。 它是 United States 的后代。
SELECT
DrillUpMember (
{ [Geography].[Geography].[Country].[Canada]
,[Geography].[Geography].[Country].[United
States]
,[Geography].[Geography].[State-Province].[Colorado]
,[Geography].[Geography].[State-Province].[Alberta]
,[Geography].[Geography].[State-Province].[Brunswick]
}
, {[Geography].[Geography].[Country].[United
States]}
) ON 0
FROM [Adventure
Works]
示例二向我们显示了成员顺序的重要性。 因为 DrillupMember 仅浅化了第一个集中由后代紧跟的这些成员，它不浅化 Canada 成员。 Canada 与其后代由 United States 和 Colorado 分隔开来。 如果你对成员重新排序，使 Canada 直接位于 Alberta 上方，则 Alberta 和 Brunswick 都将从行集中排除。
SELECT
DrillUpMember (
{
[Geography].[Geography].[Country].[Canada]
,[Geography].[Geography].[Country].[United
States]
,[Geography].[Geography].[State-Province].[Colorado]
,[Geography].[Geography].[State-Province].[Alberta]
,[Geography].[Geography].[State-Province].[Brunswick]
}
, {[Geography].[Geography].[Country].[Canada]}
)
ON 0
FROM [Adventure
Works]
示例三显示了 Hierarchize 的使用可以如何降低成员顺序的影响以及如何浅化 Canada 成员。
SELECT
DrillUpMember (
Hierarchize
(
{ [Geography].[Geography].[Country].[Canada]
,[Geography].[Geography].[Country].[United
States]
,[Geography].[Geography].[State-Province].[Colorado]
,[Geography].[Geography].[State-Province].[Alberta]
,[Geography].[Geography].[State-Province].[Brunswick]
}
),
{[Geography].[Geography].[Country].[Canada]}
)
ON 0
FROM [Adventure
Works]
47 . Error (MDX)
引发错误，可以根据需要选择提供指定的错误消息。
语法
Error( [
Error_Text ] )
参数
Error_Text
包含要返回的错误消息的有效字符串表达式。
示例
以下查询说明如何在计算度量值内使用 Error 函数：
WITH MEMBER
MEASURES.ERRORDEMO AS ERROR("THIS IS AN ERROR")
SELECT
MEASURES.ERRORDEMO
ON 0
FROM [Adventure
Works]
48 . Except (MDX)
计算两个集并删除第一个集中与第二个集中的元组重复的元组，也可以选择保留重复项。
语法
Except(Set_Expression1,
Set_Expression2 [, ALL ] )
参数
Set_Expression1
返回集的有效多维表达式 (MDX)。
Set_Expression2
返回集的有效多维表达式 (MDX)。
注释
如果指定了 ALL，该函数将保留在第一个集中找到的重复项，但仍会删除在第二个集中找到的重复项。 成员的返回顺序与它们在第一个集中出现的顺序相同。
示例
以下示例说明了此函数的用法。
//This query shows the quantity of orders
for all products,
//with the exception of Components, which
are not
//sold.
SELECT
[Date].[Month of Year].Children ON COLUMNS,
Except
([Product].[Product
Categories].[All].Children ,
{[Product].[Product
Categories].[Components]}
) ON ROWS
FROM
[Adventure Works]
WHERE
([Measures].[Order Quantity])
49 . Exists (MDX)
返回与第二个指定集的一个或多个元组共存的第一个指定集中的元组集。 该函数手动执行自动 Exists 以自动方式执行的操作。 有关自动 Exists 的详细信息，请参阅 MDX 中的重要概念 (Analysis Services)。
如果提供了可选的 <Measure
Group Name>，则函数返回与第二个集中的一个或多个元组共存的元组以及在指定度量值组的事实数据表中具有关联行的元组。
语法
Exists(
Set_Expression1 , Set_Expression2 [, MeasureGroupName] )
参数
Set_Expression1
返回集的有效多维表达式 (MDX)。
Set_Expression2
返回集的有效多维表达式 (MDX)。
MeasureGroupName
指定度量值组名称的有效字符串表达式。
注释
如果指定了
MeasureGroupName 参数，则带有包含 Null 值的度量值的度量值组行会影响 Exists。 下面是此形式的 Exists 和 Nonempty 函数之间的差异：如果这些度量值的 NullProcessing 属性设置为 Preserve，则意味着在对该部分的多维数据集运行查询时这些度量值将显示 Null 值；NonEmpty 始终从集中删除具有 Null 度量值的元组，而具有 MeasureGroupName 参数的 Exists 将不筛选具有关联的度量值组行的元组，甚至在度量值为 Null 时也是如此。
如果使用 MeasureGroupName 参数，结果取决于引用的度量值组中是否具有可见度量值；如果引用的度量值组中无可见度量值，则无论Set_Expression1 和 Set_Expression2 的值为何，EXISTS 将始终返回空集。
示例
居住在加利福尼亚的客户：
SELECT
[Measures].[Internet Sales Amount] ON 0,
EXISTS(
[Customer].[Customer].[Customer].MEMBERS
,
{[Customer].[State-Province].&[CA]&[US]}
) ON 1
FROM [Adventure
Works]
居住在加利福尼亚并且有销售额的客户：
SELECT [Measures].[Internet
Sales Amount] ON 0,
EXISTS(
[Customer].[Customer].[Customer].MEMBERS
,
{[Customer].[State-Province].&[CA]&[US]}
, "Internet
Sales") ON 1
FROM [Adventure
Works]
有销售额的客户：
SELECT
[Measures].[Internet Sales Amount] ON 0,
EXISTS(
[Customer].[Customer].[Customer].MEMBERS
, , "Internet
Sales") ON 1
FROM [Adventure
Works]
购买了自行车的客户：
SELECT
[Measures].[Internet Sales Amount] ON 0,
EXISTS(
[Customer].[Customer].[Customer].MEMBERS
,
{[Product].[Product Categories].[Category].&[1]}
, "Internet
Sales") ON 1
FROM [Adventure
Works]
50 . Extract (MDX)
返回由提取的层次结构元素中的元组构成的集。
语法
Extract(Set_Expression,
Hierarchy_Expression1 [,Hierarchy_Expression2, ...n] )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Hierarchy_Expression1
返回层次结构的有效多维表达式 (MDX)。
Hierarchy_Expression2
返回层次结构的有效多维表达式 (MDX)。
注释
Extract 函数返回由提取的层次结构元素中的元组构成的集。 对于指定集中的每个元组，将指定层次结构的成员提取到结果集中的新元组。 此函数始终删除重复元组。
Extract 函数执行的操作与 Crossjoin 函数相反。
示例
以下查询说明如何在由 NonEmpty 函数返回的元组集上使用 Extract 函数：
SELECT
[Measures].[Internet Sales Amount] ON 0,
//Returns the
distinct combinations of Customer and Date for all purchases
//of Bike Racks or
Bike Stands
EXTRACT(
NONEMPTY(
[Customer].[Customer].[Customer].MEMBERS
*
[Date].[Date].[Date].MEMBERS
*
{[Product].[Product
Categories].[Subcategory].&[26],[Product].[Product
Categories].[Subcategory].&[27]}
*
{[Measures].[Internet
Sales Amount]}
)
,
[Customer].[Customer], [Date].[Date])
ON 1
FROM [Adventure
Works]
51 . Filter (MDX)
返回根据搜索条件对指定集进行筛选后得到的集。
语法
Filter(Set_Expression,
Logical_Expression )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Logical_Expression
计算结果为 True 或 False 的有效多维表达式
(MDX) 逻辑表达式。
注释
Filter 函数对指定集中的每个元组计算指定的逻辑表达式。 如果逻辑表达式计算结果为 true，该函数将返回由指定集中的每个元组构成的集。 如果所有元组的计算结果都不为 true，则返回一个空集。
Filter 函数的工作方式与 IIf 函数类似。 IIf 函数只返回两个选项中的一个，返回哪一个取决于 MDX 逻辑表达式的值；而 Filter 函数返回符合指定搜索条件的元组集。 实际上，Filter 函数是对集中的每个元组执行 IIf(Logical_Expression, Set_Expression.Current, NULL)，然后返回所得到的集。
示例
以下示例说明 Filter 函数在查询的行轴上的用法，以便仅返回 Internet Sales Amount 大于 $10000 的 Date：
SELECT
[Measures].[Internet Sales Amount] ON 0,
FILTER(
[Date].[Date].[Date].MEMBERS
,
[Measures].[Internet Sales Amount]>10000)
ON 1
FROM
[Adventure Works]
Filter function 函数还可以在计算成员定义内部使用。 下面的示例将从 Adventure Works 多维数据集中返回 2003 年前九个月（包含在 Date 维度中）聚合的 Measures.[Order
Quantity] 成员之和。 PeriodsToDate 函数定义 Aggregate 函数对其进行运算的集中的元组。 Filter 函数将返回元组限制为先前时段内 Reseller Sales Amount 度量值较低的那些元组。
WITH MEMBER
Measures.[Declining Reseller Sales] AS Count
(Filter
(Existing
(Reseller.Reseller.Reseller),
[Measures].[Reseller Sales Amount]
<
([Measures].[Reseller Sales
Amount],[Date].Calendar.PrevMember)
)
)
MEMBER
[Geography].[State-Province].x AS Aggregate
( {[Geography].[State-Province].&[WA]&[US],
[Geography].[State-Province].&[OR]&[US] }
)
SELECT NON EMPTY
HIERARCHIZE
(AddCalculatedMembers
({DrillDownLevel
({[Product].[All Products]})}
)
) DIMENSION PROPERTIES PARENT_UNIQUE_NAME
ON COLUMNS
FROM [Adventure
Works]
WHERE
([Geography].[State-Province].x,
[Date].[Calendar].[Calendar
Quarter].&[2003]&[4],
[Measures].[Declining Reseller Sales])
52 . FirstChild (MDX)
返回指定成员的第一个子成员。
语法
Member_Expression.FirstChild
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
示例
下面的查询返回 Fiscal 层次结构中 2003 会计年度的第一个子级，也就是 2003 会计年度的第一个半期。
SELECT
[Date].[Fiscal].[Fiscal Year].&[2003].FirstChild ON 0
FROM [Adventure
Works]
53 . FirstSibling (MDX)
返回成员的父成员的第一个子成员。
语法
Member_Expression.FirstSibling
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
示例
以下查询将返回 Fiscal 层次结构中 Fiscal
Year 2003 的第一个同级，即 Fiscal Year 2002。
SELECT
[Date].[Fiscal].[Fiscal Year].&[2003].FirstSibling ON 0
FROM [Adventure
Works]
54 . Generate (MDX)
将一个集应用于另一个集中的每个成员，然后对得到的集求并集。 另外，此函数返回通过用字符串表达式对集求值而创建的串联字符串。
语法
Set expression
syntax
Generate(
Set_Expression1 , Set_Expression2 [ ,
ALL ] )
String expression
syntax
Generate(
Set_Expression1 , String_Expression [
,Delimiter ] )
参数
Set_Expression1
返回集的有效多维表达式 (MDX)。
Set_Expression2
返回集的有效多维表达式 (MDX)。
String_Expression
通常为指定集中每个元组当前成员名称
(CurrentMember.Name) 的有效字符串表达式。
Delimiter
以字符串表达式表示的有效分隔符。
注释
如果指定了第二个集，则 Generate 函数将第二个集中的元组应用于第一个集中的每个元组，再对所得到的集求并集，然后返回生成的集。 如果指定了 ALL，则函数在所得到的集中保留重复项。
如果指定了字符串表达式，则 Generate 函数对第一个集中的每个元组求指定字符串表达式的值，再串联得到的结果，然后返回生成的值。 根据需要，可以分隔字符串，从而分隔得到的串联字符串中的每个结果。
示例
集
在以下示例中，由于
[Date].[Calendar Year].[Calendar Year].MEMBERS 集中有四个成员，因此，查询四次返回包含
Measure Internet Sales Amount 的集：
SELECT
GENERATE(
[Date].[Calendar Year].[Calendar Year].MEMBERS
,
{[Measures].[Internet Sales Amount]}, ALL)
ON 0
FROM [Adventure
Works]
删除 ALL 将更改查询，这样仅返回一次
Internet Sales Amount：
SELECT
GENERATE(
[Date].[Calendar Year].[Calendar Year].MEMBERS
,
{[Measures].[Internet Sales Amount]})
ON 0
FROM [Adventure
Works]
Generate 最常见的实际用法是为一组成员计算复杂集表达式，如 TopCount。 以下示例查询显示行上每个日历年的前 10 种产品：
SELECT
{[Measures].[Internet
Sales Amount]}
ON 0,
GENERATE(
[Date].[Calendar
Year].[Calendar Year].MEMBERS
, TOPCOUNT(
[Date].[Calendar
Year].CURRENTMEMBER
*
[Product].[Product].[Product].MEMBERS
,10,
[Measures].[Internet Sales Amount]))
ON 1
FROM [Adventure
Works]
请注意，每年显示不同的前 10 种产品，使用 Generate 是得到此结果的唯一方法。 将日历年和前 10 种产品的集进行简单交叉联接将显示所有时间的前 10 种产品（每年都重复），如以下示例所示：
SELECT
{[Measures].[Internet
Sales Amount]}
ON 0,
[Date].[Calendar
Year].[Calendar Year].MEMBERS
*
TOPCOUNT(
[Product].[Product].[Product].MEMBERS
,10,
[Measures].[Internet Sales Amount])
ON 1
FROM [Adventure
Works]
字符串
以下示例说明如何使用 Generate 返回字符串：
WITH
MEMBER
MEASURES.GENERATESTRINGDEMO AS
GENERATE(
[Date].[Calendar
Year].[Calendar Year].MEMBERS,
[Date].[Calendar
Year].CURRENTMEMBER.NAME)
MEMBER
MEASURES.GENERATEDELIMITEDSTRINGDEMO AS
GENERATE(
[Date].[Calendar
Year].[Calendar Year].MEMBERS,
[Date].[Calendar
Year].CURRENTMEMBER.NAME, " AND ")
SELECT
{MEASURES.GENERATESTRINGDEMO,
MEASURES.GENERATEDELIMITEDSTRINGDEMO}
ON 0
FROM [Adventure
Works]
|
注意 |
|
由于利用此形式的 Generate 函数能够返回显示集中所有成员名称的字符串，因此，调试计算时，此形式会很有用。 与 SetToStr |
55 . Head (MDX)
返回集中指定数目的前几个元素，同时保留重复项。
语法
Head(Set_Expression
[ ,Count ] )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Count
指定要返回的元组数的有效数值表达式。
注释
Head 函数从指定集的开始处返回指定的元组数目。 并保留元素的顺序。 Count 的默认值为 1。 如果指定的元组数目小于 1，则 Head 函数返回空集。 如果指定的元组数目超过了集中的元组数目，则此函数返回原始集。
示例
以下示例根据 Reseller Gross
Profit 返回产品的前五大销售子类别（与层次结构无关）。 Head 函数用于在使用 Order 函数将结果排序后，仅返回结果中的前 5 个集。
SELECT
[Measures].[Reseller
Gross Profit] ON 0,
Head
(Order
([Product].[Product
Categories].[SubCategory].members
,[Measures].[Reseller Gross Profit]
,BDESC
)
,5
) ON 1
FROM [Adventure
Works]
56 . Hierarchize (MDX)
对层次结构中的某个集的成员进行排序。
语法
Hierarchize(Set_Expression
[ , POST ] )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
注释
Hierarchize 函数按层次结构的顺序组织指定集中的成员。 此函数始终保留重复项。
如果未指定 POST，则此函数按自然顺序对一定级别的成员进行排序。 如果未指定其他排序条件，则成员的自然顺序就是它们在层次结构中的默认排序顺序。 子成员会紧跟在它们的父成员之后。
如果指定了 POST，则 Hierarchize 函数按非自然顺序对一定级别的成员进行排序。 也就是说，子成员优先于他们的父级。
示例
下例浅化了 Canada 成员。 Hierarchize 函数用于按层次结构的顺序组织指定集中的成员，DrillUpMember 函数也要求如此。
SELECT
DrillUpMember
(
Hierarchize
(
{[Geography].[Geography].[Country].[Canada]
,[Geography].[Geography].[Country].[United States]
,[Geography].[Geography].[State-Province].[Alberta]
,[Geography].[Geography].[State-Province].[Brunswick]
,[Geography].[Geography].[State-Province].[Colorado]
}
),
{[Geography].[Geography].[Country].[United States]}
)
ON 0
FROM [Adventure
Works]
下面的示例将从 Adventure
Works 多维数据集中返回 2003 年前九个月（包含在 Date 维度中）聚合的 Measures.[Order Quantity] 成员之和。PeriodsToDate 函数定义
Aggregate 函数对其进行运算的集中的元组。 Hierarchize 函数按层次结构的顺序组织 Product 维度的指定成员集中的成员。
WITH MEMBER
Measures.[Declining Reseller Sales] AS Count
(Filter
(Existing
(Reseller.Reseller.Reseller),
[Measures].[Reseller Sales Amount]
<
([Measures].[Reseller Sales
Amount],[Date].Calendar.PrevMember)
)
)
MEMBER
[Geography].[State-Province].x AS Aggregate
(
{[Geography].[State-Province].&[WA]&[US],
[Geography].[State-Province].&[OR]&[US]
}
)
SELECT NON EMPTY
HIERARCHIZE
(AddCalculatedMembers
({DrillDownLevel
({[Product].[All Products]})}
)
) DIMENSION PROPERTIES PARENT_UNIQUE_NAME
ON COLUMNS
FROM [Adventure
Works]
WHERE ([Geography].[State-Province].x,
[Date].[Calendar].[Calendar
Quarter].&[2003]&[4],
[Measures].[Declining Reseller Sales])
57 . 层次结构 Hierarchy (MDX)
返回包含指定成员或级别的层次结构。
语法
Member expression
syntax
Member_Expression.Hierarchy
Level expression
syntax
Level_Expression.Hierarchy
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
Level_Expression
返回级别的有效多维表达式 (MDX)。
示例
下面的示例返回
AdventureWorks 多维数据集中 Data 维度的 Calendar 层次结构的名称。
WITH
MEMBER Measures.HierarchyName
as
[Date].[Calendar].Currentmember.Hierarchy.Name
SELECT
{Measures.HierarchyName} ON 0,
{[Date].[Calendar].[All
Periods]} ON 1
FROM [Adventure
Works]
58 . IIf (MDX)
根据布尔条件为 true 还是 false，计算不同的分支表达式。
语法
IIf(Logical_Expression,
Expression1 [HINT <hints>], Expression2 [HINT <hints>])
参数
IIf 函数有三个参数：iif(<条件>,
<then 分支>, <else 分支>)。
Logical_Expression
计算结果为 true (1)
或 false (0) 的条件。 它必须是有效的多维表达式 (MDX) 逻辑表达式。
Expression1 Hint
[Eager|Strict|Lazy]]
逻辑表达式的计算结果为 true 时使用。 Expression1
必须是有效的多维表达式 (MDX) 表达式。
Expression2 Hint
[Eager|Strict|Lazy]]
逻辑表达式的计算结果为 false 时使用。 Expression2
必须是有效的多维表达式 (MDX) 表达式。
注释
此表达式的值为零时，逻辑表达式指定的条件的计算结果为 false。 对于其他任何值，计算结果均为 true。
条件为 true 时，IIf 函数返回第一个表达式。 否则，该函数返回第二个表达式。
指定的表达式可以返回值或 MDX 对象。 此外，指定表达式的类型无需匹配。
建议不要用 IIf 函数来创建基于搜索条件的成员集。 请改用 Filter 函数使用逻辑表达式对指定集中的每个成员求值，然后返回成员子集。
|
注意 |
|
如果任意一个表达式的计算结果为 |
提示是一个可选修饰符，用于决定如何以及何时计算表达式。 它允许您通过指定计算表达式的方式来覆盖默认查询计划。
EAGER 针对原始 IIF 子空间计算表达式。
STRICT 仅在逻辑条件表达式创建的受限制子空间中计算表达式。
LAZY 在逐个单元的模式下计算表达式。
EAGER 和 STRICT 仅应用于 IIF 的 then-else 分支，LAZY 则应用于所有 MDX 表达式。 任意 MDX 表达式可以后跟 HINT
LAZY，后者在逐个单元的模式下计算该表达式。
在提示中，EAGER 和 STRICT 是互斥的；可以在不同表达式的相同 IIF(,,) 中使用它们。
有关详细信息，请参阅 SQL Server Analysis
Services 2008 中的 IIF 函数查询提示和 MDX IIF 函数和
CASE 语句的执行计划和计划提示。
示例
以下查询说明 IIF 在计算度量值内部的简单用法，该函数在度量值 Internet Sales Amount 大于或小于 10000 美元时返回两个不同的字符串值之一：
WITH MEMBER
MEASURES.IIFDEMO AS
IIF([Measures].[Internet
Sales Amount]>10000
, "Sales Are
High", "Sales Are Low")
SELECT
{[Measures].[Internet Sales Amount],MEASURES.IIFDEMO} ON 0,
[Date].[Date].[Date].MEMBERS
ON 1
FROM [Adventure
Works]
IIF 的十分常见的用法是处理计算度量值内部的“被零除”错误，如以下示例所示：
WITH
//Returns 1.#INF
when the previous period contains no value
//but the current
period does
MEMBER
MEASURES.[Previous Period Growth With Errors] AS
([Measures].[Internet
Sales Amount]-([Measures].[Internet Sales Amount],
[Date].[Date].CURRENTMEMBER.PREVMEMBER))
/
([Measures].[Internet
Sales Amount], [Date].[Date].CURRENTMEMBER.PREVMEMBER)
,FORMAT_STRING='PERCENT'
//Traps division
by zero and returns null when the previous period contains
//no value but the
current period does
MEMBER
MEASURES.[Previous Period Growth] AS
IIF(([Measures].[Internet
Sales Amount], [Date].[Date].CURRENTMEMBER.PREVMEMBER)=0,
NULL,
([Measures].[Internet
Sales Amount]-([Measures].[Internet Sales Amount],
[Date].[Date].CURRENTMEMBER.PREVMEMBER))
/
([Measures].[Internet
Sales Amount], [Date].[Date].CURRENTMEMBER.PREVMEMBER)
),FORMAT_STRING='PERCENT'
SELECT
{[Measures].[Internet Sales Amount],MEASURES.[Previous Period Growth With
Errors], MEASURES.[Previous Period Growth]} ON 0,
DESCENDANTS(
[Date].[Calendar].[Calendar
Year].&[2004],
[Date].[Calendar].[Date])
ON 1
FROM [Adventure
Works]
WHERE([Product].[Product
Categories].[Subcategory].&[26])
以下是 IIF 的一个示例，在
Generate 函数内部返回两个集之一，以便在行上创建一个复杂的元组集：
SELECT
{[Measures].[Internet Sales Amount]} ON 0,
//If Internet
Sales Amount is zero or null
//returns the
current year and the All Customers member
//else returns the
current year broken down by Country
GENERATE(
[Date].[Calendar
Year].[Calendar Year].MEMBERS
,
IIF([Measures].[Internet Sales Amount]=0,
{([Date].[Calendar
Year].CURRENTMEMBER, [Customer].[Country].[All Customers])}
,
{{[Date].[Calendar Year].CURRENTMEMBER} *
[Customer].[Country].[Country].MEMBERS}
))
ON 1
FROM [Adventure
Works]
WHERE([Product].[Product
Categories].[Subcategory].&[26])
最后，此示例显示如何使用计划提示：
WITH MEMBER
MEASURES.X AS
IIF(
[Measures].[Internet
Sales Amount]=0
, NULL
,
(1/[Measures].[Internet Sales Amount]) HINT EAGER)
SELECT
{[Measures].x} ON 0,
[Customer].[Customer
Geography].[Country].MEMBERS ON 1
FROM [Adventure
Works]
59 . Instr (MDX)
返回一个字符串在另一字符串中第一次出现的位置。
语法
InStr([start,
]searched_string, search_string[, compare])
参数
start
（可选）设置每个搜索的起始位置的一个数值表达式。 如果省略此值，则搜索将会在第一个字符位置开始。 如果 start 为 null，则函数返回值未定义。
searched_string
要搜索的字符串表达式。
search_string
要对其进行搜索的字符串表达式。
Compare
（可选）一个整数值。 始终忽略此参数。 定义此参数是为了与其他语言的其他 Instr 函数兼容。
返回值
具有 String2 在 String1 中的起始位置的一个整数值。
此外，InStr 函数根据以下条件返回在下表中列出的值：
|
条件 |
返回值 |
|
String1 为零长度 |
零 (0) |
|
String1 为 Null |
未定义 |
|
String2 为零长度 |
start |
|
String2 为 Null |
未定义 |
|
找不到 String2 |
零 (0) |
|
start 大于 Len(String2) |
零 (0) |
注释
|
注意 |
|
Instr 始终执行不区分大小写的比较。 |
示例
以下示例说明了 Instr 函数的用法并演示了不同的结果情形。
with
member [Date].[Date].[Results] as
"Results"
member measures.[lowercase found in
lowercase string] as InStr( "abcdefghijklmnñopqrstuvwxyz",
"o")
member measures.[uppercase found in
lowercase string] as InStr( "abcdefghijklmnñopqrstuvwxyz",
"O")
member measures.[searched string is
empty] as InStr( "",
"o")
member measures.[searched string is
null] as iif(IsError(InStr(
null, "o")), "Is Error", iif(IsNull(InStr( null,
"o")), "Is Null","Is undefined"))
member measures.[search string is
empty] as InStr(
"abcdefghijklmnñopqrstuvwxyz", "")
member measures.[search string is empty
start 10] as InStr(10,
"abcdefghijklmnñopqrstuvwxyz", "")
member measures.[search string is
null] as iif(IsError(InStr(
null, "o")), "Is Error", iif(IsNull(InStr( null,
"o")), "Is Null","Is undefined"))
member measures.[found from start 10] as InStr( 10,
"abcdefghijklmnñopqrstuvwxyz", "o")
member measures.[NOT found from start
17] as InStr( 17,
"abcdefghijklmnñopqrstuvwxyz", "o")
member measures.[NULL start] as iif(IsError(InStr(
null, "abcdefghijklmnñopqrstuvwxyz", "o")), "Is
Error", iif(IsNull(InStr( null, "abcdefghijklmnñopqrstuvwxyz",
"o")), "Is Null","Is undefined"))
member measures.[start greater than
searched length] as InStr( 170,
"abcdefghijklmnñopqrstuvwxyz", "o")
select [Results] on columns,
{ measures.[lowercase found in lowercase
string]
, measures.[uppercase found in lowercase
string]
, measures.[searched string is empty]
, measures.[searched string is null]
, measures.[search string is empty]
, measures.[search string is empty start
10]
, measures.[search string is null]
, measures.[found from start 10]
, measures.[NOT found from start 17]
, measures.[NULL start]
, measures.[start greater than searched
length]
} on rows
from [Adventure
Works]
下表显示了获得的结果。
|
结果 |
|
|
lowercase found |
16 |
|
uppercase found in |
16 |
|
searched string |
0 |
|
searched string |
未定义 |
|
search string is |
1 |
|
search string is |
10 |
|
search string is |
未定义 |
|
found from start |
16 |
|
NOT found from |
0 |
|
NULL start |
未定义 |
|
start greater |
0 |
60 . Intersect (MDX)
返回两个输入集的交集，可以选择保留重复项。
语法
Intersect(Set_Expression1
, Set_Expression2 [ , ALL ] )
参数
Set_Expression1
返回集的有效多维表达式 (MDX)。
Set_Expression2
返回集的有效多维表达式 (MDX)。
注释
Intersect 函数返回两个集的交集。 默认情况下，此函数会先删除两个集合中的重复项，然后再对这两个集合求交集。 指定的两个集合必须具有相同的维度。
可以使用可选的 ALL 标志来保留重复项。 如果指定了 ALL，Intersect 函数除了照常对非重复的元素求交集以外，还会对第一个集与第二个集中的重复项求交集。 指定的两个集合必须具有相同的维度。
示例
下面的查询将返回 2003 年和 2004 年，这是在指定的两个集合中均出现的成员：
SELECT
INTERSECT(
{[Date].[Calendar
Year].&[2001], [Date].[Calendar Year].&[2002],[Date].[Calendar
Year].&[2003]}
,
{[Date].[Calendar Year].&[2002],[Date].[Calendar Year].&[2003],
[Date].[Calendar Year].&[2004]})
ON 0
FROM
[Adventure Works]
下面的查询将失败，因为指定的两个集合包含来自不同层次结构的成员：
SELECT
INTERSECT(
{[Date].[Calendar
Year].&[2001]}
,
{[Customer].[City].&[Abingdon]&[ENG]})
ON 0
FROM
[Adventure Works]
61 . IsAncestor (MDX)
返回一个指定成员是否为另一个指定成员的祖先。
语法
IsAncestor(Member_Expression1,
Member_Expression2)
参数
Member_Expression1
返回成员的有效多维表达式 (MDX)。
Member_Expression2
返回成员的有效多维表达式 (MDX)。
注释
如果指定的第一个成员是指定的第二个成员的祖先，则 IsAncestor 函数返回 true。 否则，该函数返回 false。
示例
如果 [Date].[Fiscal].CurrentMember 是 2003 年 1 月的祖先，则下面的示例将返回 true：
WITH MEMBER MEASURES.ISANCESTORDEMO AS
IsAncestor([Date].[Fiscal].CurrentMember,
[Date].[Fiscal].[Month].&[2003]&[1])
SELECT MEASURES.ISANCESTORDEMO ON 0,
[Date].[Fiscal].MEMBERS ON 1
FROM [Adventure Works]
62 . IsEmpty (MDX)
返回表达式的计算结果是否为空单元值。
语法
IsEmpty(Value_Expression)
参数
Value_Expression
有效 MDX（多维表达式）表达式，通常返回成员或元组的单元坐标。
注释
如果表达式的计算结果为空单元值，则 IsEmpty 函数返回 true。 否则，此函数返回 false。
|
注意 |
|
成员的默认属性为成员的值。 |
IsEmpty 函数是唯一可以可靠测试空单元的方法，因为空单元值在 Microsoft SQL Server Analysis Services 中具有特殊含义。
|
重要提示 |
|
如果对值表达式的求值返回错误，该函数将返回 false。 值表达式也可能返回错误，例如，属性引用引用了无效或不存在的属性。 |
有关空单元的详细信息，请参阅 OLE DB
文档。
示例
如果 Date 维度的 Fiscal 层次结构上当前成员的
Internet Sales Amount 返回一个空单元，则下面的示例将返回 TRUE：
WITH MEMBER
MEASURES.ISEMPTYDEMO AS
IsEmpty([Measures].[Internet
Sales Amount])
SELECT
{[Measures].[Internet Sales Amount],MEASURES.ISEMPTYDEMO} ON 0,
[Date].[Fiscal].MEMBERS
ON 1
FROM [Adventure
Works]
63 . IsGeneration (MDX)
返回指定成员是否处于指定的代中。
语法
IsGeneration(Member_Expression,
Generation_Number)
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
Generation_Number
指定对指定成员进行计算的代的数值表达式。
注释
如果指定成员在指定的代号中，则 IsGeneration 函数返回 true。 否则，该函数返回 false。 另外，如果指定成员的计算结果为空成员，则IsGeneration 函数也返回 false。
为了创建代索引，叶成员的代索引为 0。 非叶成员的代索引的确定方式为：先从指定成员的所有子成员的并集中获取最高的代索引，然后向该索引添加 1。 由于非叶成员的代索引的确定方式，一个非叶成员可能会属于多个代。
示例
如果
[Date].[Fiscal].CurrentMember 属于第二代，下面的示例将返回 TRUE。
WITH MEMBER
MEASURES.ISGENERATIONDEMO AS
IsGeneration([Date].[Fiscal].CURRENTMEMBER,
2)
SELECT
{MEASURES.ISGENERATIONDEMO} ON 0,
[Date].[Fiscal].MEMBERS
ON 1
FROM [Adventure
Works]
64 . IsLeaf (MDX)
确定指定成员是否为叶成员。
语法
IsLeaf(Member_Expression)
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
注释
如果指定的成员是叶成员，则 IsLeaf 函数返回 true。 否则，该函数返回 false。
示例
如果
[Date].[Fiscal].CurrentMember 是叶成员，下面的示例将返回 TRUE：
WITH MEMBER
MEASURES.ISLEAFDEMO AS
IsLeaf([Date].[Fiscal].CURRENTMEMBER)
SELECT
{MEASURES.ISLEAFDEMO} ON 0,
[Date].[Fiscal].MEMBERS
ON 1
FROM [Adventure
Works]
65 . IsSibling (MDX)
返回一个指定成员是否为另一个指定成员的同级。
语法
IsSibling(Member_Expression1,
Member_Expression2)
参数
Member_Expression1
返回成员的有效多维表达式 (MDX)。
Member_Expression2
返回成员的有效多维表达式 (MDX)。
注释
如果第一个指定成员与第二个指定成员是同级，则 IsSibling 函数返回 true。 否则，该函数返回 false。
示例
如果 Date 维度的 Fiscal 层次结构上的当前成员是
2002 年 7 月的同级，则下面的示例将返回 TRUE：
WITH MEMBER
MEASURES.ISSIBLINGDEMO AS
IsSibling([Date].[Fiscal].CURRENTMEMBER,
[Date].[Fiscal].[Month].&[2002]&[7])
SELECT
{MEASURES.ISSIBLINGDEMO} ON 0,
[Date].[Fiscal].MEMBERS
ON 1
FROM [Adventure
Works]
66 . Item（成员）(MDX)
返回指定元组中的成员。
语法
Tuple_Expression.Item(
Index )
参数
Tuple_Expression
返回元组的有效多维表达式 (MDX)。
Index
指定要返回元组中指定特定成员位置的有效数值表达式。
注释
Item 函数返回指定元组中的成员。 此函数返回在 Index 所指定的从零开始计算的位置处找到的成员。
示例
下面的示例返回各列上的成员 [2003]（元组 [Date].[Calendar
Year].&[2003], [Measures].[Internet Sales Amount] ). 中的第一项）：
SELECT
{(
[Date].[Calendar Year].&[2003], [Measures].[Internet Sales Amount]
).Item(0)} ON 0
,{[Measures].[Reseller
Sales Amount]} ON 1
FROM [Adventure
Works]
67 . Item（元组）(MDX)
返回某个集中的元组。
语法
Index syntax
Set_Expression.Item(Index)
String expression
syntax
Set_Expression.Item(String_Expression1
[ ,String_Expression2,...n])
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
String_Expression1
通常是以字符串表示的元组的有效字符串表达式。
String_Expression2
通常是以字符串表示的元组的有效字符串表达式。
Index
根据集中位置指定要返回的特定元组的有效数值表达式。
注释
Item 函数返回指定集中的元组。 可以通过三种方式来调用 Item 函数：
如果指定了一个字符串表达式，则 Item 函数返回指定的元组。 例如，"([2005].Q3,
[Store05])"。
如果指定了多个字符串表达式，则 Item 函数返回由指定的坐标定义的元组。 字符串数必须与轴数一致，而且每个字符串都必须标识一个唯一的层次结构。 例如，"[2005].Q3", "[Store05]"。
如果指定了一个整数，则 Item 函数返回位于 Index 所指定的从零开始计算的位置处的元组。
示例
下面的示例返回
([1996],Sales)：
{([1996],Sales),
([1997],Sales), ([1998],Sales)}.Item(0)
下面的示例使用一个级别表达式，并返回
Australia 中每个 State-Province 的 Internet Sales Amount 及其占 Australia 总 Internet
Sales Amount 的百分比。 此示例使用 Item 函数从 Ancestors 函数返回的集中提取第一个项目（仅元组）。
WITH MEMBER
Measures.x AS [Measures].[Internet Sales Amount] /
( [Measures].[Internet Sales Amount],
Ancestors
( [Customer].[Customer
Geography].CurrentMember,
[Customer].[Customer
Geography].[Country]
).Item (0)
), FORMAT_STRING = '0%'
SELECT
{[Measures].[Internet Sales Amount], Measures.x} ON 0,
{ Descendants
( [Customer].[Customer
Geography].[Country].&[Australia],
[Customer].[Customer
Geography].[State-Province], SELF
)
} ON 1
FROM [Adventure
Works]
68 . KPIGoal (MDX)
返回计算指定关键绩效指标 (KPI) 目标部分的值的成员。
语法
KPIGoal(KPI_Name)
参数
KPI_Name
指定 KPI 名称的有效字符串表达式。
注释
示例
下例将为“会计年度”属性层次结构的三个成员的后代返回渠道收入度量值的 KPI 值、KPI 目标、KPI 状态和 KPI 走向：
SELECT
{ KPIValue("Channel Revenue"),
KPIGoal("Channel Revenue"),
KPIStatus("Channel Revenue"),
KPITrend("Channel Revenue")
} ON Columns,
Descendants
( { [Date].[Fiscal].[Fiscal
Year].&[2002],
[Date].[Fiscal].[Fiscal
Year].&[2003],
[Date].[Fiscal].[Fiscal
Year].&[2004]
}, [Date].[Fiscal].[Fiscal Quarter]
) ON Rows
FROM [Adventure
Works]
69 . KPIStatus (MDX)
返回表示指定关键绩效指标 (KPI) 的状态部分的规范化值。
语法
KPIStatus(KPI_Name)
参数
KPI_Name
指定 KPI 名称的有效字符串表达式。
注释
状态值通常为介于 -1 到 1 之间的规范化值。
示例
下例将返回 Fiscal Year 属性层次结构中三个成员后代的渠道收入度量值的 KPI 值、KPI 目标、KPI 状态和 KPI 走向：
SELECT
{ KPIValue("Channel Revenue"),
KPIGoal("Channel Revenue"),
KPIStatus("Channel Revenue"),
KPITrend("Channel Revenue")
} ON Columns,
Descendants
( { [Date].[Fiscal].[Fiscal
Year].&[2002],
[Date].[Fiscal].[Fiscal
Year].&[2003],
[Date].[Fiscal].[Fiscal
Year].&[2004]
}, [Date].[Fiscal].[Fiscal Quarter]
) ON Rows
FROM [Adventure
Works]
70 . KPITrend (MDX)
返回表示指定关键绩效指标 (KPI) 走向部分的规范化值。
语法
KPITrend(KPI_Name)
参数
KPI_Name
指定 KPI 名称的有效字符串表达式。
注释
走向值通常为介于 -1 到 1 之间的规范化值。
示例
下例将返回 Fiscal Year 属性层次结构中三个成员后代的渠道收入度量值的 KPI 值、KPI 目标、KPI 状态和 KPI 走向：
SELECT
{ KPIValue("Channel Revenue"),
KPIGoal("Channel Revenue"),
KPIStatus("Channel Revenue"),
KPITrend("Channel Revenue")
} ON Columns,
Descendants
( { [Date].[Fiscal].[Fiscal
Year].&[2002],
[Date].[Fiscal].[Fiscal
Year].&[2003],
[Date].[Fiscal].[Fiscal
Year].&[2004]
}, [Date].[Fiscal].[Fiscal Quarter]
) ON Rows
FROM [Adventure
Works]
71 . KPIWeight (MDX)
返回指定关键绩效指标 (KPI) 的权重。
语法
KPIWeight(KPI_Name)
参数
KPI_Name
指定 KPI 名称的有效字符串表达式。
注释
返回的值是 KPI 在父级中所占的比例。
72 . KPICurrentTimeMember (MDX)
返回指定关键绩效指标 (KPI) 的当前时间成员。
语法
KPICurrentTimeMember(KPI_Name)
参数
KPI_Name
指定 KPI 名称的有效字符串表达式。
注释
KPI 可具有与时间维度的默认成员不同的时间成员。
73 . KPIValue (MDX)
返回计算指定关键绩效指标 (KPI) 的值的成员。
语法
KPIValue(KPI_Name)
参数
KPI_Name
指定 KPI 名称的有效字符串表达式。
注释
示例
下例将返回 Fiscal Year 属性层次结构中三个成员后代的渠道收入度量值的 KPI 值、KPI 目标、KPI 状态和 KPI 走向。
SELECT
{ KPIValue("Channel Revenue"),
KPIGoal("Channel Revenue"),
KPIStatus("Channel Revenue"),
KPITrend("Channel Revenue")
} ON Columns,
Descendants
( { [Date].[Fiscal].[Fiscal
Year].&[2002],
[Date].[Fiscal].[Fiscal
Year].&[2003],
[Date].[Fiscal].[Fiscal
Year].&[2004]
}, [Date].[Fiscal].[Fiscal Quarter]
) ON Rows
FROM [Adventure
Works]
74 . Lag (MDX)
返回在成员级别中比指定成员位置靠前且靠前位数为指定位数的成员。
语法
Member_Expression.Lag(Index)
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
Index
指定成员位置滞后位数的有效数值表达式。
注释
级别内的成员位置由属性层次结构的自然顺序决定。 位置的编号从零开始。
如果指定的滞后为 0，则 Lag 函数返回所指定成员本身。
如果指定的滞后为负，则 Lag 函数返回后续成员。
Lag(1) 等效于 PrevMember 函数。 Lag(-1) 等效于 NextMember 函数。
Lag 函数与 Lead 函数相似，只不过 Lead 函数与 Lag 函数查找成员的方向相反。 也就是说，Lag(n) 等效于 Lead(-n)。
示例
下例将返回 2001 年 12 月的值：
SELECT
[Date].[Fiscal].[Month].[February 2002].Lag(2) ON 0
FROM [Adventure
Works]
下例将返回 2002 年 3 月的值：
SELECT
[Date].[Fiscal].[Month].[February 2002].Lag(-1) ON 0
FROM [Adventure
Works]
75 . LastChild (MDX)
返回指定成员的最后一个子成员。
语法
Member_Expression.LastChild
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
示例
下例将返回 2001 年 9 月的值，它是 2002 会计年度第一个会计季度的最后一个子成员。
SELECT
[Date].[Fiscal].[Fiscal Quarter].[Q1 FY 2002].LastChild ON 0
FROM [Adventure
Works]
76 . LastPeriods (MDX)
返回指定成员之前的成员集（含该成员）。
语法
LastPeriods(Index
[ ,Member_Expression ] )
参数
Index
指定期间数的有效数值表达式。
Member_Expression
返回成员的有效多维表达式 (MDX)。
注释
如果指定的期间数为正，则 LastPeriods 函数返回一个成员集，其中的成员从比指定成员表达式滞后 Index - 1 个位置的成员开始，到指定的成员为止。 此函数所返回的成员数等于 Index。
如果指定的期间数为负，则 LastPeriods 函数返回一个成员集，其中的成员从指定的成员开始，到比指定的成员超前 Index - 1 个位置的成员为止。 此函数所返回的成员数等于 Index 的绝对值。
如果指定的期间数为零，则 LastPeriods 函数返回空集。 这不同于 Lag 函数，该函数在指定了 0 时返回指定的成员。
如果未指定成员，LastPeriods 函数将使用 Time.CurrentMember。 如果没有任何一个维度标记为
Time 维度，该函数将在不发生错误的情况下分析并执行，但将导致客户端应用程序出现单元错误。
示例
下面的示例返回 2002 会计年度第二、第三和第四会计季度的默认度量值。
SELECT
LastPeriods(3,[Date].[Fiscal].[Fiscal Quarter].[Q4 FY 2002]) ON 0
FROM [Adventure
Works]
|
注意 |
|
此示例还可以用 :（冒号）运算符编写： [Date].[Fiscal].[Fiscal |
下面的示例返回 2002 会计年度第一会计季度的默认度量值。 虽然指定的期间数为三个，但是只能返回一个，因为该会计年度中没有更早的期间。
SELECT LastPeriods
(3,[Date].[Fiscal].[Fiscal Quarter].[Q1 FY
2002]
) ON 0
FROM [Adventure
Works]
77 . LastSibling (MDX)
返回指定成员的父成员的最后一个子成员。
语法
Member_Expression.LastSibling
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
示例
下面的示例返回 2002 年 7 月最后一天的默认度量值。
SELECT
[Date].[Fiscal].[Date].&[20020717].LastSibling
ON 0
FROM [Adventure
Works]
78 . Lead (MDX)
返回在成员级别中比指定成员位置靠后且靠后位数为指定位数的成员。
语法
Member_Expression.Lead(
Index )
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
Index
指定成员位置位数的有效数值表达式。
注释
级别内的成员位置由属性层次结构的自然顺序决定。 位置的编号从零开始。
如果指定的前置位数为零 (0)，则 Lead 函数返回指定的成员。
如果指定的前置位数为负，则 Lead 函数返回前面的成员。
Lead(1) 等效于 NextMember 函数。 Lead(-1) 等效于 PrevMember 函数。
Lead 函数与 Lag 函数相似，只不过 Lag 函数与 Lead 函数查找成员的方向相反。 也就是说，Lead(n) 等效于 Lag(-n)。
示例
下例将返回 2001 年 12 月的值：
SELECT [Date].[Fiscal].[Month].[February
2002].Lead(-2) ON 0
FROM [Adventure
Works]
下例将返回 2002 年 3 月的值：
SELECT
[Date].[Fiscal].[Month].[February 2002].Lead(1) ON 0
FROM [Adventure
Works]
79. Leaves (MDX)
返回由所有属性（或者限制为属于特定维度的属性）组成的集。 对于返回集中的每个属性 x，如果 x 是粒度属性或者直接或间接与粒度属性相关，则在属性 x 上设置粒度而不会影响切片。 Leaves 函数设计为用在 SCOPE 语句内部或赋值语句的左侧。
语法
Leaves( [
Dimension_expression ] )
参数
Dimension_Expression
返回维度的有效多维表达式 (MDX)。
注释
叶成员是由所有属性层次结构中的最低级别交叉联接构成的元组。 已排除了计算成员。
如果指定了维度名称，则 Leaves 函数返回的集中将包含指定维度的键属性的叶成员。
如果维度与多个度量值组相关联，将使用当前作用域中度量值的维度。
如果未指定维度名称，则此函数返回的集中将包含整个多维数据集的叶成员。
|
注意 |
|
如果维度表达式解析为层次结构，并且层次结构的唯一名称与维度的唯一名称相同（多维数据集维度属性 HierarchyUniqueNameStyle=ExcludeDimensionName，并且层次结构名称 = 维度名称），则已经使用该维度。 |
|
重要提示 |
|
如果并非所有属性在当前范围内的度量值组中均具备相同的粒度，则会产生错误。 |
80. Level (MDX)
返回成员的级别。
语法
Member_Expression.Level
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
示例
以下示例使用 Level 函数返回
Adventure Works 多维数据集中的所有月份。
SELECT[Date].[Fiscal].[Month].[February
2002].Level.Members ON 0,
[Measures].[Internet
Sales Amount] ON 1
FROM [Adventure
Works]
下例使用 Level 函数返回
Adventure Works 多维数据集中“型号名称”属性层次结构内的“多用途自行车架”级别的名称。
WITH MEMBER
Measures.x AS
[Product].[Model Name].[All-Purpose Bike
Stand].Level.Name
SELECT Measures.x
ON 0
FROM [Adventure
Works]
81. Levels (MDX)
返回由数值表达式指定在维度或层次结构中的位置的级别，或返回由字符串表达式指定名称的级别。
语法
Numeric expression
syntax
Hierarchy_Expression.Levels(
Level_Number )
String expression
syntax
Hierarchy_Expression.Levels(
Level_Name )
参数
Hierarchy_Expression
返回层次结构的有效多维表达式 (MDX)。
Level_Number
指定级别号的有效数值表达式。
Level_Name
指定级别名称的有效字符串表达式。
注释
如果指定了级别号，则 Levels 函数返回与从零开始的指定位置相关联的级别。
如果指定了级别名称，则 Levels 函数返回指定的级别。
|
注意 |
|
将字符串表达式语法用于用户定义的函数。 |
示例
下例说明了 Levels 函数的各种语法。
数值
以下示例返回国家（地区）级别：
SELECT
[Geography].[Geography].Levels(1) ON 0
FROM [Adventure
Works]
字符串
以下示例返回国家（地区）级别：
SELECT
[Geography].[Geography].Levels('Country') ON 0
FROM [Adventure
Works]
82. LinkMember (MDX)
返回相当于指定层次结构中的指定成员的成员。
语法
LinkMember(Member_Expression,
Hierarchy_Expression)
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
Hierarchy_Expression
返回层次结构的有效多维表达式 (MDX)。
注释
LinkMember 函数返回与相关层次结构中指定成员每个级别的键值相匹配的指定层次结构中的成员。 每个级别上的属性必须具有相同的键基数和数据类型。 在非自然层次结构中，如果某属性的键值有多个匹配项，结果将是错误的或不确定。
示例
下面的示例使用 LinkMember 函数从 Adventure
Works 多维数据集中返回 Calendar 层次结构中 Date.Date 属性层次结构的“July 1, 2002”成员后代的默认度量值。
SELECT Hierarchize
(Ascendants
(LinkMember
([Date].[Date].[July 1, 2002],
[Date].[Calendar]
)
)
) ON 0
FROM [Adventure Works]
83. LinRegIntercept (MDX)
对集进行线性回归计算，并返回回归线公式 y
= ax + b 中 x 截距的值。
语法
LinRegIntercept(Set_Expression,
Numeric_Expression_y [ ,Numeric_Expression_x ] )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Numeric_Expression_y
返回表示 Y 轴值的数字的有效数值表达式，通常是单元坐标的多维表达式 (MDX)。
Numeric_Expression_x
返回表示 X 轴值的数字的有效数值表达式，通常是单元坐标的多维表达式 (MDX)。
注释
线性回归使用最小二乘法，可以计算出回归线（即一系列点的最佳拟合线）的公式。 回归线具有如下公式，其中 a 为斜率，b 为截距：
y = ax+b
LinRegIntercept 函数对指定集计算第一个数值表达式的值，以获得 Y 轴的值。 然后，该函数对指定集计算第二个数值表达式（如果指定）的值，以获得 X 轴的值。 如果未指定第二个数值表达式，则该函数使用指定集中的单元的当前上下文作为 X 轴的值。 通常不对时间维度指定 X 轴参数。
获取点集后，LinRegIntercept 函数返回回归线的截距（前一等式中的 b）。
|
注意 |
|
LinRegIntercept 函数将忽略空单元或包含文本或逻辑值的单元。 但是，该函数可以包含值为零的单元。 |
示例
下例将返回单位销售额和存储销售额的回归线截距。
LinRegIntercept(LastPeriods(10),[Measures].[Unit
Sales],[Measures].[Store Sales])
84. LinRegPoint (MDX)
计算集的线性回归，并为特定 x 值返回回归线公式 y
= ax + b 中的 y-intercept 值。
语法
LinRegPoint(Slice_Expression_x,
Set_Expression, Numeric_Expression_y [ ,Numeric_Expression_x ] )
参数
Slice_Expression_x
一个有效的数值表达式，通常为返回一个数值（该数值表示切片轴的值）的单元坐标的多维表达式 (MDX)。
Set_Expression
返回集的有效多维表达式 (MDX)。
Numeric_Expression_y
返回表示 Y 轴值的数字的有效数值表达式，通常是单元坐标的多维表达式 (MDX)。
Numeric_Expression_x
返回表示 X 轴值的数字的有效数值表达式，通常是单元坐标的多维表达式 (MDX)。
注释
线性回归使用最小二乘法，可以计算出回归线（即一系列点的最佳拟合线）的公式。 回归线具有如下公式，其中 a 为斜率，b 为截距：
y = ax+b
LinRegPoint 函数根据第二个数值表达式对指定的集求值，以获得 Y 轴的值。 然后，此函数根据第三个数值表达式（如果已指定）对指定集求值，以获取 X 轴的值。 如果未指定第三个数值表达式，则该函数将使用指定集中单元的当前上下文作为 X 轴的值。 通常不对“时间”维度指定 X 轴参数。
一旦计算完线性回归线，即为第一个数值表达式计算等式的值，并且随后返回该值。
|
注意 |
|
LinRegPoint 函数会忽略空单元或包含文本的单元。 但是，该函数可以包含值为零的单元。 |
示例
下例根据单位销售额和商店销售额之间的统计关系，依据过去十个时期的数据得出单位销售额的预测值。
LinRegPoint([Measures].[Unit
Sales],LastPeriods(10),[Measures].[Unit Sales],[Measures].[Store Sales])
85. LinRegR2 (MDX)
计算集的线性回归并返回确定系数 R2。
语法
LinRegR2(Set_Expression,
Numeric_Expression_y [ ,Numeric_Expression_x ] )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Numeric_Expression_y
返回表示 Y 轴值的数字的有效数值表达式，通常是单元坐标的多维表达式 (MDX)。
Numeric_Expression_x
返回表示 X 轴值的数字的有效数值表达式，通常是单元坐标的多维表达式 (MDX)。
注释
线性回归使用最小二乘法，可以计算出回归线（即一系列点的最佳拟合线）的公式。 回归线具有如下公式，其中 a 为斜率，b 为截距：
y = ax+b
LinRegR2 函数根据第一个数值表达式对指定的集求值，以获得Y轴的值。 然后，该函数对指定集计算第二个数值表达式（如果指定）的值，以获得 X 轴的值。 如果未指定第二个数值表达式，则此函数使用指定集中的单元的当前上下文作为X 轴的值。 通常不对时间维度指定 X轴参数。
获得点集后，LinRegR2 函数会返回用来描述线性方程与点的拟合程度的统计 R2。
|
注意 |
|
LinRegR2 函数将忽略空单元以及包含文本或逻辑值的单元。 但是，该函数可以包含值为零的单元。 |
示例
下面的示例返回统计量 R2，它描述线性回归方程与单元销售额和存储销售额度量值点的拟合度。
LinRegR2(LastPeriods(10),
[Measures].[Unit Sales],[Measures].[Store Sales])
86. LinRegSlope (MDX)
对集进行线性回归计算，并返回回归线公式 y
= ax + b 中斜率的值。
语法
LinRegSlope(Set_Expression,
Numeric_Expression_y [ ,Numeric_Expression_x ] )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Numeric_Expression_y
返回表示 Y 轴值的数字的有效数值表达式，通常是单元坐标的多维表达式 (MDX)。
Numeric_Expression_x
返回表示 X 轴值的数字的有效数值表达式，通常是单元坐标的多维表达式 (MDX)。
注释
线性回归使用最小二乘法，可以计算出回归线（即一系列点的最佳拟合线）的公式。 回归线具有如下公式，其中 a 为斜率，b 为截距：
y = ax+b
LinRegSlope 函数根据第一个数值表达式对指定的集求值，以获得 Y 轴的值。 然后，此函数根据第二个数值表达式（如果已指定）对指定的集表达式求值，以获取 X 轴的值。 如果未指定第二个数值表达式，则此函数使用指定集中的单元的当前上下文作为 X 轴的值。 通常不对时间维度指定 X 轴参数。
获取点集后，LinRegSlope 函数返回回归线的斜率（前一等式中的 a）。
|
注意 |
|
LinRegSlope 函数将忽略空单元，以及包含文本或逻辑值的单元。 但是，该函数将包含值为零的单元。 |
示例
下面的示例返回单位销售额和商店销售额度量值的回归线的斜率。
LinRegSlope(LastPeriods(10),[Measures].[Unit
Sales],[Measures].[Store Sales])
87. LinRegVariance (MDX)
对集进行线性回归计算，并返回与回归线公式 y
= ax + b 相关的方差。
语法
LinRegVariance(Set_Expression,
Numeric_Expression_y [ ,Numeric_Expression_x ] ] )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Numeric_Expression_y
返回表示 Y 轴值的数字的有效数值表达式，通常是单元坐标的多维表达式 (MDX)。
Numeric_Expression_x
返回表示 X 轴值的数字的有效数值表达式，通常是单元坐标的多维表达式 (MDX)。
注释
线性回归使用最小二乘法，可以计算出回归线（即一系列点的最佳拟合线）的公式。 回归线具有如下公式，其中 a 为斜率，b 为截距：
y = ax+b
LinRegVariance 函数针对指定集计算第一个数值表达式的值，以获得 Y 轴的值。 然后，该函数针对指定集计算第二个数值表达式（如果指定）的值，以获得 X轴的值。 如果未指定第二个数值表达式，则此函数使用指定集中的单元的当前上下文作为X 轴的值。 通常不对时间维度指定 X 轴参数。
获得点集后，LinRegVariance 函数会返回用来描述线性方程与点的拟合程度的总体方差。
|
注意 |
|
LinRegVariance 函数将忽略空单元，以及包含文本或逻辑值的单元。 但是，该函数将包含值为零的单元。 |
示例
下例返回一个方差，该方差描述了单位销售额和商店销售额度量值的线性方程与点的拟合程度。
LinRegVariance(LastPeriods(10),[Measures].[Unit
Sales],[Measures].[Store Sales])
88. LookupCube (MDX)
返回用多维表达式 (MDX) 对同一数据库中的另一个指定多维数据集求得的值。
语法
Numeric expression
syntax
LookupCube(Cube_Name,
Numeric_Expression )
String expression
syntax
LookupCube(Cube_Name,
String_Expression )
参数
Cube_Name
指定多维数据集名称的有效字符串表达式。
Numeric_Expression
一个有效的数值表达式，通常为返回一个数值的单元坐标的多维表达式 (MDX)。
String_Expression
一个有效的字符串表达式，通常为返回一个字符串的单元坐标的有效多维表达式 (MDX)。
注释
如果指定了某个数值表达式，则 LookupCube 函数在指定的多维数据集内计算指定的数值表达式并且返回得到的数值。
如果指定了某个字符串表达式，则 LookupCube 函数在指定的多维数据集内计算指定的字符串表达式并且返回得到的字符串。
LookupCube 函数在源多维数据集（对其执行包含 LookupCube 函数的 MDX 查询）所在的数据库内对多维数据集进行处理。
|
重要提示 |
|
因为当前查询的上下文不会延续到将要查询的多维数据集，所以必须在数值或字符串表达式内提供任何必要的当前成员。 |
使用 LookupCube 函数的任何计算很可能会遭遇不佳的性能。 请考虑重新设计您的解决方案，而不是使用此函数，以便在一个多维数据集中提供您所需的所有数据。
示例
以下查询演示 LookupCube 的用法：
WITH MEMBER
MEASURES.LOOKUPCUBEDEMO AS
LOOKUPCUBE("Adventure
Works", "[Measures].[In" + "ternet Sales Amount]")
SELECT
MEASURES.LOOKUPCUBEDEMO ON 0
FROM [Adventure
Works]
89.Max (MDX)
返回对集求值的数值表达式的最大值。
语法
Max(
Set_Expression [ , Numeric_Expression ] )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Numeric_Expression
有效的数值表达式，通常为返回数值的单元坐标的多维表达式 (MDX)。
注释
如果指定了数值表达式，则对集计算指定数值表达式的值，然后返回求得的最大值。 如果没有指定数值表达式，则在指定集成员的当前上下文中计算指定集，然后返回求得的最大值。
|
注意 |
|
计算一组数值的最大值时，Analysis |
示例
下面的示例将返回 Adventure
Works 多维数据集中每个季度、子类别和国家（地区）的最大每月销售额。
WITH MEMBER
Measures.x AS Max
([Date].[Calendar].CurrentMember.Children
, [Measures].[Reseller Order Quantity]
)
SELECT Measures.x
ON 0
,NON EMPTY
[Date].[Calendar].[Calendar Quarter]*
[Product].[Product
Categories].[Subcategory].members *
[Geography].[Geography].[Country].Members
ON 1
FROM [Adventure
Works]
90．MeasureGroupMeasures
(MDX)
返回一组属于指定度量值组的度量值。
语法
MEASUREGROUPMEASURES(MeasureGroupName)
参数
MeasureGroupName
有效字符串表达式，其中包含要从中检索度量值集的度量值组的名称。
注释
指定的字符串必须与度量值组名称精确匹配。 对于带空格的度量值组，不要求一定使用方括号。
示例
下例返回 Adventure Works 多维数据集“Internet
Sales”度量值组中的所有度量值。
SELECT
MeasureGroupMeasures('Internet Sales') ON 0
FROM [Adventure
Works]
91. Median (MDX)
返回对集求值的数值表达式的中值。
语法
Median(Set_Expression
[ ,Numeric_Expression ] )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Numeric_Expression
有效的数值表达式，通常为返回数值的单元坐标的多维表达式 (MDX)。
注释
如果指定了数值表达式，则对集计算指定数值表达式的值，然后返回求得的中值。 如果没有指定数值表达式，则在指定集成员的当前上下文中计算指定集，然后返回求得的中值。
中值是一组有序数值的中间值。 （中值不同于平均值，平均值是一组数值的总和除以这组数值的个数所得的值）。 中值是通过选择最小值以使这组数值中至少有一半值不大于所选的值来确定的。 如果这组数值的个数为奇数，则中值对应于单个值。 如果这组数值的个数为偶数，则中值对应于两个中间值的和除以 2 所得的值。
|
注意 |
|
计算一组有序数值的中值时，Analysis |
示例
下例将返回 Adventure Works
多维数据集中每个季度、每个子类别和每个国家（地区）的每月销售额中值。
WITH MEMBER
Measures.x AS Median
([Date].[Calendar].CurrentMember.Children
, [Measures].[Reseller Order Quantity]
)
SELECT Measures.x
ON 0
,NON EMPTY
[Date].[Calendar].[Calendar Quarter]*
[Product].[Product
Categories].[Subcategory].members *
[Geography].[Geography].[Country].Members
ON 1
FROM [Adventure
Works]
92. Members（集）(MDX)
返回某个维度、级别或层次结构中的成员集。
语法
Hierarchy
expression syntax
Hierarchy_Expression.Members
Level expression
Syntax
Level_Expression.Members
参数
Hierarchy_Expression
返回层次结构的有效多维表达式 (MDX)。
Level_Expression
返回级别的有效多维表达式 (MDX)。
注释
如果指定了某个层次结构表达式，则 Members
(Set) 函数返回该指定层次结构内所有成员（不包括计算成员）的集。 若要获取层次结构中所有成员（计算成员或其他成员）的集，请使用 AllMembers
(MDX) 函数
如果指定了某个级别表达式，则 Members
(Set) 函数返回该指定级别的所有成员的集。
|
重要提示 |
|
如果维度仅包含单个可见层次结构，由于在此情况下维度名称将解析为其唯一可见的层次结构，所以既可以通过维度名称也可以通过层次结构名称来引用该层次结构。 例如，因为 |
示例
下例返回 Adventure Works 多维数据集中“日历年”层次结构的所有成员的集。
SELECT
[Date].[Calendar].[Calendar Year].Members ON
0
FROM
[Adventure Works]
下面的示例将返回 [Product].[Products].[Product
Line] 级别中每个成员在 2003 年的订单数量。 Members 函数将返回代表该级别所有成员的集。
SELECT
{Measures.[Order Quantity]} ON COLUMNS,
[Product].[Product Line].[Product
Line].Members ON ROWS
FROM
[Adventure Works]
WHERE
{[Date].[Calendar Year].[Calendar
Year].&[2003]}
93. Members（字符串）(MDX)
返回字符串表达式指定的成员。
语法
Members(Member_Name)
参数
Member_Name
指定成员名称的有效字符串表达式。
注释
Members
(String) 函数返回已指定名称的单个成员。 通常，将 Members (String) 函数与外部函数一起使用，为 Members
(String) 函数提供一个用于标识成员的字符串，并且 Members (String) 函数返回该指定成员的值。
示例
下面的示例使用 Members
(String) 函数将指定的字符串转换为有效成员，然后为该字符串中指定的成员返回默认度量值。 指定的字符串用单引号引起来。 默认度量值为 Reseller Sales Amount 度量值。
SELECT Members
('[Geography].[Geography].[Country].&[United States] ') ON 0
FROM [Adventure
Works]
94. MemberToStr (MDX)
返回与指定成员对应的多维表达式 (MDX)
格式的字符串。
语法
MemberToStr(Member_Expression)
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
注释
此函数返回包含成员的唯一名称的字符串。 它通常用于将某一成员的唯一名称返回到外部函数。
示例
下例返回字符串
[Geography].[Geography].[Country].&[United States]：
WITH MEMBER
Measures.x AS MemberToStr
([Geography].[Geography].[Country].[United
States])
SELECT Measures.x
ON 0
FROM [Adventure
Works]
95. MemberValue (MDX)
返回成员的值。
语法
Member_Expression.MemberValue
参数
Member_Expression
计算结果为成员的有效多维表达式 (MDX)。
返回值
返回的成员值包含以下信息（按这些信息在返回值中出现的顺序列出）：
值绑定（如果已定义）。
原始数据类型的键（如果不存在名称绑定，或者键和标题绑定到同一列）。
成员的标题。
示例
下例将返回 Adventure Works
多维数据集 Date 维度中的第一个日期的值绑定、成员键和标题。
WITH MEMBER
Measures.ValueColumn as [Date].[Calendar].[July 1, 2001].MemberValue
MEMBER
Measures.KeyColumn as [Date].[Calendar].[July 1, 2001].Member_Key
MEMBER
Measures.NameColumn as [Date].[Calendar].[July 1, 2001].Member_Name
SELECT
{Measures.ValueColumn, Measures.KeyColumn, Measures.NameColumn} ON 0
from [Adventure
Works]
96. Min (MDX)
返回对集求值的数值表达式的最小值。
语法
Min(
Set_Expression [ , Numeric_Expression ] )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Numeric_Expression
有效的数值表达式，通常为返回数值的单元坐标的多维表达式 (MDX)。
注释
如果指定了数值表达式，则指定的数值表达式对集求值，然后返回该求值的最小值。 如果未指定数值表达式，则在指定集的成员的当前上下文中对该集求值，然后该求值的最小值。
|
注意 |
|
计算一组数值的最小值时，Analysis |
示例
下面的示例返回 Adventure
Works 多维数据集中每个子类别和国家/地区的最小季度销售额。
WITH MEMBER
Measures.x AS Min
([Date].[Calendar].CurrentMember.Children
, [Measures].[Reseller Order Quantity]
)
SELECT Measures.x
ON 0
,NON EMPTY
[Date].[Calendar].[Calendar Quarter]*
[Product].[Product
Categories].[Subcategory].members *
[Geography].[Geography].[Country].Members
ON 1
FROM [Adventure
Works]
97. Mtd (MDX)
按照时间维度中的年级别的约束，从给定成员所在的级别返回一组同级成员，从第一个同级成员开始到给定成员为止。
语法
Mtd( [
Member_Expression ] )
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
注释
如果未指定成员表达式，则默认值为第一个层次结构的当前成员并且具有度量值组中 Time 类型的第一个维度中的 Months 类型的级别。
在某一级别所基于的属性层次结构的 Type
属性设置为 Months 时，Mtd 函数是 PeriodsToDate 函数的快捷函数。 也就是说，Mtd(Member_Expression) 等效于 PeriodsToDate(Month_Level_Expression,Member_Expression)。
示例
下例将返回 2002 年 7 月（截止于 2002 年 7 月 20 日）Internet 销售的当月运费成本总和。
WITH MEMBER
Measures.x AS SUM
(
MTD([Date].[Calendar].[Date].[July 20,
2002])
, [Measures].[Internet Freight Cost]
)
SELECT Measures.x
ON 0
FROM [Adventure
Works]
98. Name (MDX)
返回维度、层次结构、级别或成员的名称。
语法
Dimension
expression syntax
Dimension_Expression.Name
Hierarchy
expression syntax
Hierarchy_Expression.Name
Level_expression
syntax
Level_Expression.Name
Member expression
syntax
Member_Expression.Name
参数
Dimension_Expression
返回维度的有效多维表达式 (MDX)。
Hierarchy_Expression
返回层次结构的有效多维表达式 (MDX)。
Level_Expression
返回级别的有效多维表达式 (MDX)。
Member_Expression
返回成员的有效多维表达式 (MDX)。
注释
Name 函数返回对象的名称，而不是唯一名称。
示例
维度、层次结构和级别表达式示例
下面的示例返回 Date 维度的维度名称以及
July 2001 成员的层次结构和级别名称。
WITH MEMBER
Measures.DimensionName AS [Date].Name
MEMBER
Measures.HierarchyName AS [Date].[Calendar].[July 2001].Hierarchy.Name
MEMBER
Measures.LevelName as [Date].[Calendar].[July 2001].Level.Name
SELECT
{Measures.DimensionName, Measures.HierarchyName, Measures.LevelName} ON 0
from [Adventure
Works]
成员表达式示例
下面的示例返回成员名称以及成员值、成员键和成员标题。
WITH MEMBER
MemberName AS [Date].[Calendar].[July 1, 2001].Name
MEMBER
Measures.ValueColumn as [Date].[Calendar].[July 1, 2001].MemberValue
MEMBER
Measures.KeyColumn as [Date].[Calendar].[July 1, 2001].Member_Key
MEMBER Measures.NameColumn
as [Date].[Calendar].[July 1, 2001].Member_Name
SELECT
{Measures.MemberName, Measures.ValueColumn, Measures.KeyColumn,
Measures.NameColumn} ON 0
from [Adventure
Works]
99. NameToSet (MDX)
返回多维表达式 (MDX) 格式的字符串指定的成员组成的集。
语法
NameToSet(Member_Name)
参数
Member_Name
代表成员名称的有效字符串表达式。
注释
如果指定的成员名称存在，则 NameToSet 函数返回包含该成员的集。 否则，此函数返回空集。
|
注意 |
|
指定的成员名称只能是成员名称，不能是成员表达式。 若要使用成员表达式，请参阅 StrToSet |
示例
下例返回指定成员名称的默认度量值。
SELECT
NameToSet('[Date].[Calendar].[July 2001]') ON 0
FROM [Adventure
Works]
100. NextMember (MDX)
返回指定成员所在级别的下一个成员。
语法
Member_Expression.NextMember
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
注释
NextMember 函数返回与指定成员位于同一级别的下一个成员。
示例
下例将返回作为 July 2001 成员的下一个成员的
August 2001 成员。
SELECT
[Date].[Calendar].[Month].[July 2001].NextMember ON 0
FROM [Adventure
Works]
101. NonEmpty (MDX)
根据第一个指定集与第二个集的叉积，返回指定集中的非空元组集。
语法
NONEMPTY(set_expression1
[,set_expression2])
参数
set_expression1
返回集的有效多维表达式 (MDX)。
set_expression2
返回集的有效多维表达式 (MDX)。
注释
此函数返回位于第一个指定集中并且在对第二个集中的元组求值时不为空的元组。 NonEmpty 函数将考虑计算并保留重复元组。 如果未提供第二个集，将在多维数据集中属性层次结构和度量值的成员的当前坐标上下文中对表达式求值。
|
注意 |
|
|
使用此函数，而不使用不推荐的 NonEmptyCrossjoin |
|
|
重要提示 |
|
|
非空是元组所引用的单元的特征，而不是元组本身的特征。 |
|
示例
以下查询说明 NonEmpty 的简单示例，该函数返回
2001 年 7 月 1 日 Internet Sales Amount 的值为非 null 的所有 Customer：
SELECT
[Measures].[Internet Sales Amount] ON 0,
NONEMPTY(
[Customer].[Customer].[Customer].MEMBERS
,
{([Date].[Calendar].[Date].&[20010701], [Measures].[Internet Sales
Amount])}
)
ON 1
FROM [Adventure
Works]
以下示例将返回包含客户和采购日期的元组集，并且使用 Filter 函数和 NonEmpty 函数来查找每个客户的最后一次采购日期：
WITH SET MYROWS AS
FILTER
(NONEMPTY
([Customer].[Customer
Geography].[Customer].MEMBERS
*
[Date].[Date].[Date].MEMBERS
,
[Measures].[Internet Sales Amount]
) AS MYSET
,
NOT(MYSET.CURRENT.ITEM(0)
IS
MYSET.ITEM(RANK(MYSET.CURRENT, MYSET)).ITEM(0))
)
SELECT
[Measures].[Internet Sales Amount] ON 0,
MYROWS ON 1
FROM [Adventure
Works]
102. NonEmptyCrossjoin (MDX)
返回包含一个或多个集的叉积的集，不包括空元组以及无相关事实数据表数据的元组。
语法
NonEmptyCrossjoin(Set_Expression1
[ ,Set_Expression2,...] [,Count ] )
参数
Set_Expression1
返回集的有效多维表达式 (MDX)。
Set_Expression2
返回集的有效多维表达式 (MDX)。
Count
指定返回集的数量的有效数值表达式。
注释
NonEmptyCrossjoin 函数以集的形式返回两个或多个集的叉积，不包括空元组或者无基础事实表提供的数据的元组。 鉴于 NonEmptyCrossjoin函数的工作方式，所有计算成员均被自动排除。
如果没有指定 Count，该函数将交叉联接所有指定的集并在结果集中排除空成员。 如果指定了集的数量，该函数将从第一个指定的集开始，交叉联接指定数量的集。 NonEmptyCrossjoin 函数使用在后续的指定集中指定但尚未交叉联接的剩余集来确定哪些成员在交叉联接后得到的集中被视为非空。 NonEmptyCrossjoin 函数不影响计算度量值的 NON_EMPTY_BEHAVIOR 设置。
|
重要提示 |
|
不推荐使用此函数并且不应使用它，保留此函数仅是为了维护向后兼容性。 应改用带有度量值组名称参数的 Exists |
103. OpeningPeriod (MDX)
返回指定级别（也可以是指定成员）的后代中的第一个同级。
语法
OpeningPeriod( [
Level_Expression [ , Member_Expression ] ] )
参数
Level_Expression
返回级别的有效多维表达式 (MDX)。
Member_Expression
返回成员的有效多维表达式 (MDX)。
注释
该函数主要用于时间维度，但是也可以用于任何维度。
如果指定了级别表达式，则 OpeningPeriod 函数使用包含指定级别的层次结构，返回指定级别上的默认成员的后代中的第一个同级。
如果指定了级别表达式和成员表达式，则 OpeningPeriod 函数返回包含指定级别的层次结构中位于指定级别上指定成员后代中的第一个同级。
如果既不指定级别表达式也不指定成员表达式，则 OpeningPeriod 函数使用默认级别和时间类型维度的成员。
|
注意 |
|
ClosingPeriod 函数与 OpeningPeriod 函数相似，只不过 ClosingPeriod 函数返回的是最后一个同级而不是第一个同级。 |
示例
下面的示例将返回 Date 维度（Time 类型）FY2002 成员的默认度量值。 返回该成员是因为
Fiscal Year 级别是 [All] 级别的第一个后代，Fiscal 层次结构为默认层次结构是由于 Fiscal 层次结构是层次结构集合中第一个用户定义的层次结构，而且 FY2002 成员是该层次结构中该级别上的第一个同级。
SELECT
OpeningPeriod() ON 0
FROM [Adventure
Works]
下例将返回 Date.Date 属性层次结构
Date.Date.Date 级别上“July 1, 2001”成员的默认度量值。 该成员是 Date.Date 属性层次结构中 [All] 级别后代的第一个同级成员。
SELECT
OpeningPeriod([Date].[Date].[Date]) ON 0
FROM [Adventure
Works]
下面的示例将返回“January,
2003”成员的默认度量值，该成员是 Calendar 用户定义层次结构中年度级别上 2003 成员后代的第一个同级成员。
SELECT
OpeningPeriod([Date].[Calendar].[Month],[Date].[Calendar].[Calendar
Year].&[2003]) ON 0
FROM [Adventure
Works]
下面的示例将返回“July, 2002”成员的默认度量值，该成员是 Fiscal 用户定义层次结构中年度级别上 2003 成员后代的第一个同级成员。
SELECT
OpeningPeriod([Date].[Fiscal].[Month],[Date].[Fiscal].[Fiscal
Year].&[2003]) ON 0
FROM [Adventure
Works]
104. Order (MDX)
排列指定集的成员，可以选择保留或打乱原有的层次结构。
语法
Numeric expression
syntax
Order(Set_Expression,
Numeric_Expression
[ , { ASC | DESC |
BASC | BDESC } ] )
String expression
syntax
Order(Set_Expression,
String_Expression
[ , { ASC | DESC |
BASC | BDESC } ] )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Numeric_Expression
有效数值表达式，通常为返回数值的单元坐标的多维表达式 (MDX)。
String_Expression
通常是单元坐标（返回以字符串表示的数字）的有效多维表达式 (MDX) 的有效字符串表达式。
注释
Order 函数既可以考虑层次结构（通过使用 ASC 或 DESC 标志来指定），也可以不考虑层次结构（通过使用 BASC 或 BDESC 标志来指定，其中B 表示“打乱层次结构”）。 如果指定了 ASC 或 DESC，则 Order 函数先根据成员在层次结构中的位置进行排列，然后对每一级别进行排序。 如果指定了 BASC 或 BDESC，则 Order 函数排列集中的所有成员时不考虑层次结构。 如果未指定任何标志，则默认为 ASC。
如果 Order 函数用于其两个或多个层次结构执行叉积的集合，并且使用 DESC 标志，则只对该集合中最后一个层次结构的成员进行排序。 这与 Analysis Services 2000 不同，后者对集合中的所有层次结构进行排序。
示例
下面的示例从 Adventure
Works 多维数据集返回 Date 维度上 Calendar 层次结构中所有日历季度的分销商订单的数目。Order 函数重新为 ROWS 轴的集合进行排序。 Order 函数根据 [Calendar] 层次结构确定的层次结构顺序以降序按照 [Reseller Order Count] 对该集合进行排序。
SELECT
Measures.[Reseller
Order Count] ON COLUMNS,
Order(
[Date].[Calendar].[Calendar
Quarter].MEMBERS
,Measures.[Reseller
Order Count]
,DESC
) ON ROWS
FROM [Adventure
Works]
请注意在 DESC 标志更改为 BDESC 时，此示例中的层次结构是如何断开的，以及如何返回日历季度的列表（与层次结构无关）。
SELECT
Measures.[Reseller
Order Count] ON COLUMNS,
Order(
[Date].[Calendar].[Calendar
Quarter].MEMBERS
,Measures.[Reseller
Order Count]
,BDESC
) ON ROWS
FROM [Adventure
Works]
以下示例根据 Reseller Gross
Profit（分销商毛利润），返回前五个销售产品子类别的分销商销售额度量值，而不管层次结构如何。 Subset 函数用于在使用 Order 函数对结果进行排序之后，仅返回集中的前五个元组。
SELECT Subset
(Order
([Product].[Product
Categories].[SubCategory].members
,[Measures].[Reseller
Gross Profit]
,BDESC
)
,0
,5
) ON 0
FROM [Adventure
Works]
下面的示例使用 Rank 函数根据 Reseller
Sales Amount 度量值对 City 层次结构的成员进行排名，然后以排名顺序显示它们。 通过使用 Order 函数先对 City 层次结构的成员集进行排序，仅执行一次排序，然后在以排序顺序显示之前执行线性扫描。
WITH
SET OrderedCities
AS Order
([Geography].[City].[City].members
, [Measures].[Reseller Sales Amount], BDESC
)
MEMBER
[Measures].[City Rank] AS Rank
([Geography].[City].CurrentMember,
OrderedCities)
SELECT
{[Measures].[City Rank],[Measures].[Reseller Sales Amount]} ON 0
,Order
([Geography].[City].[City].MEMBERS
,[City Rank], ASC)
ON 1
FROM [Adventure
Works]
下面的示例返回集中唯一的产品的数目，同时在使用 Filter 函数之前使用 Order 函数对非空元组进行排序。 CurrentOrdinal 函数用于比较和消除等同值。
WITH MEMBER
[Measures].[PrdTies] AS Count
(Filter
(Order
(NonEmpty
([Product].[Product].[Product].Members
, {[Measures].[Reseller Order
Quantity]}
)
, [Measures].[Reseller Order Quantity]
, BDESC
) AS OrdPrds
, (OrdPrds.CurrentOrdinal <
OrdPrds.Count
AND [Measures].[Reseller Order Quantity]
=
( [Measures].[Reseller Order
Quantity]
, OrdPrds.Item
(OrdPrds.CurrentOrdinal
)
)
)
OR (OrdPrds.CurrentOrdinal > 1
AND [Measures].[Reseller Order
Quantity] =
([Measures].[Reseller Order
Quantity]
, OrdPrds.Item
(OrdPrds.CurrentOrdinal-2)
)
)
)
)
SELECT
{[Measures].[PrdTies]} ON 0
FROM [Adventure
Works]
为了理解 DESC 标志是如何使用元组集的，请首先考虑以下查询的结果：
SELECT
{[Measures].[Tax
Amount]} ON 0,
ORDER(
[Sales Territory].[Sales
Territory].[Group].MEMBERS
,[Measures].[Tax
Amount], DESC)
ON 1
FROM [Adventure
Works]
在行轴上，您可以看到 Sales
Territory Groups 已按 Tax Amount 的降序排序，如下所示：North America、Europe、Pacific、NA。 现在，看一下如果将 Sales Territory Groups 集合与 Product
Subcategories 集合执行叉积并且以相同方式应用 Order 函数后会发生什么情况，如下所示：
SELECT
{[Measures].[Tax
Amount]} ON 0,
ORDER(
[Sales
Territory].[Sales Territory].[Group].MEMBERS
*
{[Product].[Product
Categories].[subCategory].Members}
,[Measures].[Tax
Amount], DESC)
ON 1
FROM [Adventure
Works]
尽管 Product
Subcategories 的集合已按层次结构顺序的降序进行排序，但 Sales Territory Groups 现在未排序并且以它们在层次结构上出现的顺序出现：Europe、NA、North America 和 Pacific。 其原因在于，仅对元组集合中最后一个层次结构 Product Subcategories 进行了排序。 若要重现 Analysis
Services 2000 的行为，请使用一系列嵌套的 Generate 函数来在执行叉积前对每个集合进行排序，例如：
SELECT
{[Measures].[Tax
Amount]} ON 0,
GENERATE(
ORDER(
[Sales
Territory].[Sales Territory].[Group].MEMBERS
,[Measures].[Tax
Amount], DESC)
,
ORDER(
[Sales
Territory].[Sales Territory].CURRENTMEMBER
*
{[Product].[Product
Categories].[subCategory].Members}
,[Measures].[Tax
Amount], DESC))
ON 1
FROM [Adventure
Works]
105. Ordinal (MDX)
返回与某一级别关联的序数值，从零开始计算。
语法
Level_Expression.Ordinal
参数
Level_Expression
返回级别的有效多维表达式 (MDX)。
注释
Ordinal 函数经常与 IIF 和 CurrentMember 函数一起使用，以根据查询结果中每个特定单元格的序号位置，有条件地在不同的层次结构级别上显示不同的值。 例如，可以使用 Ordinal 函数在某些级别上执行计算，并在其他级别上显示默认值“N/A”。
示例
下面的示例返回 Calendar 层次结构中的
Calendar Quarter 级别的序号。
WITH MEMBER
Measures.x AS [Date].[Calendar].[Calendar Quarter].Ordinal
SELECT Measures.x
on 0
FROM [Adventure
Works]
106. ParallelPeriod (MDX)
返回上一期间具有与指定成员相同的相对位置的成员。
语法
ParallelPeriod( [
Level_Expression [ ,Index [ , Member_Expression ] ] ] )
参数
Level_Expression
返回级别的有效多维表达式 (MDX)。
Index
指定要滞后的并行期间数的有效数值表达式。
Member_Expression
返回成员的有效多维表达式 (MDX)。
注释
ParallelPeriod 函数类似于 Cousin 函数，但与时序的关系更密切。 ParallelPeriod 函数在指定级别处获取指定成员的祖先，然后查找具有指定滞后的该祖先的同级，最后返回该同级后代中指定成员的并行期间。
ParallelPeriod 函数具有下列默认值：
如果既没有指定级别表达式，也没有指定成员表达式，则默认成员值为度量值组中类型为 Time 的第一个维度上第一个层次结构的当前成员。
如果指定了级别表达式，但未指定成员表达式，则默认成员值为 Level_Expression.Hierarchy.CurrentMember。
默认索引值为 1。
默认级别为指定成员的父级别。
ParallelPeriod 函数等效于下面的 MDX 语句：
Cousin(Member_Expression,
Ancestor(Member_Expression, Level_Expression) .Lag(Numeric_Expression))
示例
下面的示例以季度级别为基准并以三个期间为间隔，返回了 October 2003（2003 年 10 月）的并行期间，即 2003 年 1 月。
SELECT
ParallelPeriod ([Date].[Calendar].[Calendar Quarter]
, 3
, [Date].[Calendar].[Month].[October 2003])
ON 0
FROM [Adventure Works]
下面的示例以半期级别为基准并以三个期间为间隔，返回了 October 2003（2002 年 10 月）的并行期间，即 2002 年 4 月。
SELECT ParallelPeriod
([Date].[Calendar].[Calendar Semester]
, 3
, [Date].[Calendar].[Month].[October 2003])
ON 0
FROM [Adventure Works]
107. Parent (MDX)
返回成员的父成员。
语法
Member_Expression.Parent
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
注释
Parent 函数返回指定成员的父成员。
示例
以下例返回“July 1, 2001”成员的父成员。 第一个示例在日期属性层次结构的上下文中指定了该成员并返回“所有时期”成员。
SELECT
[Date].[Date].[July 1, 2001].Parent ON 0
FROM [Adventure
Works]
下例在日历层次结构的上下文中指定了“July
1, 2001”成员。
SELECT
[Date].[Calendar].[July 1, 2001].Parent ON 0
FROM [Adventure
Works]
108. PeriodsToDate (MDX)
按照时间维度中的指定级别的约束，从给定成员所在的级别返回一组同级成员，从第一个同级成员开始到给定成员为止。
语法
PeriodsToDate( [ Level_Expression
[ ,Member_Expression ] ] )
参数
Level_Expression
返回级别的有效多维表达式 (MDX)。
Member_Expression
返回成员的有效多维表达式 (MDX)。
注释
在指定级别的范围内，PeriodsToDate 函数将返回与指定成员处于同一级别、从第一个期间开始到指定成员结束的期间集。
如果指定了级别，则层次结构的当前成员是指 hierarchy。CurrentMember，其中 hierarchy 是指定级别的层次结构。
如果既未指定级别，也未指定成员，则该级别是度量值组中 Time 类型的第一个维度上第一个层次结构的当前成员的父级。
PeriodsToDate(
Level_Expression, Member_Expression ) 的功能与以下 MDX 表达式相同：
TopCount(Descendants(Ancestor(Member_Expression, Level_Expression),
Member_Expression.Level), 1):Member_Expression
示例
下面的示例从 Adventure
Works 多维数据集中返回 Measures.[Order Quantity] 成员在 2003 日历年前八个月（包含在 Date 维度中）内的聚合值。
WITH MEMBER
[Date].[Calendar].[First8Months2003] AS
Aggregate(
PeriodsToDate(
[Date].[Calendar].[Calendar Year],
[Date].[Calendar].[Month].[August
2003]
)
)
SELECT
[Date].[Calendar].[First8Months2003] ON
COLUMNS,
[Product].[Category].Children ON ROWS
FROM
[Adventure Works]
WHERE
[Measures].[Order Quantity]
下面的示例聚合了 2003 日历年第二半期的前两个月。
WITH MEMBER
[Date].[Calendar].[First2MonthsSecondSemester2003] AS
Aggregate(
PeriodsToDate(
[Date].[Calendar].[Calendar
Semester],
[Date].[Calendar].[Month].[August
2003]
)
)
SELECT
[Date].[Calendar].[First2MonthsSecondSemester2003] ON COLUMNS,
[Product].[Category].Children ON ROWS
FROM
[Adventure Works]
WHERE
[Measures].[Order Quantity]
109. Predict (MDX)
|
注意 |
|
此函数由于内部不一致而正被删除。 有关使用 DMX 表达式的解决方法，请查看示例部分。 |
返回用数值表达式对数据挖掘模型求得的值。
语法
Predict(Mining_Model_Name,String_Expression)
参数
Mining_Model_Name
表示挖掘模型名称的有效字符串表达式。
String_Expression
计算结果为指定挖掘模型的有效 DMX 表达式的有效字符串表达式。
注释
Predict 函数计算指定挖掘模型上下文中指定字符串表达式的值。
在数据挖掘表达式 (DMX) 参考中提供了数据挖掘语法和函数。
示例
下面的示例使用 Customer
Clusters 挖掘模型预测群集的名称以及与特定客户的距离：
WITH MEMBER
MEASURES.CLNAME AS
PREDICT("Customer
Clusters", "Cluster()")
MEMBER
MEASURES.CLDISTANCE AS
PREDICT("Customer
Clusters", "ClusterDistance(Cluster())")
SELECT
{MEASURES.CLNAME, MEASURES.CLDISTANCE} ON 0
FROM [Adventure
Works]
WHERE([Customer].[Customer
Geography].[Customer].&[12012])
110. PrevMember (MDX)
返回指定成员所在级别的上一个成员。
语法
Member_Expression.PrevMember
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
注释
PrevMember 函数返回与指定成员位于同一级别的上一个成员。
示例
下面的示例显示一个简单查询，它使用 PrevMember 函数紧靠行轴上当前成员之前显示该成员的名称：
WITH MEMBER
MEASURES.PREVMEMBERDEMO AS
[Date].[Calendar].CURRENTMEMBER.PREVMEMBER.NAME
SELECT
MEASURES.PREVMEMBERDEMO ON 0,
[Date].[Calendar].MEMBERS
ON 1
FROM [Adventure
Works]
下面的示例根据用 Aggregate 函数计算的用户选择的
State-Province 成员值，返回上一个时期销售额下滑的分销商的计数。 Hierarchize 和DrillDownLevel 函数用于为 Product
维度中的产品类别返回呈下降趋势的销售额值。 PrevMember 函数用于将当前时间段与上一时间段进行比较。
WITH MEMBER
Measures.[Declining Reseller Sales] AS
Count(
Filter(
Existing(Reseller.Reseller.Reseller),
[Measures].[Reseller Sales Amount]
< ([Measures].[Reseller Sales Amount],
[Date].Calendar.PrevMember)
)
)
MEMBER
[Geography].[State-Province].x AS
Aggregate (
{[Geography].[State-Province].&[WA]&[US],
[Geography].[State-Province].&[OR]&[US] }
)
SELECT NON EMPTY
Hierarchize (
AddCalculatedMembers (
{DrillDownLevel({[Product].[All
Products]})}
)
)
DIMENSION PROPERTIES PARENT_UNIQUE_NAME
ON COLUMNS
FROM [Adventure
Works]
WHERE
([Geography].[State-Province].x,
[Date].[Calendar].[Calendar
Quarter].&[2003]&[4],
[Measures].[Declining Reseller Sales])
111. Properties (MDX)
返回一个包含成员属性值的字符串（或强类型值）。
语法
Member_Expression.Properties(Property_Name
[, TYPED])
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
Property_Name
成员属性名称的有效字符串表达式。
注释
Properties 函数返回指定成员属性的指定成员值。 成员属性可以是任何内部成员属性（如 NAME、ID、KEY、或 CAPTION），也可以是用户定义的成员属性。 有关详细信息，请参阅内部成员属性 (MDX)和用户定义的成员属性 (MDX)。
默认情况下，将该值强迫为一个字符串。 如果指定了 TYPED，则返回值为强类型。
如果属性是内部的，则函数返回成员的原始类型。
如果属性是用户定义的，则返回值的类型与 MemberValue 函数的返回值类型相同。
|
注意 |
|
Properties |
示例
下例既返回内部属性也返回用户定义成员属性，并且利用 TYPED 参数返回“星期几”成员属性的强类型值。
WITH MEMBER
Measures.MemberName AS
[Date].[Calendar].[July 1,
2003].Properties('Name')
MEMBER
Measures.MemberVal AS
[Date].[Calendar].[July 1,
2003].Properties('Member_Value')
MEMBER
Measures.MemberKey AS
[Date].[Calendar].[July 1,
2003].Properties('Key')
MEMBER
Measures.MemberID AS
[Date].[Calendar].[July 1,
2003].Properties('ID')
MEMBER
Measures.MemberCaption AS
[Date].[Calendar].[July 1,
2003].Properties('Caption')
MEMBER Measures.DayName
AS
[Date].[Calendar].[July 1,
2003].Properties('Day Name', TYPED)
MEMBER
Measures.DayNameTyped AS
[Date].[Calendar].[July 1,
2003].Properties('Day Name')
MEMBER
Measures.DayofWeek AS
[Date].[Calendar].[July 1,
2003].Properties('Day of Week')
MEMBER
Measures.DayofMonth AS
[Date].[Calendar].[July 1,
2003].Properties('Day of Month')
MEMBER
Measures.DayofYear AS
[Date].[Calendar].[July 1,
2003].Properties('Day of Year')
SELECT {Measures.MemberName
, Measures.MemberVal
, Measures.MemberKey
, Measures.MemberID
, Measures.MemberCaption
, Measures.DayName
, Measures.DayNameTyped
, Measures.DayofWeek
, Measures.DayofMonth
, Measures.DayofYear
} ON
0
FROM [Adventure
Works]
以下示例演示了 KEYx 属性的用法。
WITH
MEMBER
Measures.MemberKey AS
[Customer].[Customer
Geography].[State-Province].&[QLD]&[AU].Properties('Key')
MEMBER
Measures.MemberKey0 AS
[Customer].[Customer
Geography].[State-Province].&[QLD]&[AU].Properties('Key0')
MEMBER
Measures.MemberKey1 AS
[Customer].[Customer
Geography].[State-Province].&[QLD]&[AU].Properties('Key1')
SELECT
{Measures.MemberKey
, Measures.MemberKey0
, Measures.MemberKey1
} ON
0
FROM [Adventure
Works]
112. Qtd (MDX)
按照 Time 维度中的 Quarter 级别的约束，从与给定成员相同的级别中返回同级成员的集，从第一个同级成员开始到给定成员为止。
语法
Qtd( [
Member_Expression ] )
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
注释
如果未指定成员表达式，则默认值为第一个层次结构的当前成员并且具有度量值组中Time 类型的第一个维度中的 Quarters 类型的级别。
Qtd 函数是 PeriodsToDate
(MDX) 函数的快捷函数，它将后者的级别表达式参数设置为 Quarter。 也就是说，Qtd(Member_Expression) 的功能与 PeriodsToDate(Quarter_Level_Expression,
Member_Expression) 相同。
示例
下例将从 Adventure
Works 多维数据集中返回在 2003 日历年度第三季度前两个月（包含在 Date 维度中）聚合的 Measures.[Order Quantity]成员之和。
WITH MEMBER
[Date].[Calendar].[First2MonthsSecondSemester2003] AS
Aggregate(
QTD([Date].[Calendar].[Month].[August
2003])
)
SELECT
[Date].[Calendar].[First2MonthsSecondSemester2003] ON COLUMNS,
[Product].[Category].Children ON ROWS
FROM
[Adventure Works]
WHERE
[Measures].[Order Quantity]
113. Rank (MDX)
返回指定元组在指定集中的排名（从 1 开始）。
语法
Rank(Tuple_Expression,
Set_Expression [ ,Numeric Expression ] )
参数
Tuple_Expression
返回元组的有效多维表达式 (MDX)。
Set_Expression
返回集的有效多维表达式 (MDX)。
Numeric_Expression
有效的数值表达式，通常为返回数值的单元坐标的多维表达式 (MDX)。
注释
如果指定了数值表达式，则 Rank 函数通过对指定的元组计算指定的数值表达式的值，来确定该元组的排名（排名从 1 开始）。 如果指定了数值表达式，则 Rank 函数会为集中具有相同值的元组分配相同的排名。 为值相同的元组分配相同的排名，会影响该集中后续元组的排名。 例如，由以下元组组成的集：{(a,b), (e,f), (c,d)}。 元组 (a,b) 与元组 (c,d) 具有相同的值。 如果元组 (a,b) 的排名为 1，则 (a,b) 和 (c,d) 的排名都为 1。 但元组(e,f) 的排名为 3。 此集中可能没有排名为 2 的元组。
如果未指定数值表达式，则 Rank 函数返回指定元组的序号位置（序号从 1 开始）。
Rank 函数不会对集进行排序。
示例
下面的示例将返回包含客户和采购日期的元组集，并且使用 Filter、NonEmpty、Item 和 Rank 函数来查找每个客户的最后一次采购日期。
WITH SET MYROWS AS
FILTER
(NONEMPTY
([Customer].[Customer Geography].MEMBERS
* [Date].[Date].[Date].MEMBERS
, [Measures].[Internet Sales Amount]
) AS MYSET
, NOT(MYSET.CURRENT.ITEM(0)
IS MYSET.ITEM(RANK(MYSET.CURRENT,
MYSET)).ITEM(0))
)
SELECT
[Measures].[Internet Sales Amount] ON 0,
MYROWS ON 1
FROM [Adventure
Works]
下面的示例使用 Order 函数而不是 Rank 函数，根据
Reseller Sales Amount 度量值为 City 层次结构的成员排名，然后按照排名高低显示它们。通过使用 Order 函数先对 City 层次结构的成员集进行排序，仅执行一次排序，然后在以排序顺序显示之前执行线性扫描。
WITH
SET OrderedCities AS
Order
([Geography].[City].[City].members
, [Measures].[Reseller Sales Amount], BDESC
)
MEMBER
[Measures].[City Rank] AS Rank
([Geography].[City].CurrentMember,
OrderedCities)
SELECT
{[Measures].[City Rank],[Measures].[Reseller Sales Amount]} ON 0
,Order
([Geography].[City].[City].MEMBERS
,[City Rank], ASC)
ON 1
FROM [Adventure
Works]
114. RollupChildren (MDX)
使用指定的一元运算符，通过汇总指定成员的子成员的值来返回生成的值。
语法
RollupChildren(Member_Expression,
Unary_Operator)
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
Unary_Operator
指定一元运算符的有效字符串表达式。
注释
RollupChildren 函数使用指定的一元运算符，对所指定成员的子成员的值进行汇总。
下表说明了可用于此函数的有效一元运算符。
|
运算符 |
结果 |
|
+ |
total = total + |
|
- |
总额 = 总额 - 当前子级 |
|
* |
total = total * |
|
/ |
total = total / |
|
% |
total = (total / |
|
~ |
不在汇总结果中使用子成员。 子成员的值将被忽略。 |
如果成员属性中的运算符未显示在列表中，则会发生错误。 求值顺序取决于同级的顺序，而不是运算符的优先顺序。
示例
下例使用名为“Alternate
Rollup Operator”的成员属性（包含一元运算符的备用值）以备用方式汇总 Account（帐户）维度中 Net Profit（净利润）层次结构的子成员。 该成员属性不在 Adventure Works 多维数据集中，但是可以创建。 可以在假设分析的预算应用中使用 RollupChildren函数。
RollupChildren
( [Account].[Net Profit]
, [Account].CurrentMember.Properties
('Alternate Rollup Operator') )
115. Root (MDX)
返回一个元组，该元组包含来自多维数据集、维度或元组的当前作用域中的各个属性层次结构的 All 成员。 有关作用域的详细信息，请参阅 SCOPE 语句 (MDX)。
|
注意 |
|
如果属性层次结构中没有 All 成员，则元组包含该层次结构的默认成员。 |
语法
Cube syntax
Root ()
Dimension syntax
Root(
Dimension_Name )
Tuple syntax
Root(
Tuple_Expression )
参数
Dimension_Name
指定维度名称的有效字符串表达式。
Tuple_Expression
返回元组的有效多维表达式 (MDX)。
注释
如果未指定维度名称和元组表达式，则 Root 函数从多维数据集的每个属性层次结构中返回包含 All 成员（如果 All 成员不存在，则为默认成员）的元组。 成员在元组中的顺序基于多维数据集中定义属性层次结构的顺序。
如果指定了维度名称，则 Root 函数根据当前成员的上下文，从该维度中的每个属性层次结构中返回包含 All 成员（如果 All 成员不存在，则为默认成员）的元组。 成员在元组中的顺序基于维度中定义属性层次结构的顺序。
|
注意 |
|
如果指定了层次结构名称，Tuple 函数将从该层次结构名称中选取维度名称。 |
如果指定了元组表达式，则 Root 函数返回的元组包含指定元组与未显式包括在指定元组中的所有其他维度属性的 All 成员的交集。
示例
下例将从 Adventure Works 多维数据集的每个层次结构中返回包含 All 成员（如果 All 成员不存在，则为默认成员）的元组。
SELECT Root()ON 0
FROM [Adventure
Works]
下例将从 Adventure Works 多维数据集的 Date 维度的每个层次结构中返回包含 All 成员（如果 All 成员不存在，则为默认成员）的元组，并且还将返回这些默认成员与 Measures 维度中指定成员的交集的值。
SELECT
Root([Date]) ON 0
FROM [Adventure
Works]
WHERE
[Measures].[Order Count]
下例将从 Adventure Works 多维数据集的 Date 维度的每个非指定层次结构中返回包含指定的元组成员 (July 1, 2001) 和 All 成员（如果 All 成员不存在，则为默认成员）的元组，并且还将返回这些成员与 Measures 维度中指定成员的交集的值。
SELECT
Root([Date].[July 1, 2001]) ON 0
FROM [Adventure
Works]
WHERE
[Measures].[Order Count]
116. SetToArray (MDX)
将一个或多个集转换为数组，以便在用户定义的函数中使用。
语法
SetToArray(Set_Expression1
[ ,Set_Expression2,...n ][ ,Numeric_Expression ] )
参数
Set_Expression1
返回集的有效多维表达式 (MDX)。
Set_Expression2
返回集的有效多维表达式 (MDX)。
Numeric_Expression
返回数字的有效数值表达式，通常为单元坐标的多维表达式 (MDX)。
注释
SetToArray 函数将一个或多个集转换为数组，以便在用户定义的函数中使用。 所得到的数组中的维度数与指定的集数相同。
可选的数值表达式可以为数组单元提供值。 如果未指定数值表达式，则在当前上下文中对集的交叉联接求值。
所得到的数组中的单元坐标与各个集在列表中的位置相对应。 例如，有三个集，SA、SB 和 SC。 其中每个集都有两个元素。 则 MDX 语句SetToArray(SA, SB, SC) 创建以下三维数组：
(SA1, SB1, SC1)
(SA2, SB1, SC1) (SA1, SB2, SC1) (SA2, SB2, SC1)
(SA1, SB1, SC2)
(SA2, SB1, SC2) (SA1, SB2, SC2) (SA2, SB2, SC2)
|
注意 |
|
SetToArray 函数的返回类型为 VARIANT 类型 VT_ARRAY。 因此，SetToArray 函数的输出只能用作用户定义函数的输入。 |
示例
下例将返回一个数组。
SetToArray([Geography].[Geography].Members,
[Measures].[Internet Sales Amount])
117.SetToStr (MDX)
返回多维表达式 (MDX) 格式的字符串，它对应于指定的集合。
语法
SetToStr(Set_Expression)
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
注释
该函数用于将某集的字符串表示形式传输到外部函数，以进行分析。 返回的字符串以括号 {} 括起，并用逗号分隔集中的每一项。
示例
下面的示例将返回包含
Geography.Country 属性层次结构的所有成员的字符串。
WITH MEMBER
Measures.x AS SetToStr (Geography.Geography.Children)
SELECT Measures.x
ON 0
FROM [Adventure
Works]
118. Siblings (MDX)
返回指定成员的同级，包括该成员本身。
语法
Member_Expression.Siblings
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
示例
下面的示例返回 March 2003 的同级（即 January
2003 和 February 2003，也包括 March 2003）的默认度量值。
SELECT
[Date].[Calendar].[Month].[March 2003].Siblings ON 0
FROM [Adventure
Works]
119. Stddev (MDX)
Stdev函数的别名。
120. StddevP (MDX)
StdevP 函数的别名。
121. Stdev (MDX)
返回数值表达式用无偏差总体公式（除以
n-1）对集求得的样本标准偏差。
语法
Stdev(Set_Expression
[ ,Numeric_Expression ] )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Numeric_Expression
有效数值表达式，通常为返回数值的单元坐标的多维表达式 (MDX)。
注释
Stdev 函数使用无偏差总体公式，而 StdevP 函数使用有偏差总体公式。
示例
下例将使用无偏差总体公式返回对日历年
2003 的前三个月求得的 Internet Order Quantity 的标准偏差。
WITH MEMBER
Measures.x AS
Stdev
( { [Date].[Calendar].[Month].[January
2003],
[Date].[Calendar].[Month].[February
2003],
[Date].[Calendar].[Month].[March 2003]},
[Measures].[Internet Order Quantity])
SELECT Measures.x
ON 0
FROM [Adventure
Works]
122. StdevP (MDX)
返回数值表达式用有偏差总体公式（除以 n）对集求得的总体标准偏差。
语法
StdevP(Set_Expression
[ ,Numeric_Expression ] )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Numeric_Expression
有效数值表达式，通常为返回数值的单元坐标的多维表达式 (MDX)。
注释
StdevP 函数使用有偏差总体公式，而 Stdev 函数使用无偏差总体公式。
示例
下面的示例将使用有偏差总体公式返回对
2003 日历年度中前三个月求得的 Internet Order Quantity 的标准偏差。
WITH MEMBER
Measures.x AS
StdevP
( { [Date].[Calendar].[Month].[January
2003],
[Date].[Calendar].[Month].[February 2003],
[Date].[Calendar].[Month].[March 2003]},
[Measures].[Internet Order Quantity])
SELECT Measures.x
ON 0
FROM [Adventure
Works]
123. StripCalculatedMembers (MDX)
返回通过从指定集中删除计算成员而生成的集。
语法
StripCalculatedMembers(Set_Expression)
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
注释
StripCalculatedMembers 函数从集中删除计算成员。 可以使用 AddCalculatedMembers 函数将计算成员添加到某个集中，该函数将返回服务器上定义的计算成员或者使用 WITH MEMBER 语法在查询本身中添加的计算成员。
示例
以下示例从查询中删除所有计算成员。
WITH MEMBER
Measures.MemberName AS
[Date].[Calendar].[July 1,
2003].Properties('Name')
MEMBER
Measures.MemberVal AS
[Date].[Calendar].[July 1,
2003].Properties('Member_Value')
MEMBER
Measures.MemberKey AS
[Date].[Calendar].[July 1,
2003].Properties('Key')
MEMBER
Measures.MemberID AS
[Date].[Calendar].[July 1,
2003].Properties('ID')
MEMBER
Measures.MemberCaption AS
[Date].[Calendar].[July 1,
2003].Properties('Caption')
MEMBER
Measures.DayName AS
[Date].[Calendar].[July 1,
2003].Properties('Day Name', TYPED)
MEMBER
Measures.DayNameTyped AS
[Date].[Calendar].[July 1,
2003].Properties('Day Name')
MEMBER
Measures.DayofWeek AS
[Date].[Calendar].[July 1,
2003].Properties('Day of Week')
MEMBER
Measures.DayofMonth AS
[Date].[Calendar].[July 1,
2003].Properties('Day of Month')
MEMBER
Measures.DayofYear AS
[Date].[Calendar].[July 1,
2003].Properties('Day of Year')
SELECT StripCalculatedMembers(
{ Measures.DefaultMember
, Measures.MemberName
, Measures.MemberVal
, Measures.MemberKey
, Measures.MemberID
, Measures.MemberCaption
, Measures.DayName
, Measures.DayNameTyped
, Measures.DayofWeek
, Measures.DayofMonth
, Measures.DayofYear
}
) ON
0
FROM [Adventure
Works]
124. StrToMember (MDX)
返回多维表达式 (MDX) 格式的字符串指定的成员。
语法
StrToMember(Member_Name
[,CONSTRAINED] )
参数
Member_Name
直接或间接指定成员的有效字符串表达式。
注释
StrToMember 函数返回字符串表达式中指定的成员。 StrToMember 函数通常与用户定义函数一起使用，以从外部函数或在参数化 MDX 查询时向 MDX 语句返回成员规范。
如果使用 CONSTRAINED 标志，则成员名称必须可直接解析为限定或未限定的成员名称。 此标志通过指定字符串可降低注入攻击的风险。如果所提供的字符串无法直接解析为限定或未限定的成员名称，将出现以下错误：“违反了 STRTOMEMBER 函数中 CONSTRAINED 标志所规定的限制。”
如果未使用 CONSTRAINED 标志，指定的成员将能直接解析为成员名称，或解析为 MDX 表达式以解析为名称。
为了更好地理解集和成员之间的差异，请参阅“使用集表达式”和“使用成员表达式”。
示例
下面的示例使用 StrToMember 函数返回
State-Province 属性层次结构中 Bayern 成员的 Reseller Sales Amount 度量值。 指定字符串提供了限定的成员名称。
SELECT
{StrToMember ('[Geography].[State-Province].[Bayern]')}
ON 0,
{[Measures].[Reseller
Sales Amount]} ON 1
FROM [Adventure
Works]
下面的示例使用 StrToMember 函数返回 Bayern 成员的 Reseller
Sales Amount 度量值。 由于成员名称字符串仅提供了一个未限定的成员名称，因此该查询返回指定成员的第一个实例，而指定成员恰好在 Customer 维度（不与 Reseller Sales 相交）的 Customer Geography 层次结构中。 最佳做法要求指定限定名称以确保获得预期的结果。
SELECT
{StrToMember ('[Bayern]').Parent}
ON 0,
{[Measures].[Reseller
Sales Amount]} ON 1
FROM [Adventure
Works]
下面的示例使用 StrToMember 函数返回
State-Province 属性层次结构中 Bayern 成员的 Reseller Sales Amount 度量值。 所提供的成员名称字符串解析为限定的成员名称。
SELECT
{StrToMember('[Geography].[Geography].[Country].[Germany].FirstChild',
CONSTRAINED)}
ON 0,
{[Measures].[Reseller
Sales Amount]} ON 1
FROM [Adventure
Works]
下面的示例返回因 CONSTRAINED 标志而引起的错误。 虽然所提供的成员名称字符串包含一个可解析为限定的成员名称的有效 MDX 成员表达式，但是 CONSTRAINED 标志要求成员名称字符串包含限定或未限定的成员名称。
SELECT StrToMember
('[Geography].[Geography].[Country].[Germany].FirstChild', CONSTRAINED)
ON 0
FROM [Adventure
Works]
125.StrToSet (MDX)
返回多维表达式 (MDX) 格式的字符串指定的集。
语法
StrToSet(Set_Specification
[,CONSTRAINED] )
参数
Set_Specification
直接或间接指定某个集的有效字符串表达式。
注释
StrToSet 函数返回字符串表达式中指定的集。 StrToSet 函数通常与用户定义函数一起使用，以从外部函数或在参数化 MDX 查询时向 MDX 语句返回集规范。
如果使用了 CONSTRAINED 标志，则该集规范必须包含限定或非限定成员名称，或包含以括号 {} 括起来的限定或非限定成员名称的一组元组。 此标志通过指定字符串可降低注入攻击的风险。 如果提供的字符串不能直接解析为限定或非限定的成员名称，则会出现下列出错信息：“违反了 STRTOSET 函数中 CONSTRAINED 标志所规定的限制。”
如果未使用 CONSTRAINED 标志，则指定的集规范可以解析为返回一个集的有效多维表达式 (MDX)。
为了更好地理解集和成员之间的差异，请参阅“使用集表达式”和“使用成员表达式”。
示例
下例使用 StrToSet 函数，返回
State-Province 属性层次结构的成员集。 该集规范提供一个有效的 MDX 集表达式。
SELECT StrToSet
('[Geography].[State-Province].Members')
ON 0
FROM [Adventure
Works]
下面的示例返回因 CONSTRAINED 标志而引起的错误。 如果集规范提供一个有效的
MDX 集表达式，则 CONSTRAINED 标志在集规范中需要限定或非限定的成员名称。
SELECT StrToSet
('[Geography].[State-Province].Members', CONSTRAINED)
ON 0
FROM [Adventure
Works]
下例返回德国和加拿大的“分销商销售额”度量值。 指定字符串中提供的集规范包含了 CONSTRAINED 标志所需的限定成员名称。
SELECT StrToSet
('{[Geography].[Geography].[Country].[Germany],[Geography].[Geography].[Country].[Canada]}',
CONSTRAINED)
ON 0
FROM [Adventure
Works]
126. StrToTuple (MDX)
返回多维表达式 (MDX) 格式的字符串指定的元组。
语法
StrToTuple(Tuple_Specification
[,CONSTRAINED] )
参数
Tuple_Specification
直接或间接指定元组的有效字符串表达式。
注释
StrToTuple 函数返回指定的集。 StrToTuple 函数通常与用户定义函数一起使用，以将外部函数中的元组规范返回到 MDX 语句。
如果使用 CONSTRAINED 标志，则元组规范必须包含限定或未限定的成员名称。 此标志通过指定字符串可降低注入攻击的风险。 如果所提供的字符串无法直接解析为限定或未限定的成员名称，将出现以下错误：“违反了 STRTOTUPLE 函数中 CONSTRAINED 标志所规定的限制。”
如果未使用 CONSTRAINED 标志，则指定的元组可以解析为有效的 MDX 表达式以返回元组。
示例
下面的示例返回 Bayern 成员在日历年度 2004 的 Reseller
Sales Amount 度量值。 提供的元组规范包含有效的 MDX 元组表达式。
SELECT StrToTuple
('([Geography].[State-Province].[Bayern],[Date].[Calendar Year].[CY 2004],
[Measures].[Reseller Sales Amount])')
ON 0
FROM [Adventure
Works]
下面的示例返回 Bayern 成员在日历年度 2004 的 Reseller
Sales Amount 度量值。 提供的元组规范包含了 CONSTRAINED 标志所需的限定成员名称。
SELECT StrToTuple
('([Geography].[State-Province].[Bayern],[Date].[Calendar Year].[CY 2004],
[Measures].[Reseller Sales Amount])', CONSTRAINED)
ON 0
FROM [Adventure
Works]
下面的示例返回 Bayern 成员在日历年度 2004 的 Reseller
Sales Amount 度量值。 提供的元组规范包含有效的 MDX 元组表达式。
SELECT StrToTuple
('([Geography].[State-Province].[Bayern],[Date].[Calendar
Year].&[2003].NEXTMEMBER, [Measures].[Reseller Sales Amount])')
ON 0
FROM [Adventure
Works]
下面的示例返回因 CONSTRAINED 标志而引起的错误。 虽然所提供的元组规范包含有效的 MDX 元组表达式，但是 CONSTRAINED 标志要求元组规范包含限定或未限定的成员名称。
SELECT StrToTuple
('([Geography].[State-Province].[Bayern],[Date].[Calendar Year].&[2003].NEXTMEMBER,
[Measures].[Reseller Sales Amount])', CONSTRAINED)
ON 0
FROM [Adventure
Works]
127. StrToValue (MDX)
返回多维表达式 (MDX) 格式的字符串指定的数值。
语法
StrToValue(MDX_Expression
[,CONSTRAINED] )
参数
MDX_Expression
直接或间接解析为单个单元的有效字符串表达式。
注释
StrToValue 函数返回 MDX 表达式指定的数值。 StrToValue 函数通常与用户定义函数一起使用，以从某个外部函数向可解析为单个单元的 MDX 语句返回一个 MDX 表达式。
如果使用 CONSTRAINED 标志，则 MDX 表达式只能包含一个标量值。 通过指定字符串，使用
CONSTRAINED 标志可降低发生注入攻击的风险。 如果提供的 MDX 表达式不能直接解析为标量值，则会出现下列出错信息：“违反了 STRTOVALUE 函数中 CONSTRAINED 标志所规定的限制。”
当未使用 CONSTRAINED 标志时，指定的 MDX 表达式的复杂程度不受限制，只要该表达式可解析为能够返回单个单元的有效多维表达式 (MDX) 即可。
|
注意 |
|
如果 MDX 表达式的结果以文本方式存储，并且您希望对返回值执行算术运算，那么将该结果作为数值返回将十分有用。 |
示例
下例使用 StrToValue 函数将每辆自行车的重量作为值返回。
WITH MEMBER
Measures.x AS
StrToValue
([Product].[Product].CurrentMember.Properties ('Weight')
,CONSTRAINED
)
SELECT Measures.x
ON 0
,[Product].[Product].[Product].Members
ON 1
FROM [Adventure
Works]
WHERE
[Product].[Product Categories].[Bikes]
128. Subset (MDX)
返回指定集中的元组的子集。
语法
Subset(Set_Expression,
Start [ ,Count ] )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Start
指定要返回第一个元组位置的有效数值表达式。
Count
指定要返回的元组数的有效数值表达式。
注释
Subset 函数从指定集的指定开始位置起返回包含指定元组数的子集。 开始位置基于以零为基的索引；即 0 对应于指定集中的第一个元组，1 对应于第二个元组，依此类推。
如果未指定 Count，则函数返回从 Start 到集末尾的所有元组。
示例
下例根据 Reseller Gross
Profit（分销商毛利润），返回前五个销售产品子类别的分销商销售额度量值，而不管层次结构如何。 Subset 函数用于在使用 Order 函数将结果排序后，仅返回结果中的前五个集。
SELECT Subset
(Order
([Product].[Product
Categories].[SubCategory].members
,[Measures].[Reseller Gross Profit]
,BDESC
)
,0
,5
) ON 0
FROM [Adventure
Works]
129. Sum (MDX)
返回对指定集计算数值表达式求得的和。
语法
Sum(
Set_Expression [ , Numeric_Expression ] )
参数
Set_Expression
有效的多维表达式 (MDX) 集表达式。
Numeric_Expression
有效数值表达式，通常为返回数值的单元坐标的多维表达式 (MDX)。
注释
如果指定了数值表达式，则对集计算指定数值表达式的值然后求和。 如果没有指定数值表达式，则在指定集成员的当前上下文中计算指定集然后求和。 如果将 SUM 函数应用于非数值表达式，则结果不确定。
|
注意 |
|
计算一组数值的总和时，Analysis |
示例
下例将返回 2001 和 2002 日历年
Product.Category 属性层次结构的所有成员的 Reseller Sales Amount 之和。
WITH MEMBER
Measures.x AS SUM
( { [Date].[Calendar Year].&[2001]
, [Date].[Calendar Year].&[2002] }
, [Measures].[Reseller Sales Amount]
)
SELECT Measures.x
ON 0
,[Product].[Category].Members
ON 1
FROM [Adventure
Works]
下例将返回截至 2002 年 7 月 20 日 7 月份的 Internet 销售运费之和。
WITH MEMBER
Measures.x AS SUM
(
MTD([Date].[Calendar].[Date].[July 20,
2002])
, [Measures].[Internet Freight Cost]
)
SELECT Measures.x
ON 0
FROM [Adventure
Works]
下面的示例使用 WITH MEMBER 关键字和 SUM 函数定义 Measures
维度中计算成员，其中包含 Geography 维度 Country 属性层次结构中的 Canada 和 United States 成员的 Reseller Sales Amount 度量值之和。
WITH MEMBER
Measures.NorthAmerica AS SUM
(
{[Geography].[Country].&[Canada]
,
[Geography].[Country].&[United States]}
,[Measures].[Reseller Sales Amount]
)
SELECT
{[Measures].[NorthAmerica]} ON 0,
[Product].[Category].members
ON 1
FROM [Adventure
Works]
通常，SUM 函数与 CURRENTMEMBER 函数或 YTD 之类的函数（返回根据层次结构的当前成员而变化的集合）一起使用。 例如，下面的查询返回所有日期（从日历年的开始到行轴上显示的日期）的 Internet Sales Amount 度量值的总和。
WITH MEMBER MEASURES.YTDSUM
AS
SUM(YTD(),
[Measures].[Internet Sales Amount])
SELECT
{[Measures].[Internet Sales Amount], MEASURES.YTDSUM} ON 0,
[Date].[Calendar].MEMBERS
ON 1
FROM [Adventure
Works]
130. Tail (MDX)
返回集末尾的子集。
语法
Tail(Set_Expression
[ ,Count ] )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Count
指定要返回的元组数的有效数值表达式。
注释
Tail 函数从指定集的结尾处返回指定的元组数目。 会保留元素的顺序。 Count 的默认值为 1。 如果指定的元组数目小于 1，则该函数返回空集。如果指定的元组数目超过了集中的元组数目，则此函数返回原始集。
示例
下例根据 Reseller Gross
Profit（分销商毛利润），返回前五个销售产品子类别的分销商销售额度量值，而不管层次结构如何。 Tail 函数用于在使用 Order 函数将结果排序后，仅返回结果中的后五个集。
SELECT Tail
(Order
([Product].[Product
Categories].[SubCategory].members
,[Measures].[Reseller Gross Profit]
,BASC
)
,5
) ON 0
FROM [Adventure
Works]
131.This (MDX)
返回用于多维表达式 (MDX) 脚本中的分配的当前子多维数据集。
语法
This
注释
This 函数可用于代替任何子多维数据集表达式，以提供 MDX 计算脚本中的当前作用域内的当前子多维数据集。 必须在分配的左侧使用 This 函数。
示例
以下 MDX 脚本片段说明如何将
This 关键字用于 SCOPE 语句来为子多维数据集进行分配：
Scope
(
[Date].[Fiscal
Year].&[2005],
[Date].[Fiscal].[Fiscal
Quarter].Members,
[Measures].[Sales
Amount Quota]
) ;
This = ParallelPeriod
(
[Date].[Fiscal].[Fiscal
Year], 1,
[Date].[Fiscal].CurrentMember
) * 1.35 ;
/*-- Allocate
equally to months in FY 2002 -----------------------------*/
Scope
(
[Date].[Fiscal
Year].&[2002],
[Date].[Fiscal].[Month].Members
) ;
This = [Date].[Fiscal].CurrentMember.Parent
/ 3 ;
End Scope ;
End Scope;
132. ToggleDrillState (MDX)
在成员之间切换深化模式和浅化模式的状态。
语法
ToggleDrillState(Set_Expression1,Set_Expression2
[, [RECURSIVE]
[,INCLUDE_CALC_MEMBERS]
] )
参数
Set_Expression1
返回集的有效多维表达式 (MDX)。
Set_Expression2
返回集的有效多维表达式 (MDX)。
Recursive
（可选）。 指示集的递归比较的关键字。 ToggleDrillState 函数结合了 DrillupMember 函数和 DrilldownMember 函数。 仅当该成员处于 DrilldownMember 状态才适用递归。
Include_calc_members
（可选）。 指示是否在深化级别包括计算成员（如果存在）的标志。
注释
ToggleDrillState 函数切换每个存在于第一个集中的第二个集的成员的钻取状态。 第一个集可以包含任意维数的元组，但是第二个集必须包含单个维度的成员。 ToggleDrillState 函数结合了 DrillupMember 函数和 DrilldownMember 函数。 如果第二个集中的成员 m 存在于第一个集中，并且该成员被深化（即，其后有一个直接后代），那么 DrillupMember(Set_Expression1, {m}) 将应用于第一个集中的成员或元组。 如果 m 成员被浅化（即，m 后没有 m 的直接后代），则对第一个集应用 DrilldownMember(Set_Expression1, {m}[, RECURSIVE])。
如果使用了可选的 RECURSIVE 标志，则循环应用浅化和深化。 关于循环标志的详细信息，请参阅 DrillupMember 函数和 DrilldownMember 函数。
通过查询 XMLA 属性
MdpropMdxDrillFunctions，您可以确认服务器为钻取功能提供的支持的级别；有关详细信息，请参阅支持的 XMLA 属性 (XMLA)。
请参阅 数据库日志：MDX
集函数：ToggleDrillState() 函数（用于涉及这个函数的方案和示例）。
示例
下例对第一个集中的澳大利亚成员进行深化，而对第一个集中的美国成员进行浅化。
SELECT
ToggleDrillState
({[Geography].[Geography].[Country].Members,
[Geography].[Geography].[Country].&[United States].Children},
{[Geography].[Geography].[Country].[Australia]
,
[Geography].[Geography].[Country].&[United States]}
--, recursive
--, include_calc_members
) ON 0
FROM [Adventure Works]
133. TopCount (MDX)
按降序对集进行排序，并返回指定数目的最大值元素。
语法
TopCount(Set_Expression,Count
[ ,Numeric_Expression ] )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Count
指定要返回的元组数的有效数值表达式。
Numeric_Expression
有效数值表达式，通常为返回数值的单元坐标的多维表达式 (MDX)。
注释
如果指定了数值表达式，则 TopCount 函数根据数值表达式指定的值（通过计算指定对集得出），对指定集指定的集中的元组按降序排序。 对集进行排序后，TopCount 函数返回指定数目的具有最大值的元组。
|
重要提示 |
|
与 BottomCount 函数一样，TopCount 函数总是会打乱层次结构。 |
如果未指定数值表达式，则函数按照自然顺序返回成员集，而不进行任何排序，其行为如同 Head
(MDX) 函数。
示例
下面的示例按 Internet Sales
Amount 返回前 10 个日期：
SELECT
[Measures].[Internet Sales Amount] ON 0,
TOPCOUNT([Date].[Date].[Date].MEMBERS,
10, [Measures].[Internet Sales Amount])
ON 1
FROM [Adventure
Works]
下面的示例返回 Bike 类别包含
Geography 维度中 Geography 层次结构的 City 级别的所有成员组合的集中的前五个成员，并按照 Reseller Sales Amount 度量值进行排序（从成员集中销售额最高的成员开始）。
SELECT
[Measures].[Reseller Sales Amount] ON 0,
TopCount
({[Geography].[Geography].[City].Members
*[Date].[Fiscal].[Fiscal Year].Members}
, 5
, [Measures].[Reseller Sales Amount]
) ON 1
FROM [Adventure
Works]
WHERE([Product].[Product
Categories].Bikes)
134. TopPercent (MDX)
按降序对集进行排序，并返回一个最大值元组集，该元组集的累积合计等于或大于指定的百分比。
语法
TopPercent(Set_Expression,
Percentage, Numeric_Expression)
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Percentage
指定要返回的元组数的有效数值表达式。
|
重要提示 |
|
Percentage 需要是正数值；负值将生成错误。 |
Numeric_Expression
通常是单元坐标（返回数字）的多维表达式
(MDX) 的有效数值表达式。
注释
TopPercent 函数使用指定的集对指定的数值表达式求和，同时对该集按降序排序。 然后，该函数返回具有最高值的元素，其总合计值的累积百分比至少是指定的百分比。 该函数返回累积合计至少达到指定百分比的最小子集。 返回的元素从大到小排序。
|
注意 |
|
|
如果 Numeric_Expression 返回任何负值，则 TopPercent 将仅返回一 (1) 行。 请参阅针对此行为的详细演示的第二个示例。 |
|
|
重要提示 |
|
|
与 BottomPercent 函数一样，TopPercent 函数总是会打乱层次结构。 |
|
示例
下面的示例返回对于“自行车”类别，帮助实现前 10% 的分销商销售额的最佳城市。 结果将按降序排序，并且从具有最高销售额的城市开始。
SELECT
[Measures].[Reseller Sales Amount] ON 0,
TopPercent
({[Geography].[Geography].[City].Members}
, 10
, [Measures].[Reseller Sales Amount]
) ON 1
FROM [Adventure
Works]
WHERE([Product].[Product
Categories].[Bikes])
上面的表达式生成以下结果：
|
Reseller Sales |
|
|
Toronto |
$3,508,904.84 |
|
London |
$1,521,530.09 |
|
Seattle |
$1,209,418.16 |
|
Paris |
$1,170,425.18 |
使用下面的查询可以获取原始数据集，并返回
588 行：
SELECT
[Measures].[Reseller Sales Amount] ON 0,
Order
({[Geography].[Geography].[City].Members}
, [Measures].[Reseller Sales Amount]
, BDESC
) ON 1
FROM [Adventure
Works]
WHERE([Product].[Product
Categories].[Bikes])
示例
下面的演练将帮助您理解 Numeric_Expression 中负值的影响。 首先，将生成一些可展示该行为的上下文。
下面的查询将返回一个表，由分销商的“Sales
Amount”、“Total Product Cost”和“Gross Profit”构成，并且按利润的降序排序。 请注意，对于利润仅存在负值；因此，最小的利润损失将出现在最顶部。
SELECT {
[Measures].[Reseller Sales Amount], [Measures].[Reseller Total Product Cost],
[Measures].[Reseller Gross Profit] } ON columns
,
ORDER( [Product].[Product Categories].[Bikes].[Touring Bikes].children,
[Measures].[Reseller Gross Profit], BDESC )
ON rows
FROM [Adventure Works]
上述查询会返回以下结果；为便于阅读，中间部分的行已删除。
|
Reseller Sales |
Reseller Total |
Reseller Gross |
|
|
Touring-2000 |
$157,444.56 |
$163,112.57 |
($5,668.01) |
|
Touring-2000 |
$321,027.03 |
$333,021.50 |
($11,994.47) |
|
Touring-3000 |
$87,773.61 |
$100,133.52 |
($12,359.91) |
|
… |
… |
… |
… |
|
Touring-1000 |
$1,016,312.83 |
$1,234,454.27 |
($218,141.44) |
|
Touring-1000 |
$1,184,363.30 |
$1,443,407.51 |
($259,044.21) |
现在，如果要求您按利润展示前 100% 的自行车，则编写如下查询：
SELECT {
[Measures].[Reseller Sales Amount], [Measures].[Reseller Total Product Cost],
[Measures].[Reseller Gross Profit] } ON columns
,
TOPPERCENT( [Product].[Product Categories].[Bikes].[Touring
Bikes].children, 100,[Measures].[Reseller Gross Profit] ) ON rows
FROM [Adventure Works]
请注意，查询要求百分之百 (100%)；这意味着应返回所有行。 但是，因为在 Numeric_Expression 中存在负值，所以仅返回一行。
|
Reseller Sales |
Reseller Total |
Reseller Gross |
|
|
Touring-2000 |
$157,444.56 |
$163,112.57 |
($5,668.01) |
135. TopSum (MDX)
对集进行排序并返回累计合计至少达到指定值的最前面元素。
语法
TopSum(Set_Expression,
Value, Numeric_Expression)
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Value
指定与每个元组相比较的值的有效数值表达式。
Numeric_Expression
返回度量值的有效数值表达式，通常是多维表达式 (MDX)。
注释
TopSum 函数计算对指定集求得的指定度量值的和，同时对该集按降序排序。 然后，该函数返回最大值元素，其指定数值表达式的合计至少为指定值。 此函数返回集的最小子集，其累积合计至少为指定值。 返回的元素按从大到小的顺序排序。
|
重要提示 |
|
与 BottomSum 函数一样，TopSum 函数总是会打乱层次结构。 |
示例
下面的示例返回 Geography 维度中 Geography
层次结构内 City 级别的最小成员集（对于 Bike 类别），使用 Reseller Sales Amount 度量值时该集的累积合计至少为
6,000,000（从集中具有最大销售额的成员开始）。
SELECT
[Measures].[Reseller Sales Amount] ON 0,
TopSum
({[Geography].[Geography].[City].Members}
, 6000000
, [Measures].[Reseller Sales Amount]
) ON 1
FROM [Adventure
Works]
WHERE([Product].[Product
Categories].Bikes)
136. TupleToStr (MDX)
返回多维表达式 (MDX) 格式的字符串，它对应于指定的元组。
语法
TupleToStr(Tuple_Expression)
参数
Tuple_Expression
返回元组的有效多维表达式 (MDX)。
注释
此函数用于将元组的字符串表示形式传输给外部函数进行分析。 返回的字符串将用大括号 {} 括起来；如果元组中明确定义了多个成员，则每个成员之间用逗号分隔。
示例
下面的示例返回字符串
([Date].[Calendar
Year].&[2001],[Geography].[Geography].[Country].&[United States])：
WITH MEMBER
Measures.x AS TupleToStr
(
([Date].[Calendar Year].&[2001]
,
[Geography].[Geography].[Country].&[United States]
)
)
SELECT Measures.x
ON 0
FROM [Adventure
Works]
下面的示例与上面的示例返回相同的字符串。
WITH SET s AS
{
([Date].[Calendar Year].&[2001],
[Geography].[Geography].[Country].&[United States]
)
}
MEMBER Measures.x
AS TupleToStr ( s.Item(0) )
SELECT Measures.x
ON 0
FROM [Adventure
Works]
137. Union (MDX)
返回两个集的并集，并且可以选择保留重复成员。
语法
Standard syntax
Union(Set_Expression1,
Set_Expression2 [,...n][, ALL])
Alternate syntax
1
Set_Expression1 +
Set_Expression2 [+...n]
Alternate syntax
2
{Set_Expression1 ,
Set_Expression2 [,...n]}
参数
Set Expression 1
返回集的有效多维表达式 (MDX)。
Set Expression 2
返回集的有效多维表达式 (MDX)。
注释
此函数可返回两个或多个指定集的并集。使用标准语法和替代语法 1 时，默认情况下会消除重复项。 使用标准语法和 ALL 标志可以保留并集中的重复项。 从该集的尾部删除重复项。 使用替代语法 2 时始终会保留重复项。
示例
以下示例将使用每种语法来演示 Union 函数的行为。
标准语法，消除重复项
SELECT Union
([Date].[Calendar Year].children
, {[Date].[Calendar Year].[CY 2002]}
, {[Date].[Calendar Year].[CY 2003]}
) ON 0
FROM [Adventure
Works]
标准语法，保留重复项
SELECT Union
([Date].[Calendar Year].children
, {[Date].[Calendar Year].[CY 2002]}
, {[Date].[Calendar Year].[CY 2003]}
, ALL
) ON 0
FROM [Adventure
Works]
替代语法 1，消除重复项
SELECT
[Date].[Calendar Year].children
+ {[Date].[Calendar Year].[CY 2002]}
+ {[Date].[Calendar Year].[CY 2003]} ON 0
FROM [Adventure
Works]
替代语法 2，保留重复项
SELECT
{[Date].[Calendar Year].children
, [Date].[Calendar Year].[CY 2002]
, [Date].[Calendar Year].[CY 2003]} ON 0
FROM [Adventure
Works]
138. UniqueName (MDX)
返回指定的维度、层次结构、级别或成员的唯一名称。
语法
Dimension
expression syntax
Dimension_Expression.UniqueName
Hierarchy
expression syntax
Hierarchy_Expression.UniqueName
Level expression
syntax
Level_Expression.UniqueName
Member expression
syntax
Member_Expression.UniqueName
参数
Dimension_Expression
解析为维度的有效多维表达式 (MDX)。
Hierarchy_Expression
返回层次结构的有效多维表达式 (MDX)。
Level_Expression
返回级别的有效多维表达式 (MDX)。
Member_Expression
返回成员的有效多维表达式 (MDX)。
注释
UniqueName 函数返回对象的唯一名称，而不是由 Name 函数返回的名称。 返回的名称不包括多维数据集的名称。 返回的结果取决于服务器端设置或 MDX Unique Name Style 连接字符串属性。
示例
下例将返回 Adventure Works
多维数据集中的 Product 维度、Product Categories 层次结构、Subcategory 级别和 Bike Racks 成员的唯一名称值。
WITH MEMBER
DimensionUniqueName
AS [Product].UniqueName
MEMBER
HierarchyUniqueName
AS [Product].[Product Categories].UniqueName
MEMBER
LevelUniqueName
AS [Product].[Product
Categories].[Subcategory].UniqueName
MEMBER
MemberUniqueName
AS [Product].[Product
Categories].[Subcategory].[Bike Racks]
SELECT
{DimensionUniqueName
, HierarchyUniqueName
, LevelUniqueName
, MemberUniqueName }
ON 0
FROM [Adventure
Works]
139. UnknownMember (MDX)
返回与级别或成员关联的未知成员。
语法
Member expression
syntax
Member_Expression.UnknownMember
Hierarchy_expression
syntax
Hierarchy_Expression.UnknownMember
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
Hierarchy_Expression
返回层次结构的有效多维表达式 (MDX)。
注释
当层次结构未知时，Microsoft
SQL Server Analysis Services 将创建一个未知成员，以便将事实数据表数据与该层次结构相关联。 未知成员可位于下列级别之一：
位于未聚合的属性层次结构的*。
位于自然层次结构的 All 级别下的第一级。
位于非自然层次结构的任何一级。
如果指定了成员表达式，UnknownMember 函数将返回指定成员的未知子成员。 如果指定的成员不存在，该函数将返回空。
如果指定了层次结构表达式，UnknownMember 函数将返回位于*的未知成员（如果存在）。
如果级别或成员中不存在未知成员，UnknownMember 函数将创建一个空成员。
|
注意 |
|
如果层次结构或成员中不存在未知成员，将生成一个错误。 |
示例
下面的示例为 Measures 维度的所有成员返回
Product 属性层次结构中 All Products 成员的未知成员。
SELECT
[Product].[Product].[All Products].UnknownMember
ON Columns,
[Measures].Members
ON Rows
FROM [Adventure
Works]
下面的示例为 Measures 维度的所有成员返回
Product Categories 层次结构的未知成员。
SELECT
[Product].[Product Categories].UnknownMember
ON Columns,
[Measures].Members
ON Rows
FROM [Adventure
Works]
140. Unorder (MDX)
从指定集中删除任何强制排序。
语法
Unorder(Set_Expression)
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
注释
Unorder 函数删除集中包含的元组被其他任意函数或语句（例如 Order 函数）强制实施的任一顺序。 由 Unorder 函数返回的集中的元组顺序是不确定的。
将 Unorder 函数用作
Microsoft SQL Server Analysis Services 的提示以对级处理进行查询优化。 如果集中的元组顺序对计算或查询并不重要，则使用 Unorder 函数可提高性能。 例如，与 Analysis Services 需要保留顺序时相比，NonEmpty
(MDX) 函数在提供给它的集未经排序时表现地更为出色；尽管使用 SQL Server 2014 Analysis Services (SSAS) 时，查询处理器会尝试自动对许多函数（例如 Sum 和 Aggregate）执行此函数。 使用 Unorder 的性能优势可能仅在包含数百万元组的非常大的集中才会体现出来。
示例
下面的伪代码说明了此函数的语法。
NonEmpty (UnOrder
(<set_expression>))
141. UserName (MDX)
返回当前连接的域名和用户名。
语法
UserName [ ( ) ]
注释
返回值为以下格式的字符串：
domain-name\user-name
示例
下例将返回正在执行查询的用户的用户名。
WITH MEMBER
Measures.x AS UserName
SELECT Measures.x
ON COLUMNS
FROM [Adventure
Works]
142. ValidMeasure (MDX)
在返回指定元组的结果时，通过将不适用的维度强制到“全部”级别（如果是不可聚合的，则为默认成员）来返回多维数据集中的度量值。
语法
ValidMeasure(Tuple_Expression)
参数
Tuple_Expression
返回元组的有效多维表达式 (MDX)。
注释
ValidMeasure 函数返回元组的值，并且忽略与元组返回其值的度量值的度量值组无关的属性。 出于以下两个原因，属性可与度量值无关：
属性的维度与元组中度量值的度量值组无关。
属性的维度与度量值的度量值组无关，但粒度属性不是键属性，并且粒度属性与元组中的属性没有直接关系。
该函数指定的行为是默认服务器端行为，并且受度量值组对象的 IgnoreUnrelatedDimensions 属性控制。
对于具有粒度的指定元组中的每个属性（也就是说，元组中的成员不是“全部”成员），其当前坐标按如下方式移动：
与指定属性成员相关的属性移动至与当前成员共存的成员。
与指定属性成员相关的属性移动至“全部”成员（如果层次结构是不可聚合的，则为默认成员）。
不相关的属性移动至“全部”成员（根据度量值）。
示例
下面的查询显示如何使用
ValidMeasure 函数来覆盖 IgnoreUnrelatedDimensions 属性的行为。 在 Adventure
Works 多维数据集中，Sales Targets 度量值组将 IgnoreUnrelatedDimensions 设置为 False；因为 Date 维度在 Calendar
Quarter 粒度联接到此度量值组，所以这意味着，Sales Quota 度量值默认情况下将在 Calendar Quarter 下返回 Null（尽管在 MDX 脚本中也存在将值向下分配给 Month 级别的计算）。 在计算度量值中使用 ValidMeasure 函数可用于使 Sales Quota 度量值的行为就像 IgnoreUnrelatedDimensions 设置为 True 一样并且强制 Sales
Quota 显示当前 Calendar Quarter 的值。
WITH MEMBER
MEASURES.VTEST AS VALIDMEASURE([Measures].[Sales Amount Quota])
SELECT
{[Measures].[Sales Amount Quota], MEASURES.VTEST} ON 0,
[Date].[Calendar].MEMBERS
ON 1
FROM [Adventure
Works]
同样，Sales Targets 度量值组与
Promotion 维度完全没有任何关系，因此，在 Promotion 上任何层次结构的“全部”成员之下，它将返回 Null。此外，可以通过使用 ValidMeasure 更改此行为：
WITH MEMBER
MEASURES.VTEST AS VALIDMEASURE([Measures].[Sales Amount Quota])
SELECT
{[Measures].[Sales Amount Quota], MEASURES.VTEST} ON 0,
[Promotion].[Promotions].members
ON 1
FROM [Adventure
Works]
143.Value (MDX)
返回查询上下文中的属性层次结构的当前成员与
Measures 维度的当前成员的交集的值。
语法
Member_Expression[.Value]
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
注释
Value 函数以字符串形式返回指定成员的值。 由于成员的值是成员的默认属性，并且如果未指定其他值则其值为返回的成员值，因此 Value 参数是可选的。 有关成员属性的详细信息，请参阅内部成员属性 (MDX)和用户定义的成员属性 (MDX)。
示例
下例将返回成员值并显式返回该成员的名称。
WITH MEMBER
[Date].[Calendar].NumericValue as [Date].[Calendar].[July 1, 2001].Value
MEMBER
[Date].[Calendar].MemberName AS [Date].[Calendar].[July 1, 2001].Name
SELECT
{[Date].[Calendar].NumericValue, [Date].[Calendar].MemberName} ON 0
from [Adventure
Works]
下例将以轴上成员的默认返回值返回成员值。
SELECT
{[Date].[Calendar].[July 1, 2001]} ON 0
from [Adventure
Works]
144. Var (MDX)
返回用无偏差总体公式（除以 n）对集计算数值表达式而求得的样本方差。
语法
Var(Set_Expression
[ ,Numeric_Expression ] )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Numeric_Expression
有效的数值表达式，通常为返回数值的单元坐标多维表达式 (MDX)。
注释
Var 函数返回对指定的集计算指定的数值表达式而求得的无偏差方差。
Var 函数使用无偏差总体公式，而 VarP 函数使用有偏差总体公式。
145. Variance (MDX)
Var 函数的别名。
146. VarianceP (MDX)
VarP 函数的别名。
147. VarP
返回数值表达式用有偏差总体公式（除以 n-1）对集求得的总体方差。
语法
VarP(Set_Expression
[ ,Numeric_Expression ] )
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Numeric_Expression
返回数字的有效数值表达式，通常为单元坐标的多维表达式 (MDX)。
注释
VarP 函数返回指定的数值表达式对指定的集求得的有偏差方差。
VarP 函数使用有偏差总体公式，而 Var 函数使用无偏差总体公式。
148. VisualTotals (MDX)
返回通过动态计算指定集内子成员的合计而生成的集，可以选择在得到的结果集内为父成员名称应用某种模式。
语法
VisualTotals(Set_Expression[,Pattern])
参数
Set_Expression
返回集的有效多维表达式 (MDX)。
Pattern
集中父成员的有效字符串表达式，包含星号
(*) 作为父名称的替代字符。
注释
指定的集表达式可以指定包含单个维度内任何级别成员（通常是具有祖先-后代关系的成员）的集。 VisualTotals 函数计算指定集中子成员值的总和，并在计算结果总和时忽略未包括在集中的子成员。 直观地对以层次结构顺序排序的集计算总和。 如果集中成员的顺序违背了层次结构，则结果就不是直观合计了。 例如，VisualTotals (USA, WA, CA, Seattle) 不将 WA 返回为 Seattle，而返回 WA、CA 和 Seattle 的值，然后计算这些值的总和作为 USA 的直观合计，同时计算两次 Seattle 的销售额。
|
注意 |
|
将 VisualTotals 函数应用于与度量值无关或在度量值组粒度以下的维度成员会导致各值被替换为空值。 |
Pattern 是可选的，可指定合计标签的格式。 Pattern 需要用星号 (*) 作为父成员的替代字符，而字符串中的剩余文本出现在与父名称相串联的结果中。 若要显示星号，请使用两个星号 (**)。
示例
下面的示例根据所指定的一个后代 - 7 月，返回 2001 日历年第三季度的直观合计。
SELECT
VisualTotals
({[Date].[Calendar].[Calendar
Quarter].&[2001]&[3]
,[Date].[Calendar].[Month].&[2001]&[7]}) ON 0
FROM [Adventure
Works]
下面的示例返回 Product 维度中 Category 属性层次结构的 [All]
成员及其四个子级中的两个。 对 Internet Sales Amount 度量值的 [All] 成员返回的合计是仅针对
Accessories 和 Clothing 成员的合计。 另外，模式参数用于指定 [All Products] 列的标签。
SELECT
VisualTotals
({[Product].[Category].[All Products]
,[Product].[Category].[Accessories]
,[Product].[Category].[Clothing]}
, '* - Visual Total'
) ON Columns
,
[Measures].[Internet Sales Amount] ON Rows
FROM [Adventure
Works]
149. Wtd (MDX)
按照时间维度中的周级别的约束，从给定成员所在的级别返回一组同级成员，从第一个同级成员开始到给定成员为止。
语法
Wtd( [
Member_Expression ] )
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
注释
如果未指定成员表达式，则默认值为第一个层次结构的当前成员并且具有度量值组中 Time (Time.CurrentMember) 类型的第一个维度中的 Weeks 类型的级别。
Wtd 函数是 PeriodsToDate 函数的快捷函数，它将后者的级别设置为 Weeks。 也就是说，Wtd(Member_Expression) 等效于PeriodsToDate(Week_Level_Expression,Member_Expression)。
150. Ytd (MDX)
按照 Time 维度中的 Year 级别的约束，从与给定成员相同的级别中返回同级成员的集，从第一个同级成员开始到给定成员为止。
语法
Ytd( [
Member_Expression ] )
参数
Member_Expression
返回成员的有效多维表达式 (MDX)。
注释
如果未指定成员表达式，则默认值为第一个层次结构的当前成员并且具有度量值组中 Time 类型的第一个维度中的 Years 类型的级别。
在级别所基于的属性层次结构的 Type 属性设置为 Years 的情况下，Ytd 函数是 PeriodsToDate 函数的快捷函数。 也就是说，Ytd(Member_Expression) 等效于 PeriodsToDate(Year_Level_Expression,Member_Expression)。 请注意，在 Type 属性设置为FiscalYears 时，此函数将不起作用。
示例
下面的示例将从 Adventure
Works 多维数据集中返回在 2003 日历年度的前八个月（包含在 Date 维度中）聚合的 Measures.[Order Quantity]成员之和。
WITH MEMBER
[Date].[Calendar].[First8MonthsCY2003] AS
Aggregate(
YTD([Date].[Calendar].[Month].[August
2003])
)
SELECT
[Date].[Calendar].[First8MonthsCY2003] ON
COLUMNS,
[Product].[Category].Children ON ROWS
FROM
[Adventure Works]
WHERE
[Measures].[Order Quantity]
通常在使用 Ytd 时不指定参数，这意味着 CurrentMember
(MDX) 函数将在报表中显示本年度至今的连续累积合计，如以下查询中所示：
WITH MEMBER
MEASURES.YTDDEMO AS
AGGREGATE(YTD(),
[Measures].[Internet Sales Amount])
SELECT
{[Measures].[Internet Sales Amount], MEASURES.YTDDEMO} ON 0,
[Date].[Calendar].MEMBERS
ON 1
FROM [Adventure Works]