MDX用户指南

MDX用户指南... 3

1．介绍... 4

2. 基本概念... 4

2.1 Cube结构... 4

2.2 示例Cube数据库... 5

2.3 表达式表示法... 6

2.4元组、集合... 6

3. MDX查询与语义... 7

3.1 MDX基本查询... 7

3.2 轴维度和切片器维度... 7

指定轴维度的内容... 8

指定切片器维度的内容... 9

3.3 高级查询－使用计算成员... 9

3.4 高级查询－使用命名集合... 11

4. MDX函数列表... 12

4.1 维度函数... 12

4.1.1 Dimension. 12

4.1.2 Dimensions 12

4.2 层级函数... 13

4.2.1 Hierarchy. 13

4.3 级别函数... 14

4.3.1 Level 14

4.3.2 Levels 14

4.4 成员函数... 15

4.4.1 Ancestor 15

4.4.2 ClosingPeriod. 16

4.4.3 Cousin. 17

4.4.4 CurrentMember 17

4.4.5 DefaultMember 18

4.4.6 FirstChild. 18

4.4.7 FirstSibling. 19

4.4.8 Lag. 19

4.4.9 LastChild. 20

4.4.10 LastSibling. 20

4.4.11 Lead. 20

4.4.12 NextMember 21

4.4.13 OpeningPeriod. 21

4.4.14 ParallelPeriod. 22

4.4.15 Parent 23

4.4.16 PrevMember 23

4.4.17 StrToMember 24

4.5 集合函数... 24

4.5.1 Ancestors 24

4.5.2 Ascendants 25

4.5.3 BottomCount 26

4.5.4 BottomPercent 26

4.5.5 BottomSum.. 27

4.5.6 Children. 27

4.5.7 Crossjoin. 28

4.5.8 Descendants 28

4.5.9 Distinct 30

4.5.10 Except 31

4.5.11 Filter 31

4.5.12 Generate. 32

4.5.13 Head. 33

4.5.14 Hierarchize. 34

4.5.15 Intersect 35

4.5.16 Members 35

4.5.17 Mtd. 36

4.5.18NonEmptyCrossjoin. 37

4.5.19 Order 39

4.5.20 PeriodsToDate. 41

4.5.21 Qtd. 41

4.5.22 Siblings 42

4.5.23 Subset 42

4.5.24 Tail 43

4.5.25 TopCount 43

4.5.26 TopPercent 44

4.5.27 TopSum.. 44

4.5.28 Union. 45

4.5.29 Wtd. 45

4.5.30 Ytd. 45

4.5.31 : 46

4.6 逻辑函数... 46

4.6.1 IsEmpty. 46

4.6.2 And. 47

4.6.3 Or 47

4.6.4 Not 47

4.6.5 Xor 47

4.6.6 >. 47

4.6.7 >=. 48

4.6.8 <. 48

4.6.9 <=. 48

4.6.10 <>. 48

4.6.11 =. 48

4.7 数值函数... 49

4.7.1 Aggregate. 49

4.7.2 Avg. 49

4.7.3 CoalesceEmpty. 49

4.7.4 Count 50

4.7.5 IIf 51

4.7.6 Max. 52

4.7.7 Median. 53

4.7.8 Min. 53

4.7.9 Sum.. 54

4.7.10 Value. 54

4.7.11 +. 54

4.7.12 - 54

4.7.13 *. 55

4.7.14 / 55

4.8 字符串函数... 55

4.8.1 Generate. 55

4.8.2 IIf 55

4.8.3 Name. 55

4.8.4 Caption. 56

4.8.5 UniqueName. 56

4.8.6 Properties 57

4.8.9 Format 58

将数字格式化成字符串. 58

5.分析功能应用举例... 58

5.1      成员百分比分析... 58

5.2 重要顾客分布分析... 59

5.3 排序... 60

5.4 历史相关的累计值... 60

5.5 四则运算... 61

5.6 逻辑判断... 61

5.7 成员属性... 61

5.8 多步计算实现复杂逻辑... 62

5.9 同期、前期... 62

5.10 Top N分析... 63

5.11成员过滤... 63

MDX用户指南

MDX为MultIDimensional Expressions的缩写，多维表达式，是标准的olAP查询语言。在多数olAPServer都提供MDX支持，如Microsoft sql Server olAP Services,SAS,Hyperion Essbase等。支持多维对象与数据的定义和 *** 作。MDX 在很多方面与结构化查询语言 (sql) 语法相似，但它不是 sql 语言的扩展；事实上，MDX 所提供的一些功能也可由 sql 提供，尽管不是那么有效或直观。

如同 sql 查询一样，每个 MDX 查询都要求有数据请求（SELECT 子句）、起始点（FROM 子句）和筛选（WHERE 子句）。这些关键字以及其它关键字提供了各种工具，用来从多维数据集析取数据的特定部分。MDX 还提供了可靠的函数集，用来对所检索的数据进行 *** 作，同时还具有用用户定义函数扩展 MDX 的能力。

MDX为多维数据库提供了表达式查询语法，用于查询Cube数据，并提供了许多强大的分析函数，用于支持常用的olAP分析。

Kingdee olAP实现了MDX语法，提供了大多数MDX函数，部分函数未实现，因为我们认为当前没有必要实现。本文档后面会提供支持的函数列表。

本指南更像一本入门教程。更为详细的信息可以参考sqlServer olAP Services联机文档。

       在介绍MDX之前，我们简单介绍一下cube结构,理解cube结构是学习MDX的前提。我们采用sqlServer olAP Services自带的事例olAP数据库FoodMart来描述。我们建议你阅读《olap模型设计指南》来学习、熟悉Cube结构。

Cube是联机分析的关键。它们是一种多维结构，包括原始事实数据、聚合数据，这些数据聚合允许用户快速进行复杂查询。

Cube包含两个基本的概念：维度和度量。

维度(Dimension): 维度提供了分类描述,表示一类分析角度,用户通过维度来分析度量数据.

度量(Measures): 度量表示用来聚合分析的数字信息,如数量,销售金额等.

重要: 度量的集合组成了一个特殊的维度,叫做”Measures”.

一个维度可以包含级别的层级结构,级别（Level）表示特定的分类.比如,地区维度可以包含级别层级:Country、State、City。每个级别比它的父级别在数据粒度上更加细粒度。又比如：一个时间维可能包含级别：年、季、月。

成员，是最重要的概念之一。一个成员是维度（包括度量维Measures）上的一个项目值，时间维度上“年”级别的成员可能有2000、2001，月成员有1、2、3等等。

计算成员是一种运行时通过特殊表达式动态计算的成员。计算成员可以定义为度量。计算成员不影响现有的cube数据，它基于cube数据，通过各种数学表达式和各种函数定义，可以创建复杂的表达式。任何动态分析功能，都可以通过计算成员实现，比如实现占比、同期比等等。

示例olAP数据库结构（FoodMart Sales Cube，来自Microsoft olAP Services）。

       维度、级别、成员等，一般用唯一名称Uniquename来标示，可以用[]包围name，如果name有空格或者以数字开头，必须使用[],否则可以忽略。Uniquename是根据层级结构表示的一种方法。即递归显示出祖先的名称。

维度(Dimension)：维度直接用[]包围。Product的唯一名称为[Product]或Product，维度Education Level的唯一名称为[Education Level]。度量维为[Measures]。

级别(Level)：级别的Uniquename为[维度名称].[级别名称]，如[Product].[ Product Family]，同样，如果没有空格，[]可以省略，如Product.[Product Family]。

成员(Member)：成员的Uniquename格式为[维度].(Parent Member Uniquename).[Member name]，如上面时间维上的2003年2月份的Uniquename为[Time].[1].[2]，中间的1为1季度，因为该维度的结构为年、季、月。

度量（Measure）：度量实际上是属于度量维的成员。如度量Unit Sales的Uniquename为[Measures].[Unit Sales]。

Uniquename是olAP元素内部的表示法，在MDX查询语言中，可以使用Uniquename来表示元素。同时，MDX还提供模糊和其它等价的元素标示方式。表现在：

1)                  省略维度名标示级别，如果一个维度的级别名称在整个Cube中是唯一的，那么可以省略维度名来查询级别。如Product.[Product Family]可以写成[Product Family]。

2)                  省略维度名标示成员，如果省略维度名，可以标示该维度最高级别的成员，如[Time].[2000]可以写成[2000],[Measures].[Unit Sales]可以写成[Unit Sales].

3)                  成员挂在级别下，即成员不一定要写成[维度].(Parent Member Uniquename).[Member name]，可以写成[维度].[级别].[Member name].如2000年3月可以写成[Time].[Months].[3]

模糊查询表示法,都基于不会重复的假设,如果有重复的元素,取第一个查找到的元素作为查询结果,可能发生错误.因此,建议使用完备的表示法.

       元组用于定义来自多维数据集的数据切片；它由来自一个或多个维度的单个成员的有序集合组成。元组内不能包含来自同一个维度的多个成员（是否可以理解为坐标？）.元组用()包围.如:

       (时间.[下半年])

       (时间.[下半年],[产品].[手机].[Nokia])

       如果一个元组是由单个维度的成员组成,那么可以不用()包围,即(时间.[下半年])可表示成:时间.[下半年]

       集合(set)是零个、一个或多个元组的有序集合。集合最常用于在 MDX 查询中定义轴维度和切片器维度，并且同样可能只具有单个元组或可能在某些情况下为空。在 MDX 语法中，元组用花括号括起来以构造集合，下面的示例显示具有两个元组的集合：

{ (时间.[上半年],路线.非陆地.航空),(时间.[下半年],路线.非陆地.海路) }

一个集合可包含同一个元组不止一次的出现。下面的集合是可接受的：

{ 时间.[下半年],时间.[下半年] }

集合指以元组表示的一组成员组合，或指集合中的元组所代表的单元中的值，视集合使用的上下文而定。

       注意，单个元组的集合不等于元组。如{时间.[下半年]}不等于 时间.[下半年].

       在MDX语法中，很多函数语义中包含元组和集合，作为参数或者返回值。

       先看看MDX基本语法结构：

       基本的 MDX SELECT 语句包含一个 SELECT 子句和一个 FROM 子句，以及一个可选的 WHERE 子句。

       [axis specificatioin]可以看成是轴的成员选择。[slicer specification]表示切片上的成员，可以看成过滤信息，[slicer specification]可选，如果没有指定，取系统默认的维度成员作为切片。

       该查询语句返回一个二维表格数据，可以显示为交叉表形式。

       这里Measures表示度量维，[Store]表示Store维，[]可选，如果维度名称有空格，则需要用[]包围。Members函数施加在维度上返回该维度的所有成员。该查询显示所有商店的度量值。二维表格如下：   

       当设计多维表达式 (MDX) 查询时，应用程序一般查看多维数据集并将维度集合划分为两个子集：

因为轴维度和切片器维度都可从要查询的多维数据集的多个维度构造，所以用这些术语将要查询的多维数据集使用的维度与在由 MDX 查询返回的多维数据集中创建的维度区分开。

例如，假定存在名为 TestCube 的多维数据集，具有两个名为 Route 和 Time 的简单维度。因为多维数据集的度量值是 Measures 维度的一部分，所以该多维数据集总共有三个维度。查询要提供一个矩阵，可以在该矩阵内跨路线和时间比较 Packages 度量值。

在下面的 MDX 查询示例中，Route 和 Time 维度用作轴维度，Measures 维度用作切片器维度。Members 函数表明要用于构造集合的维度或级别的成员，而不必在 MDX 查询中显式声明给定维度或级别的各个成员。

SELECT

   { Route.nonground.Members } ON ColUMNS,

   { Time.[1st half].Members } ON ROWS

FROM TestCube

WHERE ( [Measures].[Packages] )

得到的值表格类似于下表，表中在 ColUMNS 和 ROWS 轴维度的各个交集显示 Packages 度量值的值。

MDX 首先评估轴维度和切片器维度，并在从要查询的多维数据集检索信息之前生成结果多维数据集的结构。

轴维度决定多维结果集的边缘。多维表达式 (MDX) 使用 SELECT 子句通过将集合指派到特定轴来指定轴维度。以下信息描述在 MDX 中怎样处理这种指派。

在下面的语法示例中，每个 <axis_specification> 值定义一个轴维度。数据集中轴的个数等于多维表达式 (MDX) 查询中 <axis_specification> 值的个数。MDX 查询最多可以支持 128 个指定轴，但几乎没有 MDX 查询会用到 5 个以上的轴。

<axis_specification> 语法可分解为：

<axis_specification> ::= <set> ON <axis_name>

<axis_name> ::= ColUMNS | ROWS

轴维度上的只能接受集合<set>，如果是手工指定成员集合，必须用{}包围，如果使用MDX集合函数，则不需要用{}包围，因为集合函数返回值为集合。一个轴维度上可以包含几个维度，如：

SELECT {[Measures].[Sales_Dollars],[Measures].[Sales_Units],[Measures].[Sales_Units_max]} ON columns,CrossJoin({[State].[Canada],[State].[Mexico],[State].[USA]},{[Product].[Bread],[Product].[Dairy],[Product].[meat]}) ON rows FROM sales WHERE ([Time].[All Time],[Employee].[All Employee])

Columns轴上是手工指定的成员元组集合，用{}包围，Rows轴使用集合函数CrossJoin，该函数返回两个集合的交集，Rows轴上包含两个维度State和Product。

切片器维度筛选多维数据。可以通过将切片器维度包含在多维表达式 (MDX) 查询的 WHERE 子句来限制所返回的数据。

假定未显式指派给轴的维度是切片器维度，并用其默认成员进行筛选。则默认成员为最高级别的第一个成员。

切片器维度还可通过使用 MDX 语法的 WHERE 子句进行显式指定。WHERE 子句的语法可分解为：

[WHERE [<slicer_specification>]]

切片器维度只可接受评估为单个元组的表达式。如下例所示：

WHERE ( [Time].[1st half],[Route].[nonground] )

       基本MDX查询提供了对多维数据的简单查询，MDX查询还提供了更为丰富强大的多维查询工具。

       计算成员允许在查询表达式中定义公式，并将该公式当成一个新的成员，挂在某个维度下。它并非通过检索数据来解析，而是通过计算 MDX 表达式来返回值。在 MDX 查询中构造和使用计算成员的能力为多维数据提供了大量 *** 作功能。多数分析功能都可以通过计算成员来实现。

       MDX通过With语句来创建计算成员，下面的语法用于将 WITH 关键字添加到 MDX SELECT 语句：

[WITH <formula_specification>]

      [,<formula_specification>]

SELECT [<axis_specification>

       [,<axis_specification>...]]

  FROM [<cube_specification>]

[WHERE [<slicer_specification>]]

计算成员的 <formula_specification> 值在以下语法定义中进一步分解：

<formula_specification> ::= MEMBER <member_name>

                            AS '<value_Expression>'

                            [,Format_String = <unsigned string>]

                            [,<cell_property>=<value_Expression>...]

<member_name> 值是计算成员的完全合法名称，其中包括了该计算成员所关联的维度或级别，而 <value_Expression> 值在经过计算后，将返回计算成员的值。

通过在 Format_String中指定计算成员的格式化串，跟Cube定义中的Measure定义的formatString一样，采用java.text.DecimalFormater中的格式化语法。

例如，下面的 MDX 查询示例定义了两个计算成员。第一个计算成员 [Measures].[StoreType] 用于表示 Store Type 成员属性。第二个计算成员 [Measures].[ProfitPct] 用于计算给定商店的总利润率，并将其表示为格式化的百分比值。

WITH

   MEMBER [Measures].[StoreType] AS

   '[Store].CurrentMember.PropertIEs("Store Type")',           其意不详

   SolVE_ORDER = 2

   MEMBER [Measures].[ProfitPct] AS

   '(Measures.[Store Sales] - Measures.[Store Cost]) / Measures.[Store Sales]),

SELECT

   { [Store].[Store name].Members} ON ColUMNS,

   { [Measures].[Store Sales],[Measures].[Store Cost],[Measures].[StoreType],

   [Measures].[ProfitPct] } ON ROWS

FROM Sales

计算成员可在层次结构的任意位置创建。例如，下列 MDX 查询示例定义作为 [Beer and Wine] 成员的子成员创建的计算成员，以确定给定商店的啤酒和果酒 (Beer and Wine) 的单位销售额是否至少为 100.00：

WITH

   MEMBER [Product].[Beer and Wine].[BigSeller] AS

  'IIf([Product].[Beer and Wine] > 100,"Yes","No")'

SELECT

   {[Product].[BigSeller]} ON ColUMNS,

   {Store.[Store name].Members} ON ROWS

FROM Sales

也可创建不仅取决于多维数据集中的现有成员，而且取决于同一 MDX 表达式中定义的其它计算成员的计算成员。下列示例说明这样的 MDX 表达式：

WITH

   MEMBER [Measures].[ProfitPct] AS

   'Val((Measures.[Store Sales] - Measures.[Store Cost]) / Measures.[Store Sales])',

   FORMAT_STRING = '#.00%'

   MEMBER [Measures].[ProfitValue] AS

   '[Measures].[Store Sales] * [Measures].[ProfitPct]',

FORMAT_STRING = '#,###.##'

SELECT

   { [Store].[Store name].Members} ON ColUMNS,[Measures].[ProfitValue],

   [Measures].[ProfitPct] } ON ROWS

FROM Sales

第二个计算成员 [Measures].[ProfitValue] 使用第一个计算成员 [Measures].[ProfitPct] 中创建的值来生成自己的值。

只能是后面的计算成员使用前面的计算成员，不能反过来，所有，计算成员的顺序很重要。

命名集合是一个与别名相关联的集合表达式。它定义一个集合，可以在MDX语句中多出使用，主要是为了方便维护，提高可读性，如果该集合被多处使用，可以重用，减少解析时间，提高性能。命名集别名视为集合表达式，并可用于任何接受集合表达式的地方。

下面的语法用于将 WITH 关键字添加到 MDX SELECT 语句：

[WITH <formula_specification>]

      [,<axis_specification>...]]

  FROM [<cube_specification>]

[WHERE [<slicer_specification>]]

命名集的 <formula_specification> 值进一步分解为以下语法定义：

<formula_specification> ::= SET <set_name> AS '<set>'

<set_name> 参数包含命名集的别名。<set> 参数包含命名集别名所指的集合表达式。

例如，[ChardonnayChablis] 命名集用于Product 维度上的所有 Chardonnay 酒和 Chablis 酒成员。以下示例对命名集的语法进行了描述：

WITH SET [ChardonnayChablis] AS

   '{[Product].[All Products].[Drink].[Alcoholic Beverages].[Beer and Wine].[Wine].[Good].[Good Chardonnay],

   [Product].[All Products].[Drink].[Alcoholic Beverages].[Beer and Wine].[Wine].[Pearl].[Pearl Chardonnay],

   [Product].[All Products].[Drink].[Alcoholic Beverages].[Beer and Wine].[Wine].[Portsmouth].[Portsmouth Chardonnay],

   [Product].[All Products].[Drink].[Alcoholic Beverages].[Beer and Wine].[Wine].[top Measure].[top Measure Chardonnay],

   [Product].[All Products].[Drink].[Alcoholic Beverages].[Beer and Wine].[Wine].[Walrus].[Walrus Chardonnay],

   [Product].[All Products].[Drink].[Alcoholic Beverages].[Beer and Wine].[Wine].[Good].[Good Chablis Wine],

   [Product].[All Products].[Drink].[Alcoholic Beverages].[Beer and Wine].[Wine].[Pearl].[Pearl Chablis Wine],

   [Product].[All Products].[Drink].[Alcoholic Beverages].[Beer and Wine].[Wine].[Portsmouth].[Portsmouth Chablis Wine],

   [Product].[All Products].[Drink].[Alcoholic Beverages].[Beer and Wine].[Wine].[top Measure].[top Measure Chablis Wine],

   [Product].[All Products].[Drink].[Alcoholic Beverages].[Beer and Wine].[Wine].[Walrus].[Walrus Chablis Wine]}'

还可在用于创建命名集的集合表达式中使用 MDX 函数。

       函数分类和说明基本上是直接从sqlServer Analysis Service拷贝的。

       表示返回值为Dimension的函数.

返回包含指定的成员、级别或层次结构的维度。

«Member».Dimension

返回包含 «Member» 的维度。

«Level».Dimension

返回包含 «Level» 的维度。

«HIErarchy».Dimension

返回包含 «HIErarchy» 的维度。

返回由数值表达式或字符串表达式指定的维度。

Dimensions(«Numeric Expression»)

返回这样的维度，该维度在多维数据集中以零为基的位置是由 «Numeric Expression» 指定的。

说明  Measures 维度总由 Dimensions(0) 表示。

Dimensions(«String Expression»)

返回这样的维度，该维度的名称是由 «String Expression» 指定的。

Dimensions 函数的字符串版本通常用于用户定义的函数。

如果将 Time、Region 和 Product 维度添加到多维数据集（按照所列顺序），则下面的表达式将返回 Region：

Dimensions(2)

       返回值为HIErarchy的函数。

注：实际上，在本文档中，我们比较少介绍HIErarchy的概念，因为我们建议一个维度只能有一个HIErarchy，这时，HIErarchy基本上等同于Dimension。因此，用户可以不用层级函数。

返回包含指定的成员或级别的层次结构。

«Member».HIErarchy

返回包含 «Member» 的层次结构。

«Level».HIErarchy

返回包含 «Level» 的层次结构。

[January].HIErarchy

该示例返回 Time。

[Quarter].HIErarchy

该示例返回 Time。

返回成员的级别。

«Member».Level

如果 Time 维度有"（全部）"、Year、Quarter、Month、Week 和 Day 级别，则以下示例返回 Month 级别：

January.Level

下面的示例返回 Month 级别的名称：

January.Level.name

返回由数值表达式或字符串表达式指定的级别。

«Dimension».Levels(«Numeric Expression»)

返回其基于零的位置是由 «Numeric Expression» 指定的级别。

Levels(«String Expression»)

返回其名称是由 «String Expression» 指定的级别。

字符串版本的 Levels 函数用于用户定义的函数。

下面的示例假定 Time 维度有"（全部）"、Year、Quarter、Month、Week 和 Day 级别。

以下示例返回 Quarter 级别：

Time.Levels(2)

以下示例返回 Year 级别：

Levels("Year")

返回指定级别或指定距离上成员的祖先。

Ancestor(«Member»,«Level»)

返回 «Level» 中指定的维度级别中的 «Member» 的祖先。

Ancestor(«Member»,«Numeric Expression»)

返回层次结构中与 «Member» 的距离为 «Numeric Expression» 个步骤的祖先。

如果 Geography 维度包括级别 Country、State 和 City，下列函数将返回如下值。

Ancestor(Los Angeles,Country)

[USA]

Ancestor(Los Angeles,State)

[California]

Ancestor(Los Angeles,0)

[Los Angeles]

Ancestor(Los Angeles,1)

[California]

Ancestor(Los Angeles,2)

[USA]

返回成员在指定级别上的后代中的最后一个兄弟。

ClosingPeriod([«Level»[,«Member»]])

如果指定 «Level»，则使用包含 «Level» 的维度，否则使用 Time 维度。如果没有指定 «Level»，则使用 «Member» 所在级别的下一级别。如果未指定 «Level» 或 «Member»，则默认设置为 Time.CurrentMember。

此函数等同于 BottomCount(Descendants(«Member»,«Level»),1)。

openingPeriod 函数与此函数类似，但返回第一个兄弟而不是最后一个兄弟。

下例返回 [1991].December：

ClosingPeriod(Month,[1991])

返回父成员下方与指定子成员具有相同的相对位置的子成员。

Cousin(«Member1»,«Member2»)

此函数在级别内的成员顺序和位置上 *** 作。如果有两个维度，第一个有四个级别，第二个有五个级别，则第一个维度第三级别的同代是第二个维度的第三级别。

在下面的示例中，假定年份 1996 和 1994 在成员 march 之前都包含相同数目的月份：

Cousin([1996].march,[1994])

本例产生成员 [1994].march。

如果同一示例假定 1996 级别包含 January、February、march、April、May、June、July、August、September、October、November 和 December 成员，而 1994 级别包含 [1st Quarter]、[2nd Quarter]、[3rd Quarter] 和 [4th Quarter] 成员，则该示例返回 [1994].[3rd Quarter]，因为它处于该级别内的同一相对位置（第三）。

返回迭代过程中维度上的当前成员。

«Dimension».CurrentMember

在维度成员集合的迭代过程中，迭代过程的每一步中正在被 *** 作的成员就是当前成员。此函数返回该成员。

Time..CurrentMember

返回维度或层次结构的默认成员。

«Dimension».DefaultMember

«HIErarchy».DefaultMember

如果维度包含"（全部）"级别，则默认成员是"全部"成员。如果该属性是空的而维度或层次结构不包含"（全部）"级别，则默认成员是最高级别的任何成员。后一种情况下，DefaultMember 函数不明确，我们处理为计算后物理存储的第一个成员。

如果 Time 维度包含级别"（全部）"、Year、Quarter、Month 和成员 All-Time，则下面的表达式返回 All-Time：

Time.DefaultMember

如果 [Fiscal Year] 层次结构包含级别 Quarter、Month 和成员 [Month 1]，则下列表达式返回 [Month 1]：

[Fiscal Year].DefaultMember

返回成员的第一个子代。

«Member».FirstChild

如果 Time 维度包含级别 Year、Quarter、Month、Week 和 Day，则下面的代码返回 January：

[1995].FirstChild

返回成员的父代的第一个子代。

«Member».FirstSibling

假定维度由月份组成，则下面的示例返回 January：

May.FirstSibling

返回成员，该成员处在其所在维度中指定的成员之前指定的位数上。

«Member».Lag(«Numeric Expression»)

成员在维度中的位置由维度的自然顺序决定。位置的编号以零为基。

如果 «Numeric Expression» 为零，则返回 «Member»。如果 «Numeric Expression» 为负数，则返回其后的成员。

Lag(1) 等同于 PrevMember。Lag(-1) 等同于 NextMember。

«Member».Lead 函数与此类似，但是方向相反。Lag(n) 等同于 Lead(-n)。

如果 Time 维度中的级别包括 Year 和 Month，则下面的示例返回 [1994].November：

[1995].February.Lag(3)

返回指定成员的最后一个子代。

«Member».LastChild

如果 Time 维度包含 Year、Quarter、Month、Week 和 Day，则下面的示例返回 December：

1995.LastChild

返回指定成员的父代的最后一个子代。

«Member».LastSibling

如果父代级别为 quarters，则以下示例返回 June：

May.LastSibling

返回成员，该成员处在其所在维度中指定的成员后指定的位数上。

«Member».Lead(«Numeric Expression»)

成员在维度中的位置由维度的自然顺序决定。位置的编号以零为基。

如果 «Numeric Expression» 为零，则返回 «Member»。如果 «Numeric Expression» 为负数，则返回前面的成员。

Lead(1) 等同于 NextMember。Lead(-1) 等同于 PrevMember。

«Member».Lag 函数与此类似，但方向相反。Lead(n) 等同于 Lag(-n)。

如果 Time 维度中的级别包括 Year 和 Month，则下面的示例返回 [1995].February：

[1994].November.Lead(3)

返回指定成员所在级别的下一个成员。

«Member».NextMember

NextMember 函数返回与 «Member» 中所指定的成员位于同一级别的下一个成员。

如果 Year 级别是由名为 [1994]、[1995] 和 [1996] 的成员组成，则下例返回 [1995]：

[1994].NextMember

返回某一指定级别的后代中的第一个兄弟，或者某一指定成员的后代中的第一个兄弟。

openingPeriod([«Level»[,«Member»]])

如果指定 «Level»，则使用包含 «Level» 的维度，否则使用 Time 维度。如果没有指定 «Level»，则使用 «Member» 所在级别的下一级别。如果未指定 «Level» 和 «Member»，则默认设置为 Time.CurrentMember。

此函数等同于 topCount(Descendants(«Member»,«Level»),1)。

ClosingPeriod 函数与此类似，但返回最后一个兄弟而非第一个兄弟。

下例返回 [1991].January：

openingPeriod(Month,[1991])

返回上一时期中与指定成员具有相同的相对位置的成员。

ParallelPeriod([«Level»[,«Numeric Expression»[,«Member»]]])

此函数类似于 Cousin 函数，但与 Time 系列的关系更密切。它在 «Level»（称作 ancestor）中提取 «Member» 的祖先，然后提取滞后 «Numeric Expression» 的 ancestor 的兄弟，并返回那个兄弟后代中 «Member» 的并行时期。

此函数有如下默认值：

此函数等同于 Cousin(Member,Lag(Ancestor(Member,Level),Numeric Expression)。

下表列出如何使用此函数的各种示例。

ParallelPeriod(Year,2,

[96 Qtr 3])

[94 Qtr 3]

ParallelPeriod(Year,2)

ParallelPeriod(Year)

ParallelPeriod()

返回成员的父代。

«Member».Parent

此函数返回在 «Member» 中指定的成员的父成员。

如果 Geography 维度包括 State 和 Country，则以下示例返回 USA：

California.Parent

返回指定成员所在级别的上一个成员。

«Member».PrevMember

此函数返回与 «Member» 中所指定的成员位于同一级别的前一个成员。

如果 Year 级别是由 [1994]、[1995] 和 [1996] 组成的，则下例返回成员 [1995]：

[1996].PrevMember

返回具有多维表达式 (MDX) 格式的字符串表达式中的成员。

StrToMember(«String Expression»)

返回具有 MDX 格式的字符串中的成员，该字符串应包含有成员，并在 «String Expression» 中指定。

StrToMember 函数通常用于用户定义的函数。

下例返回成员 Time.[1996]：

StrToMember("Time.[1996]")

       返回集合的函数。

返回指定级别或距离的成员的所有祖先的集合。

Ancestors(«Member»,«Level»)

返回 «Level» 中指定级别的 «Member» 的所有祖先。

返回成员的集合必须全部来自同一层次结构，但是 «Level» 不必是与 «Member» 同一层次结构的级别。

Ancestors(«Member»,«Numeric Expression»)

返回层次结构中 «Member» 之上 «Numeric Expression» 个步骤的层次结构的所有成员。Ancestors 函数的这一形式适用于父代级别未知或无法命名的情况。返回成员的集合必须都来自同一层次结构。

说明  Ancestors(«Member»,0) 返回 «Member»。

与 Ancestor 函数不同，Ancestors 是一个集合值表达式；它返回的是一个集合而不是一个成员。

如果 Geography 维度包括级别 Country、State 和 City，下列函数将返回如下值。

Ancestors([Los Angeles],Country)

{ USA }

Ancestors([Los Angeles],State)

{ California }

Ancestors([Los Angeles],0)

{ [Los Angeles] }

Ancestors([Los Angeles],1)

{ California }

Ancestors([Los Angeles],2)

{ USA }

返回指定成员的祖先集合。

Ascendants(«Member»)

Ancestor 函数返回特定级别上的一个特定的祖先成员或祖先，而 Ascendants 函数则不同，它对成员的层次结构执行后序遍历，并且在集合中返回与给定成员相关的所有祖先成员，包括其自身。

下例返回集合 { LA,California,USA,[All Locations] }：

Ascendants([Los Angeles])

从集合底端开始返回指定数目的项，可以选择首先对集合排序。

BottomCount(«Set»,«Count»[,«Numeric Expression»])

此函数根据 «Numeric Expression» 的值对集合进行排序，然后返回底端 «Count» 成员，其中的 «Count» 是一个数值表达式。

重要  与 topCount 函数相似，BottomCount 函数总是打破层次结构。

BottomCount(Geography.CitIEs.Members,5,Sales)

对集合排序并返回指定数目的最底部的元素，这些元素的累积合计至少为指定的百分比。

BottomPercent(«Set»,«Percentage»,«Numeric Expression»)

此函数对在 «Set« 中指定的集合进行排序，并返回其 «Numeric Expression» 的累积合计至少为 «Percentage» 的指定数量的最底端元素。«Percentage» 是一个数值表达式。

重要  与 topPercent 函数相似，BottomPercent 函数总是打破层次结构。

BottomPercent(Products.[Product Description].Members,25,Sales)

使用数值表达式对集合排序，并返回指定数量的最底端元素，这些元素的和至少为指定的值。

BottomSum(«Set»,«Value»,«Numeric Expression»)

此函数按 «Numeric Expression« 进行排序并挑选最底端的 n（可能的最小数）个元素，这些元素的和至少是 «Value»。

重要  与 topSum 函数相似，BottomSum 函数总是打破层次结构。

BottomSum(Products.[Product Description].Members,100000,Quantity)

返回成员的子代。

«Member».Children

下列代码返回 { Nebraska,Oklahoma,Montana }：

[Geography].[All Geography].[Central Region].Children

返回两个集合的矢量积。

Crossjoin(«Set1»,«Set2»)

«Set1» * «Set2»

所得集合中元组的顺序取决于 «Set1» 和 «Set2» 的顺序，以及其成员的顺序。

如果 «Set1» = {x1,x2,...,xn} 并且 «Set2» = {y1,y2,yn}，则 Crossjoin(Set1,Set2) 为：

{(x1,y1),(x1,y2), yn),(x2,

(x2,yn),(xn, y2),yn)}

下例返回 {([1994],USA),([1994],Japan),([1995],Japan)}：

CrossJoin({[1994],[1995]},{USA,Japan})

返回某一成员在指定级别或距离上的后代集合，可以选择包含或不包含其它级别上的后代。

Descendants(«Member»,[«Level»[,«Desc_flags»]])

返回成员的后代集合，该成员由 «Member» 指定，位于 «Level» 所指定的级别，并且可以选择由 «Desc_flags» 中指定的标志进行修改。

如果没有指定 «Level» 或 «Desc-flags» 参数，则函数的语法如下：

Descendants(«Member»,«Member».Level,SELF_BEFORE_AND_AFTER)

Descendants(«Member»,«distance»[,«Desc_flags»])

返回成员的后代，而该成员由 «Member»（在层次结构中有 «distance» 个步骤）指定，并且可以选择由 «Desc_flags» 中指定的标志进行修改。此语法通常用于处理不齐整层次结构。指定 «distance» 为 0 将返回一个只包含 «Member» 中指定的成员的集合。

默认情况下，只包含指定级别或距离上的成员。此函数与 SELF 的 «desc_flag» 值相对应。通过更改 «desc_flags» 的值，可以包含或不包含位于指定级别或距离的后代、指定级别或距离之前或之后（直到叶节点为止）的子代、以及与指定的级别或距离无关的所有叶子代。

假定 Location 维度中级别的命名为（按照层次结构顺序）CountrIEs（国家）、States（州）、CountIEs（县）和 CitIEs（城市）。

Descendants(USA)

Descendants(USA,CountIEs)

Descendants(USA,CountIEs,SELF)

Descendants(USA,BEFORE)

Descendants(USA,AFTER)

Descendants(USA,BEFORE_AND_AFTER)

Descendants(USA,SELF_BEFORE_AFTER)

Descendants(USA,States,LEAVES)

Descendants(USA,1)

Descendants(USA,SELF_BEFORE_AFTER)

返回一个集合，并从指定集合中删除重复的元组。

distinct(«Set»)

从尾部删除重复的元组。

下例返回 {(a,b),(c,d )}：

distinct({(a,d),(a,b)})

查找两个集合之间不同的项，可以选择保留重复项。

Except(«Set1», «Set2»[,ALL])

在查找不同的项之前先消除两个集合中的重复项。可选的 ALL 标志保留重复项。清除 «Set1» 中的匹配重复项并保留非匹配重复项。

示例

Except({Canada,[British Columbia],Mexico,Washington},{Canada,California})

返回

{[British Columbia],Washington}

示例

Except({Canada,California},ALL)

返回

{[British Columbia],Washington}.

返回根据搜索条件对指定集合进行筛选所得到的集合。

Filter(«Set», «Search Condition»)

Filter 函数对 Set 中指定的集合的每个成员，评估多维表达式 (MDX) 逻辑表达式（该表达式在 Search Condition 中指定），并返回满足搜索条件的成员集合。

Filter 函数的工作方式与 IIf 函数的类似。IIf 函数仅返回两个选项中的一个，返回其中哪个取决于 MDX 逻辑表达式的取值，而 Filter 函数返回满足指定搜索条件的一组成员。实际上，Filter 函数对该集合中的每个成员执行 IIf(«Search Criteria»,«Member»,NulL)，并返回所得结果。如果所有成员都不满足搜索条件，则返回空集。

如果这些城市从 1995 到 1996 级别的销售额下降，则以下示例返回 {Paris,buffalo}：

Filter(SampleSet,(Sales,[1996]) < (Sales,[1995]))

将集合应用到另一集合的每个成员，然后用 union 运算合并所得的集合。或者，返回一个在某个集合上计算字符串表达式所得的值创建的串联字符串。

Generate(«Set1»,«Set2»[,ALL])

Generate(«Set», «String Expression»[,«Delimiter»])

此函数的集合版本将 «Set2» 应用于 «Set1» 的每个成员，然后用 union 运算合并所得的集合。如果指定了 ALL，结果中将保留重复项。

此函数的字符串版本迭代于 «Set» 中指定的集合的每个成员，对成员计算字符串表达式（在 «String Expression» 中指定）的值，然后将结果串联成返回字符串。或者，可以用 «Delimiter» 提供字符串表达式（即用分隔符来分隔串联返回字符串中的每个结果），从而对字符串进行分隔。

Generate({USA,France},Descendants(Geography.CurrentMember,CitIEs))

此函数对集合 {USA,France} 中的每个成员应用表达式 Descendants(Geography.CurrentMember,CitIEs)。每应用于一个成员便产生一个集合。（应用于 USA 将生成美国 (USA) 所有城市的集合；应用于 France 将生成法国 (France) 所有城市的集合。）这些集合通过 union 运算合并以返回此函数的结果。本例中，美国和法国的所有城市就是结果。通常，Generate(«Set1»,«set_Expression») 将把 «set_Expression» 应用于 «Set1» 的每个成员，然后用 union 运算合并所得的结果。

如果通过 CurrentMember，«Set1» 与 «set_Expression» 无关，那么 Generate 生成 «set_Expression» 所指的集合的简单复制，它包含的复制与 «Set1» 中的元组一样多。如果指定了可选的 ALL 标志，结果中将保留所有重复项。如果未指定 ALL，重复项将被删除。例如：

Generate({USA,FRANCE},{SEATTLE,BOSTON},ALL)

返回集合

{SEATTLE,BOSTON,SEATTLE,BOSTON}.

但如果未指定 ALL，那么返回的集合是

{SEATTLE,BOSTON}.

以下示例返回字符串 "19971998"：

Generate( {Time.[1997],Time.[1998]},Time.CurrentMember.name)

以下示例返回字符串 "1997 and 1998"：

Generate( {Time.[1997],Time.CurrentMember.name," and ")

返回集合中指定数目的前若干个元素。

head(«Set»[, «Numeric Expression»])

此函数返回集合中前 «Numeric Expression» 个元素。保留元素的顺序。«Numeric Expression» 的默认值是 1。如果 «Numeric Expression» 小于 1，则返回空集合。如果 «Numeric Expression» 超出了集合中元组的个数，则返回原始的集合。

以下示例返回集合 {USA,Canada,France}：

head({USA,France,Germany,Japan},3)

在层次结构中对集合的成员排序。

HIErarchize(«Set»[,POST])

此函数在层次结构中对 «Set» 的成员排序。除非使用 POST 关键字，否则当未指定其它排序条件时，级别中的成员按其自然顺序排序，这是维度上的成员的默认排序顺序。POST 关键字使用后采用后序排序，即以后序方式遍历层级树。

HIErarchize 始终保留重复项。

示例

HIErarchize(SampleSet)

按自然顺序返回集合。按层次结构排列的数据集如下所示（假定数据源的自然顺序是按字母排列）：

返回两个输入集合的交集，可以选择保留重复项。

Intersect(«Set1»,ALL])

此函数返回 «Set1» 和 «Set2» 的交集。根据默认设置，在相交之前先删除两个集合中的重复项。

可选的 ALL 保留重复项。ALL 有几种工作方式。算法是：不重复的元素照常相交。对于 «Set1» 中的每个重复项，将其与 «Set2» 中的重复项相匹配，如果存在匹配的项，则在交集中保留匹配的重复项。

示例

Intersect({[1994],[1995],[1996]},{[1995],[1996],[1997]})

返回集合 {[1995],[1996]}。

返回维度、级别或层次结构中成员的集合。

«Dimension».Members

此语法返回 «Dimension» 中所有成员的集合。

«HIErarchy».Members

此语法返回 «HIErarchy» 中所有成员的集合。

«Level».Members

该语法返回维度中指定级别上所有成员的集合。

示例

Geography.Members

返回 Geography 维度中所有成员的集合。

示例

Time.Quarterly.Members

返回 Time 维度的 Quarters 层次结构中所有成员的集合。

如果 Year 级别包含 [1994]、[1995] 和 [1996]，则该示例返回集合 {[1994],[1996]}：

Year.Members

返回 Time 维度 Month 级别上的成员集合，从第一个时期开始到指定的成员为止。

Mtd([«Member»])

Mtd 函数是 PeriodsToDate 函数的快捷函数，它将函数的 «Level» 参数定义为 Month。如果未指定成员，则根据默认设置是 Time.CurrentMember。

Mtd(«Member») 等同于 PeriodsToDate(Month,«Member»)。

下例将返回 1997 年 9 月的头五天。

MTD([05-Sep-1997])

以一个集合的形式返回两个或多个集合的矢量积，不包括空元组以及无相关事实数据表数据的元组。

NonEmptyCrossjoin(«Set1»,«Set3»...][, «Crossjoin Set Count»])

NonEmptyCrossjoin 函数以一个集合的形式返回两个或多个集合的矢量积，不包括空元组或无基础事实数据表提供的数据的元组，因此所有计算成员均被自动排除。如果未指定 Crossjoin Set Count，则所有指定的集合将交叉联接，而且从所得集合中排除空成员。如果已指定 «Crossjoin Set Count»，则交叉联接以 «Set1» 开头的 «Crossjoin Set Count»。剩余集合用于确定在所得交叉联接集合中哪些成员是非空的。

例如，您要查看参加 Big Time Savings 促销的 Beverly Hills 每个商店的单位总销售额，但仅想查看位于 California 的那些客户的总销售额。但是，下列多维表达式 (MDX) 语法返回一个集合，该集合包含在 California 所有城市的单位总销售额，是按 Beverly Hills 的商店对客户进行分组的，而且都参加了 Big Time Savings 促销；该集合是三个集合的矢量积。所返回的单位销售额仅是三个集合的矢量积；未返回参加 Big Time Savings 促销的 Beverly Hills 的商店的总销售额，而仅是参加促销本身的每个商店或客户城市的各个单位销售额。

NonEmptyCrossJoin([Store].[Beverly Hills].Children,[Customers].[CA].Children,{[Promotions].[Big Time Savings]})

上面的示例范围太窄，无法完成任务。相反，下列 MDX 语句仅交叉联接前两个集合，而且从返回的集合中删除了非空成员。因为未使用 {[Promotions].[Big Time Savings]}，所以下一 MDX 语句范围太宽；MDX 语句包含太多元组，无法完成目标。

NonEmptyCrossJoin([Store].[Beverly Hills].Children,[Customers].[CA].Children)

下列 MDX 语句使用 Crossjoin Set Count 参数返回一个集合，该集合包含 California 所有城市的单位销售额，而且按 Beverly Hills 的商店对客户进行分组；该集合是前两个集合的矢量积。但是，只返回了参加 Big Time Savings 促销的交叉联接集合中的那些成员，所以完成了任务。在 Crossjoin Set Count 参数中指定的前两个集合交叉联接，而第三个集合用于在确定交叉联接集合成员是否包含数据时确定应考虑交叉联接集合的哪些成员。

NonEmptyCrossJoin([Store].[Beverly Hills].Children,{[Promotions].[Big Time Savings]},2)

NonEmptyCrossjoin 函数的好处是处理涉及两个以上集合的交叉联接时更快、更有效，而且函数所提供的语法更简单。使用下列 MDX 语句中所示的 Filter、Crossjoin 和 IsEmpty 函数也可获得相同结果，但效率较低：

Filter(Crossjoin([Store].[Beverly Hills].Children,[Customers].[CA].Children),NOT IsEmpty([Promotions].[Big Time Savings])

当添加其它集合时，使用 Filter、Crossjoin 和 IsEmpty 就变得不太实际，因为每个 Crossjoin 语句嵌套在另一个 Crossjoin 语句中才能返回相同结果。例如，使用 NonEmptyCrossjoin 将 [Product].Children 集合添加到返回的集合中类似于：

NonEmptyCrossJoin([Store].[Beverly Hills].Children,[Product].Children,3)

在另一方面，使用 Filter、Crossjoin 和 IsEmpty 函数执行相同功能与下列类似：

Filter(Crossjoin(Crossjoin([Store].[Beverly Hills].Children,[Product].Children),NOT IsEmpty([Promotions].[Big Time Savings]))

前一 MDX 语句在执行时比较慢，而且易读性比其基于 NonEmptyCrossjoin 的对应语句要差。

下列语句返回一个集合，该集合包含 California 所有城市的全部单位销售额，而且按参加 Big Time Savings 促销的 Beverly Hills 的商店对客户进行分组：

NonEmptyCrossJoin([Store].[Beverly Hills].Children,2)

排列指定集合的成员，可以选择保留或打破层次结构。

Order(«Set»,{«String Expression» | «Numeric Expression»}
[,ASC | DESC | BASC | BDESC])

Order 有两种变化形式：按层次结构排列（ASC 或 DESC）和不按层次结构排列（BASC 或 BDESC，其中 B 代表打破层次结构）。按层次结构排列的排序首先按成员在层次结构中的位置对其进行排序，然后再对每个级别进行排序。而不按层次结构排列的排序在对集合中的成员排序时不考虑层次结构。如果没有明确说明，则根据默认设置使用 ASC。

示例

Order(SampleSet,Sales),DESC)

按层次结构排列所有成员然后按 Sales 排序每个级别。在构造排序后的列表时，比较最高级别上的 Sales。因此，如果 California 的所有城市的 Sales 合计低于 New York 的所有城市的 Sales 合计，在按降序排列的列表中，California 和 California.LA 将排在 NYC 的下面。

该示例的结果

Order(SampleSet,DESC)

在下表中列出。

下面的表达式在按成员的值排序成员时不考虑它们在成员层次结构中的相对位置。在本例中，按每个城市的 1995 年销售数据排序数值，包括按州和国家/地区计算的累积销售数据：

Order(SampleSet,BDESC)

下表显示上一个表达式的结果。

说明  如果输入的集合中有两个元素，这两个元素的 «String Expression» 或 «Numeric Expression» 有相同的值，则保留输入顺序。

例如，如果 USA 和 Europe 的销售额各为 300，而 Asia 的销售额为 100，则以下表达式返回的是集合 {Asia,Europe}，而不是集合 {Asia,Europe,USA}：

Order({USA,Asia},Sales,BASC)

返回指定级别上的一个时期（成员）集合，从第一个时期开始到指定的成员为止。

PeriodsToDate([«Level»[,«Member»]])

在 «Level» 作用域内，此函数返回处于 «Member» 级别上的时期的集合，该集合以第一个时期开始，以 «Member» 结束。如果没有指定级别或成员，则 «Member» 的值就为 Time.CurrentMember，并且 «Level» 为 Time.CurrentMember 的父代级别。如果指定了级别，则 «Member» 为 dimension.CurrentMember，其中的 dimension 是 «Level» 的维度。

下表列出可以使用 PeriodsToDate 的各种方法。

PeriodsToDate(Quarter,

[05-Sep-1997])

PeriodsToDate(Year,march) 

PeriodsToDate(Year)

PeriodsToDate()

PeriodsToDate(level,member) 与 topCount(Descendants(Ancestor(member,level),member.Level),1):member 相同

返回 Time 维度 Quarter 级别上的成员集合，从第一个时期开始到指定的成员为止。

Qtd([«Member»])

PeriodsToDate 函数的这个快捷函数将 PeriodsToDate 函数的 «Level» 参数预定义为 Quarter。如果未指定成员，则根据默认设置是 Time.CurrentMember。

Qtd(«Member») 等同于 PeriodsToDate(Quarter,«Member»)。

下例将返回从 1997 年第三季度开始的天数的集合：

Qtd([05-Sep-1997]))

返回指定成员的兄弟，包括成员本身。

«Member».Siblings

下例返回集合 { January,march }：

[Time].[All Time].[1998].[Quarter 1].[January].Siblings

从指定集合中返回元组的子集。

Subset(«Set», «Start»[,«Count»])

此函数从 «Set» 中返回 «Count» 元组，并作为一个集合，该集合从 «Start» 位置开始。«Start» 是以零为基：0 对应于集合中的第一个元组，1 对应于第二个元组，依此类推。如果没有指定 «Count»，则返回从集合 «Start» 开始到集合末尾的所有元组。

下例返回集合 {USA,Canada}：

Subset({USA,Japan,England,Peru},2)

从集合尾部返回子集。

Tail(«Set»[, «Count»])

此函数返回集合中后面 «Count» 个元素。保留元素的顺序。«Count» 的默认值为 1。如果 «Count» 小于 1，则返回空集合。如果 «Count» 超出了集合中元组的个数，则返回原始的集合。

以下代码返回集合 {France,Japan}：

Tail({USA,3)

从指定集合的顶端成员开始，返回指定数目的项目，可以选择首先对集合排序。

topCount(«Set», «Count»[,«Numeric Expression»])

此函数根据 «Numeric Expression» 的值对集合进行排序，然后返回顶端 «Count» 成员，其中的 «Count» 是一个数值表达式。

重要  与 BottomCount 函数相似，此函数总是打破层次结构。

topcount(Geography.CitIEs.Members,Sales)

对集合排序并返回最顶端的元素，这些元素的累积合计至少为指定的百分比。

topPercent(«Set»,«Numeric Expression»)

此函数使用 «Numeric Expression» 对集合进行排序，并返回其 «Numeric Expression» 的累积合计至少为 «Percentage» 的顶端 n 个元素。«Percentage» 是一个数值表达式。

重要  与 BottomPercent 函数相似，此函数总是打破层次结构。

topPercent({London,Paris,Rome,New York,Seattle,Tokyo},15,Sales)

对集合排序并返回最顶端的元素，这些元素的累积合计至少为指定的值。

topSum(«Set», «Value»,«Numeric Expression»)

此函数在 «Numeric Expression» 上排序并挑选顶端的 n（可能的最小数）个元素，这些元素的累积合计至少是 «Value»。

重要  与 BottomSum 函数相似，此函数总是打破层次结构。

topsum(Products.[Product Description].Members,Quantity)

返回对两个集合进行 union 运算所生成的集合，可以保留重复的成员。

Union(«Set1»,ALL])

此函数返回 «Set1» 和 «Set2» 的 union 运算结果，并在默认情况下消除重复项。ALL 标志表示在并集中保留重复项。从尾部删除重复项。

Union(USA.Children,CANADA.Children,ALL)

返回 Time 维度 Week 级别上的成员集合，从第一个时期开始到指定的成员为止。

Wtd([«Member»])

Wtd 函数是 PeriodsToDate 函数的快捷函数，它将 PeriodsToDate 函数的 «Level» 参数定义为 Week。如果未指定成员，则默认为 Time.CurrentMember。

Wtd(«Member») 等同于 PeriodsToDate(Week,«Member»)。

下面的示例将返回从一周的开始到当前日的天数：

Wtd(Day)

返回 Time 维度 Year 级别上的成员集合，从第一个时期开始到指定的成员为止。

Ytd([«Member»])

Ytd 函数是 PeriodsToDate 函数的快捷函数，它将 PeriodsToDate 函数的 «Level» 参数定义为 Year。如果未指定成员，则根据默认设置是 Time.CurrentMember。

Ytd(«Member») 等同于 PeriodsToDate(Year,«Member»)。

下例将返回从 Time.CurrentMember 祖先的起始年到 Time.CurrentMember 的成员集合：

Ytd()

    返回处于成员对之间的成员集合.

<Member>:<Member>

    两个Member所属的Level必须相同.

下例将返回从 Time.[2000].[1]到Time.[2000].[5]之间的成员集合.

    Time.[2000].[1]: Time.[2000].[5]

如果表达式的值为空单元值，则返回 TRUE，否则返回 FALSE。

IsEmpty(«Value Expression»)

如果 Measures.CurrentMember 是空单元，则以下示例返回 TRUE：

IsEmpty(Measures.CurrentMember)

   逻辑与.

<Logical Expression> AND <Logical Expression>

逻辑或.

<Logical Expression> OR <Logical Expression>

逻辑非.

<Logical Expression> OR <Logical Expression>

逻辑异或.

<Logical Expression> XOR <Logical Expression>

    比较大小.两个版本:

    <Numeric Expression> > <Numeric Expression>

    <String> > <String>

    比较大小.两个版本:

    <Numeric Expression> >= <Numeric Expression>

    <String> >= <String>

    比较大小.两个版本:

    <Numeric Expression> < <Numeric Expression>

    <String> < <String>

    比较大小.两个版本:

    <Numeric Expression> <= <Numeric Expression>

    <String> <= <String>

    比较大小.两个版本:

    <Numeric Expression> <> <Numeric Expression>

    <String> <> <String>

比较大小.两个版本:

    <Numeric Expression> = <Numeric Expression>

    <String> = <String>

返回根据成员的聚合类型，用适当的聚合函数计算所得的值。

Aggregate(«Set»[,«Numeric Expression»])

在下面的表达式中，先用度量值 SumSales 显示计算成员 Total，然后再用度量值 MaxSales 显示计算成员 Total。在前一种情况下，Total 是通过加法（使用 Sum）计算得到的。在后一种情况下，Total 是通过取最大值计算得到的。

WITH MEMBER Geography.Total AS  'AGGREGATE({USA,France})'

SELECT {Measures.SumSales,Measures.MaxSales} ON ColUMNS,

      {USA,Total} ON ROWS

FROM SalesCube

WHERE ([1998])

返回在某一集合上对数值表达式求得的平均值。

Avg(«Set»[, «Numeric Expression»])

此函数需要单元数的隐性计数，不包含空单元。若要强制包含空单元，应用程序必须使用 CoalesceEmpty 函数。

如果 Sales 分别为 1000、2000 和 3000，则下面的函数返回 2000：

Avg({USA,Mexico},Sales)

将空单元值合并为数字或字符串并返回合并后的值。

CoalesceEmpty(«Numeric Expression»[,«Numeric Expression»]...)

CoalesceEmpty(«String Expression»[,«String Expression»]...)

此函数返回值表达式列表中的第一个（左侧）非空的值表达式。如果所有的值表达式都取值为空单元值，则返回空单元值。

所有值表达式都必须取值为数值数据类型或空单元值。或者，所有值表达式都必须取值为字符串数据类型或空单元值。

如果 Measures.CurrentMember 是空单元值，则下例返回 -99，否则返回 Measures.CurrentMember：

CoalesceEmpty(Measures.CurrentMember,-99)

下例在 Time.Parent.name 是空单元值时，返回字符串 "EMPTY"，否则返回 Time.Parent.name：

CoalesceEmpty(Time.Parent.name,"EMPTY")

返回集合中项目的数量（具体数目取决于集合）。

Dimensions.Count

返回多维数据集中的维度数，其中包括 [Measures] 维度。

«Dimension»|«HIErarchy».Levels.Count

返回维度或层次结构中的级别数，包括 [All] 级别（如果适用）。

Count(«Set»[, ExcludeEmpty | IncludeEmpty])

返回集合中的单元数。该语法允许分别使用 ExcludeEmpty 或 IncludeEmpty 标志来排除或包含空单元。

«Set».Count

返回集合中的单元数，其中包括空单元。

若要从集合计数中排除空单元，请使用可选的 ExcludeEmpty 关键字。

如果 Time 包含级别 Year 和 Month，Year 的成员是 1994 和 1995，那么下面的示例返回 24：

Count({Time.Month.Members})

Time.Month.Members.Count

返回由逻辑测试确定的两个数值或字符串值之一。

IIf(«Logical Expression»,«Numeric Expression1»,«Numeric Expression2»)

如果 «Logical Expression» 取值为 TRUE，则此函数返回 «Numeric Expression1»，否则，返回 «Numeric Expression2»。

IIf(«Logical Expression»,«String Expression1»,«String Expression2»)

如果 «Logical Expression» 取值为 TRUE，则此函数返回 «String Expression1»，否则，返回 «String Expression2»。

只有当 «Logical Expression» 的值为零时，才认为该表达式是 FALSE。任何其它值都被解释为 TRUE。

不推荐用 Iif 函数基于搜索条件创建成员的集合。请改用 Filter 函数根据逻辑表达式评估指定集合中的每个成员，然后返回成员的子集合。

如果 Measures.CurrentMember 是空单元，则下面的示例返回 0，否则返回 1：

IIf(IsEmpty(Measures.CurrentMember),1)

如果 Measures.CurrentMember 是空单元，则下面的字符串返回字符串 "Yes"，否则返回字符串 "No"：

IIf(IsEmpty(Measures.CurrentMember),"No")

返回在某一集合上对数值表达式求得的最大值。

Max(«Set»[, «Numeric Expression»])

Max 函数返回数值表达式的最大值，该表达式在 «Numeric Expression» 中指定，对在 «Set» 中指定的集合进行求值。

如果国家/地区的 Sales 分别是 1000、2000 和 3000，则返回 3000：

Max({USA,CANADA,MEXICO},Sales)

返回在某一集合上对数值表达式求得的中值。

Median(«Set»[, «Numeric Expression»])

Median 函数返回数值表达式的中值，该表达式在 «Numeric Expression» 中指定，对在 «Set» 中指定的集合进行求值。

如果国家/地区的 Sales 分别是 1000、2000 和 3000，则下例返回 2000：

Median({USA,Sales)

返回在某一集合上对数值表达式求得的最小值。

Min(«Set»[, «Numeric Expression»])

Min 函数返回数值表达式的最小值，该表达式在 «Numeric Expression» 中指定，对在 «Set» 中指定的集合进行求值。

如果国家/地区的 Sales 分别是 1000、2000 和 3000，则返回 1000：

Min({USA,Sales)

返回在某一集合上对数值表达式求得的和。

Sum(«Set»[, «Numeric Expression»])

如果 USA、CANADA 和 MEXICO 成员的值分别为 1000、2000 和 3000，则以下示例返回 6000：

Sum({USA,Sales.VALUE)

以下示例更加直观，并且同样有效：

Sum({USA,Sales)

返回度量值的值。

«Member».Value

Value 函数返回在 «Member» 中指定的度量值的值。它是度量值的默认属性。

Sales.Measures.CurrentMember.Value

    顾名思义,数字相加.

    顾名思义,数字相减.

    顾名思义,数字相乘.

    顾名思义,数字相除.

参考集合函数中Generate的描述.

返回由逻辑测试确定的两个数值或字符串值之一。

参考数值函数中IIF的描述.

返回级别、维度、成员或层次结构的名称。

«Dimension».name

«Level».name

«Member».name

«HIErarchy».name

name 函数返回对象名称，但不是唯一名称。

Products.name

Products.[Product Description].name

Products.[Product Description].Widgets.name

Time.[Fiscal Year].name

    类似于name

返回指定级别、维度、成员或层次结构的唯一名称。

«Dimension».Uniquename

«Level».Uniquename

«Member».Uniquename

«HIErarchy».Uniquename

Uniquename 函数返回对象的唯一名称，而不是其它名称。

Products.Uniquename

Products.[Product Description].Uniquename

Products.[Product Description].Widgets.Uniquename

Time.[Fiscal Year].Uniquename

返回包含成员属性值的字符串。

«Member».PropertIEs(«String Expression»)

PropertIEs 函数返回在 «String Expression» 中指定的成员属性的值。成员属性可以是任何标准的成员属性，如 name、ID、KEY 或 CAPTION，它也可以是用户定义的成员属性。

在 Store 维度中，如果 Store name 级别有一个相关的成员属性 Store Manager，则下例返回 Smith：

[Store].[All Stores].[USA].[WA].[Bellingham].[Store 2].PropertIEs("Store Manager")

Format(<Numeric Expression>,<Format String Expression>)

<Format String Expression>与度量值的FormatString类似,采用采用java.util.DecimalFormater格式串.

4.8.10 ||

       将两个字符串相连接.

<String Expression> || <String Expression>

       这些例子相对来说比较复杂,使用了计算成员,主要演示了常用的分析功能.

函数：CurrentMember、Parent等；
分析各城市的销售所占全部城市的总销售额百分比。
 

WITH MEMBER Measures.[Unit Sales Percent] AS '((Store.CURRENTMEMBER,Measures.[Unit Sales]) / (Store.CURRENTMEMBER.PARENT,Measures.[Unit Sales])) ',FORMAT_STRING = '0.00%'
 

SELECT

{Measures.[Unit Sales],Measures.[Unit Sales Percent]} ON ColUMNS,
  

ORDER(DESCENDANTS(Store.[USA].[CA],Store.[Store City],SELF),[Measures].[Unit Sales],ASC) ON ROWS
 

FROM Sales

函数：Count、Sum、Filter、Descendants等；
分析各个省份中重要顾客的数量及他们的总购买量，"重要顾客"的定义是一个顾客的购买金额或者购买数目达到或超过一定的数值。

WITH

MEMBER [Measures].[QualifIEd Count] AS               

‘COUNT(FILTER(DESCENDANTS(Customers.CURRENTMEMBER,[Customers].[name]),([Measures].[Store Sales]) > 10000 OR ([Measures].[Unit Sales]) > 10))'  

MEMBER [Measures].[QualifIEd Sales] AS 'SUM(FILTER(DESCENDANTS(Customers.CURRENTMEMBER,([Measures].[Store Sales]) > 10000 OR ([Measures].[Unit Sales]) > 10),([Measures].[Store Sales]))'

SELECT

{[Measures].[QualifIEd Count],[Measures].[QualifIEd Sales]} ON ColUMNS,

DESCENDANTS([Customers].[All Customers],[State Province],SELF_AND_BEFORE) ON ROWS

FROM Sales

函数：Order
对各个产品类别按照Store Sales指标降序排列，排序分为维内排序/整体排序。
select {[Measures].[Unit Sales],[Measures].[Store Sales]} on columns,

Order([Product].[Product Department].members,[Measures].[Store Sales],DESC) on rows
 from Sales
 

函数：YTD、Sum、Descendants
求销售额的本年累计值YTD()，类似还可以求解历史累计YTD()、本月累计MTD()、本周累计WTD()等,以及更通用的函数PeriodToDate()。
with

member [Measures].[Accumulated Sales] as 'Sum(YTD(),[Measures].[Store Sales])' 

select    {[Measures].[Store Sales],[Measures].[Accumulated Sales]} on columns,

{Descendants([Time].[1997],[Time].[Month])} on rows

from [Warehouse and Sales]
 

函数：四则运算函数；
在成员上及指标上均可以进行四则运算，动态派生出新的成员及指标。
 WITH MEMBER MEASURES.ProfitPercent AS '([Measures].[Store Sales]-[Measures].[Store Cost])/([Measures].[Store Cost])',FORMAT_STRING = '#.00%'
 MEMBER [Time].[First Half 97] AS  '[Time].[1997].[Q1] + [Time].[1997].[Q2]'
 MEMBER [Time].[Second Half 97] AS '[Time].[1997].[Q3] + [Time].[1997].[Q4]'
 SELECT {[Time].[First Half 97],[Time].[Second Half 97],[Time].[1997].CHILDREN} ON ColUMNS,
 {[Store].[Store Country].[USA].CHILDREN} ON ROWS
 FROM [Sales]
 WHERE (MEASURES.ProfitPercent)
 

函数：IIf
逻辑判断可以根据不同的条件产生不同的结果。下例判断各商店是否是啤酒及白酒的大卖家。
 WITH MEMBER [Product].[BigSeller] AS 'IIf([Product].[Drink].[Alcoholic Beverages].[Beer and Wine] > 100,"No")'
 SELECT {[Product].[BigSeller],[Product].children} ON ColUMNS,
 {[Store].[All Stores].[USA].[CA].children} ON ROWS
 FROM Sales
 

函数：PropertIEs、
成员属性是与成员绑定的，其对应关系导致很难选择合适的使用方式。以下是使用成员属性的例子，它对应每个商店成员列出了商店类型属性，相应的，商店经理、商店规模、商店地址等属性也可以被列出。该用法稍加灵活应用就可以解决过去遇到的企业名称——〉企业代码对应展示问题。
 
WITH MEMBER [Measures].[StoreType] AS '[Store].CurrentMember.PropertIEs("Store Type")',
MEMBER [Measures].[ProfitPct] AS '(Measures.[Store Sales] - Measures.[Store Cost]) / Measures.[Store Sales]',FORMAT_STRING = '##.00%'
 SELECT { Descendants([Store].[USA],[Store].[Store name])} ON ColUMNS,
 {[Measures].[Store Sales],[Measures].[ProfitPct] } ON ROWS"
 FROM Sales
 

函数：其实可以是任意函数合乎逻辑的组合
求出从来没有买过乳制品的顾客，求解过程是先求出每位顾客在过去购买的乳制品的数量累计，然后找出累计值为0的顾客。同样，过去遇到的求税额大于平均税额的海关的问题可以类似求出。
 
with member [Measures].[Dairy ever] as 'sum([Time].members,([Measures].[Unit Sales],[Product].[Food].[Dairy]))'
 set [Customers who never bought dairy] as 'filter([Customers].members,[Measures].[Dairy ever] = 0)'
 select {[Measures].[Unit Sales],[Measures].[Dairy ever]}  on columns,
 [Customers who never bought dairy] on rows
 from Sales
  

函数：PrevMember、ParellelPeriod
求解各产品销售额的去年同期值，年增长率。
with member [Measures].[Store Sales Last Period] as '([Measures].[Store Sales],Time.PrevMember)',format_string='#,###.00'
 member [Measures].[Yearly Increase Rate] as ‘([Measures].[Store Sales] - [Measures].[Store Sales Last Period])/ [Measures].[Store Sales Last Period]',FORMAT_STRING = '0.00%'
 select {[Measures].[Store Sales],[Measures].[Store Sales Last Period]} on columns,
 { [Product].members} on rows
 from Sales
 where ([Time].[1998])
 
另一个例子，使用ParellelPeriod函数。
 WITH MEMBER [Measures].[YTD Unit Sales] AS 'COALESCEEMPTY(SUM(YTD(),[Measures].[Unit Sales]),0)' MEMBER [Measures].[PrevIoUs YTD Unit Sales] AS  '(Measures.[YTD Unit Sales],ParaLLELPERIOD([Time].[Year]))'
 MEMBER [Measures].[YTD Growth] AS '[Measures].[YTD Unit Sales] - ([Measures].[PrevIoUs YTD Unit Sales])'
 SELECT {[Time].[1998]} ON ColUMNS,
 {[Measures].[YTD Unit Sales],[Measures].[PrevIoUs YTD Unit Sales],[Measures].[YTD Growth]} ON ROWS
 FROM Sales;
 

函数：topCount
求解1998年总购买量处于前5名的顾客；
select {[Measures].[Store Sales]} on columns,
{topCount([Customers].[Customer name].members,[Measures].[Store Sales])} on rows
from Sales
where ([time].[1998])
 

函数：Filter、Except
求解1998年所有顾客中购买总额得到1万元以上的顾客，列出满足条件的顾客的名字、年购买数量、年购买金额。
Select {[measures].[Store Sales],[measures].[unit sales]} on columns,
FILTER(Customers.[name].Members,[Measures].[Store Sales] > 10000) on rows
From sales
Whare ([time].[1998])
另外一种成员过滤（从所有的媒体类型中剔除No Media类型），确切的说应该是集合运算。
select {[Measures].[Unit Sales]} on columns,
except([Promotion Media].[Media Type].members,{[Promotion Media].[Media Type].[No Media]}) on rows
from Sales

函数：sum、"："运算符 求美国的商店在指定时间段内的销售额。 WITH  MEMBER [Time].[1997].[Six Month] AS 'SUM([Time].[1]:[Time].[6])' MEMBER [Time].[1997].[Nine Month] AS 'SUM([Time].[1]:[Time].[9])' SELECT {[Time].[1997].[Six Month],[Time].[1997].[Nine Month]} ON ColUMNS,{[measures].[store salse]} ON ROWS FROM Sales Where ([Store].[USA])

以上是内存溢出为你收集整理的MDX用户指南全部内容，希望文章能够帮你解决MDX用户指南所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。