本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。 # 添加计算 使用以下一项或多项创建计算字段以转换数据： + [运算符](arithmetic-and-comparison-operators.md) + [函数](functions.md) + 包含数据的字段 + 其他计算字段 您可以在数据准备期间或从分析页面中向数据集添加计算字段。如果在数据准备期间将计算字段添加到数据集中，则可以在使用该数据集的所有分析中使用该字段。在将一个计算字段添加到分析中的数据集时，只能在此分析中使用该字段。有关添加计算字段的更多信息，请参阅以下主题。 **Topics** + [ # 添加计算字段 ](adding-a-calculated-field-analysis.md) + [ # Amazon Quick Sight 中的评估顺序 ](order-of-evaluation-quicksight.md) + [ # 在 Quick Sight 中使用关卡感知计算 ](level-aware-calculations.md) + [ # Amazon Quick 的计算字段函数和运算符参考 ](calculated-field-reference.md) # 添加计算字段 使用以下一项或多项创建计算字段以转换数据： + [运算符](arithmetic-and-comparison-operators.md) + [函数](functions.md) + 聚合函数（只能将这些函数添加到分析中） + 包含数据的字段 + 其他计算字段 您可以在数据准备期间或从分析页面中向数据集添加计算字段。如果在数据准备期间将计算字段添加到数据集中，则可以在使用该数据集的所有分析中使用该字段。在将一个计算字段添加到分析中的数据集时，只能在此分析中使用该字段。 分析同时支持单行操作和聚合操作。单行操作是指为每行提供 (可能) 不同的结果的操作。聚合操作提供的结果始终与整个行集相同。例如，如果您使用不带任何条件的简单字符串函数，它将更改每一行。如果您使用聚合函数，该规则将应用于组中的所有行。如果要查询美国的总销售额，则相同的数量应用于整个集合。如果需要特定状态的数据，则总销售额会反映新分组。它仍将为整个集合提供一个结果。 通过在分析内创建聚合的计算字段，您可以深入了解数据。在每个级别相应地重新计算聚合字段的值。数据集准备期间不能有这种类型的聚合。 例如，假设您要计算每个国家/地区、区域和州/省的利润百分比。您可以在分析中添加计算字段，`(sum(salesAmount - cost)) / sum(salesAmount)`。随后，在分析师深入到地理位置时，将计算每个国家/地区、区域和州/省的该字段。 **Topics** + [ ## 将计算字段添加到分析 ](#using-the-calculated-field-editor-analysis) + [ ## 将计算字段添加到数据集 ](#using-the-calculated-field-editor) + [ ## 处理计算字段中的十进制值 ](#handling-decimal-fields) ## 将计算字段添加到分析 当您将数据集添加到分析中时，数据集中存在的每个计算字段都会添加到分析中。您可以在分析级别添加其他计算字段，以创建仅在该分析中可用的计算字段。 **将计算字段添加到分析** 1. 打开 [Quick 控制台](https://quicksight.aws.amazon.com/)。 1. 打开要更改的分析。 1. 在**数据**窗格中，选择左上角的**添加**，然后选择 **\$1 计算字段**。 1. 在打开的计算编辑器中，执行以下操作： 1. 为计算字段输入名称。 1. 使用数据集、函数和运算符中的字段输入公式。 1. 完成后，选择**保存**。 有关如何使用 Quick Sight 中的可用函数创建公式的更多信息，请参阅[Amazon Quick 的计算字段函数和运算符参考函数和运算符](calculated-field-reference.md)。 ## 将计算字段添加到数据集 Amazon Quick Sight 作者可以在数据集创建的数据准备阶段生成计算字段。当您为数据集创建计算字段时，该字段将成为数据集中的新列。所有使用该数据集的分析都会继承该数据集的计算字段。 如果计算字段在行级别运行，并且数据集存储在行级别SPICE，则 Quick Sight 会在中计算并具体化结果。SPICE如果计算字段依赖于聚合函数，Quick Sight 会保留公式并在生成分析时执行计算。此类计算字段称为非具体化计算字段。 **为数据集添加或编辑计算字段** 1. 打开您希望使用的数据集。有关更多信息，请参阅 [编辑数据集](edit-a-data-set.md)。 1. 在“数据准备”页面上，执行以下操作： + 要创建新字段，请选择左侧的**添加计算字段**。 + 要编辑现有的计算字段，请从左侧的**计算字段**中选择该字段，然后从上下文（右键单击）菜单中选择**编辑**。 1. 在计算编辑器中，为**添加标题**输入描述性名称来命名新的计算字段。此名称出现在数据集的字段列表中，因此应与其他字段相似。在本示例中，我们将字段命名为 `Total Sales This Year`。 1. （可选）添加注释，例如用斜杠和星号将文本括起来，以说明表达式的作用。 ``` /* Calculates sales per year for this year*/ ``` 1. 确定要使用的指标、函数和其他项目。在本示例中，我们需要确定以下内容： + 要使用的指标 + 函数：`ifelse` 和 `datediff` 我们想构建一个语句，类似于“如果销售发生在今年，则显示总销售额，否则显示 0。” 要添加 `ifelse` 函数，请打开**函数**列表。选择**全部**以关闭所有函数的列表。现在，您应该会看到函数组：**聚合**、**条件**、**日期**等。 选择**条件**，然后双击 `ifelse` 将其添加到工作区。 ``` ifelse() ``` 1. 将光标放在工作区的括号内，然后添加三个空白行。 ``` ifelse( ) ``` 1. 将光标放在第一个空白行上，找到 `dateDiff` 函数。它列在**日期**下的**函数**中。您也可以通过输入 **date** 使用**搜索功能**查找。`dateDiff` 函数返回名称中包含 *`date`* 的所有函数。它不会返回**日期**下列出的所有函数；例如，搜索结果中缺少 `now` 函数。 双击 `dateDiff` 将其添加到 `ifelse` 语句的第一个空白行。 ``` ifelse( dateDiff() ) ``` 添加 `dateDiff` 使用的参数。将光标放在 `dateDiff` 括号内以开始添加 `date1`、`date2` 和 `period`： 1. 对于 `date1`：第一个参数是包含日期的字段。在**字段**下找到它，然后双击它或输入其名称将其添加到工作区。 1. 对于 `date2`，添加逗号，然后选择 `truncDate()` 作为**函数**。在括号内添加周期和日期，如下所示：**truncDate( "YYYY", now() )** 1. 对于 `period`：在 `date2` 后面添加逗号并输入 **YYYY**。这是一年的周期。要查看所有支持的周期列表，在**函数**列表中找到 `dateDiff`，然后选择**了解更多**以打开文档。如果您已经像现在一样查看文档，请参阅 [dateDiff](dateDiff-function.md)。 如果您愿意，可以添加一些空格以提高可读性。表达式应如下所示。 ``` ifelse( dateDiff( {Date}, truncDate( "YYYY", now() ) ,"YYYY" ) ) ``` 1. 指定返回值。在我们的示例中，`ifelse` 中的第一个参数需要返回 `TRUE` 或 `FALSE` 的值。因为我们想要当前年份，并且将其与今年进行比较，所以指定 `dateDiff` 语句应返回 `0`。对于销售年份和当前年份之间没有区别的行，`ifelse` 的 `if` 部分评估为 true。 ``` dateDiff( {Date}, truncDate( "YYYY", now() ) ,"YYYY" ) = 0 ``` 要为去年 `TotalSales` 创建字段，可以将 `0` 更改为 `1`。 使用 `addDateTime` 而不是 `truncDate`，也能达到同样的目的。然后，对于之前的每一年，更改 `addDateTime` 的第一个参数来代表每一年。为此，您可以使用 `-1` 表示去年，`-2` 表示之前的一年，依此类推。如果您使用 `addDateTime`，则将每年的 `dateDiff` 函数保留为 `= 0`。 ``` dateDiff( {Discharge Date}, addDateTime(-1, "YYYY", now() ) ,"YYYY" ) = 0 /* Last year */ ``` 1. 将光标移到 `dateDiff` 下方的第一个空白行。添加逗号。 对于 `ifelse` 语句的 `then` 部分，我们需要选择包含销售额的度量（指标）`TotalSales`。 要选择字段，打开**字段**列表，然后双击字段将其添加到屏幕上。或者可以输入名称。在包含空格的名称周围添加大括号 `{ }`。您的指标可能有不同的名称。您可以通过字段前面的数字符号（**\$1**）判断哪个字段是指标。 现在，表达式应如下所示。 ``` ifelse( dateDiff( {Date}, truncDate( "YYYY", now() ) ,"YYYY" ) = 0 ,{TotalSales} ) ``` 1. 添加 `else` 子句。`ifelse` 函数不需要子句，但我们想添加。出于报告的目的，您通常不希望有任何 null 值，因为有时会省略带 null 值的行。 我们将 ifelse 的其余部分设置为 `0`。结果是，对于包含往年销售额的行，该字段为 `0`。 为此，请在空白行上添加一个逗号，然后添加 `0`。如果您在开头添加了注释，则最终 `ifelse` 表达式应如下所示。 ``` /* Calculates sales per year for this year*/ ifelse( dateDiff( {Date}, truncDate( "YYYY", now() ) ,"YYYY" ) = 0 ,{TotalSales} ,0 ) ``` 1. 选择右上角的**保存**以保存您所做的工作。 如果表达式中有错误，编辑器会在底部显示错误消息。检查表达式中是否有红色的波浪线，然后将光标悬停在该行上以查看错误消息内容。常见错误包括标点符号缺失、参数缺失、拼写错误和数据类型无效。 要避免进行任何更改，请选择**取消**。 **将参数值添加到计算字段** 1. 您可以在计算字段中引用参数。通过将参数添加到表达式中，可以添加该参数的当前值。 1. 要添加参数，打开**参数**列表，然后选择要包含其值的参数。 1. （可选）要手动向将参数添加到表达式，请键入参数的名称。然后用大括号 `{}` 将其括起来，并加上 `$` 前缀，例如 `${parameterName}`。 您可以更改数据集中任何字段的数据类型，包括计算字段的类型。您只能选择与字段中的数据相匹配的数据类型。 **更改计算字段的数据类型** + 对于**计算字段**（左侧），选择要更改的字段，然后从上下文（右键单击）菜单中选择**更改数据类型**。 与数据集中的其他字段不同，计算字段无法禁用。相反，可以将其删除。 **删除计算字段** + 对于**计算字段**（左侧），选择要更改的字段，然后从上下文（右键单击）菜单中选择**删除**。 ## 处理计算字段中的十进制值 当您的数据集使用直接查询模式时，十进制数据类型的计算由数据集来源引擎的行为决定。在某些特定情况下，Quick Sight 会应用特殊处理来确定输出计算的数据类型。 当您的数据集使用 SPICE 查询模式并且计算字段被具体化时，结果的数据类型取决于特定的函数运算符和输入的数据类型。下表显示了一些数值计算字段的预期行为。 **一元运算符** 下表显示了根据您使用的运算符和输入值的数据类型输出哪种数据类型。例如，如果您在 `abs` 计算中输入一个整数，则输出值的数据类型为整数。 **** [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/quick/latest/userguide/adding-a-calculated-field-analysis.html) **二元运算符** 下表根据您输入的两个值的数据类型显示输出哪种数据类型。例如，对于算术运算符，如果您提供两个整数数据类型，则计算结果将输出为整数。 对于基本运算符（\$1、-、\$1）： | | **整数** | **十进制定点** | **十进制浮点** | | --- | --- | --- | --- | | **整数** | 整数 | 十进制定点 | 十进制浮点 | | **十进制定点** | 十进制定点 | 十进制定点 | 十进制浮点 | | **十进制浮点** | 十进制浮点 | 十进制浮点 | 十进制浮点 | 对于除法运算符（/）： | | **整数** | **十进制定点** | **十进制浮点** | | --- | --- | --- | --- | | **整数** | 十进制浮点 | 十进制浮点 | 十进制浮点 | | **十进制定点** | 十进制浮点 | 十进制定点 | 十进制浮点 | | **十进制浮点** | 十进制浮点 | 十进制浮点 | 十进制浮点 | 对于指数运算符和模数运算符（^、%）： | | **整数** | **十进制定点** | **十进制浮点** | | --- | --- | --- | --- | | **整数** | 十进制浮点 | 十进制浮点 | 十进制浮点 | | **十进制定点** | 十进制浮点 | 十进制浮点 | 十进制浮点 | | **十进制浮点** | 十进制浮点 | 十进制浮点 | 十进制浮点 | # Amazon Quick Sight 中的评估顺序 评估顺序 当您打开或更新分析时，在显示分析之前，Amazon Quick Sight 会按特定顺序评估分析中配置的所有内容。Amazon Quick Sight 将配置转换为数据库引擎可以运行的查询。无论您连接到数据库、软件即服务 (SaaS) 源还是 Amazon Quick Sight 分析引擎 ([SPICE](spice.md))，查询都会以类似的方式返回数据。 如果您了解评估配置的顺序，您就知道指示将特定筛选器或计算应用于数据的顺序。 下图显示了评估顺序。左侧的列显示了未涉及等级感知计算窗口（LAC-W）或聚合（LAC-A）函数时的评估顺序。第二列显示了包含要在预筛选条件（`PRE_FILTER`）等级计算 LAC-W 表达式的计算字段的分析评估顺序。第三列显示了包含要在预聚合（`PRE_AGG`）等级计算 LAC-W 表达式的计算字段的分析评估顺序。最后一列显示了包含要计算 LAC-W 表达式的计算字段的分析评估顺序。在下图中，显示了评估顺序的详细说明。有关等级感知计算的更多信息，请参阅 [在 Quick Sight 中使用关卡感知计算](level-aware-calculations.md)。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/order-of-evaluation2.png) 以下列表显示了 Amazon Quick Sight 在您的分析中应用配置的顺序。在数据集中设置的任何内容都在分析之外发生，例如，数据集级别的计算、筛选器和安全设置。它们都应用于基础数据。以下列表仅涵盖分析内发生的内容。 1. **LAC-W 预筛选条件等级**：在分析筛选条件之前按原始表基数评估数据 1. **简单计算**：在标量等级进行计算，无需任何聚合或窗口计算。例如 `date_metric/60, parseDate(date, 'yyyy/MM/dd'), ifelse(metric > 0, metric, 0), split(string_column, '|' 0)`。 1. **LAC-W 函数 PRE\$1FILTER**：如果视觉对象中涉及任何 LAC-W PRE\$1FILTER 表达式，则 Amazon Quick Sight 首先在原始表级别计算窗口函数，然后再计算任何筛选器。如果在筛选条件中使用 LAC-W PRE\$1FILTER 表达式，则此时将应用该表达式。例如 `maxOver(Population, [State, County], PRE_FILTER) > 1000`。 1. **LAC-W PRE\$1AGG**：在聚合之前按原始表基数评估数据 1. **分析期间添加的筛选条件**：此时将应用为视觉对象中的未聚合字段创建的筛选条件，这与 WHERE 子句类似。例如 `year > 2020`。 1. **LAC-W 函数 PRE\$1AGG**：如果视觉对象中涉及任何 LAC-W PRE\$1AGG 表达式，Amazon Quick Sight 会在应用任何聚合之前计算窗口函数。如果在筛选条件中使用 LAC-W PRE\$1AGG 表达式，则此时将应用该表达式。例如 `maxOver(Population, [State, County], PRE_AGG) > 1000`。 1. **顶部/底部 N 个筛选器**：在维度上配置为显示 top/bottom N 个项目的筛选器。 1. **LAC-A 等级**：在视觉对象聚合之前，在自定义等级评估聚合 1. **自定义等级聚合**：如果视觉对象中涉及任何 LAC-A 表达式，则此时会对其进行计算。Amazon 根据上述筛选条件之后的表格QuickSight 计算聚合，并按计算字段中指定的维度进行分组。例如 `max(Sales, [Region])`。 1. **视觉对象等级**：在视觉对象等级评估聚合和聚合后表计算，并将其余配置应用于视觉对象 1. **视觉对象等级聚合**：应始终应用视觉对象聚合，表格表格除外（其维度为空）。使用此设置，将根据字段井中的字段计算聚合，并按视觉对象中的维度进行分组。如果任何筛选条件构建在聚合之上，则此时将应用该筛选条件，类似于 HAVING 子句。例如 `min(distance) > 100`。 1. **表计算**：如果视觉对象中引用了任何聚合后表计算（应将聚合表达式作为操作数），则此时会对其进行计算。Amazon Quick Sight 在可视化聚合之后执行窗口计算。同样，也会应用构建在此类计算上的筛选条件。 1. **其他类别计算**：此类计算仅存在于line/bar/pie/donut图表中。有关更多信息，请参阅 [显示限制](working-with-visual-types.md#display-limits)。 1. **总计和小计**：如果需要，可以在圆环图（仅限总计）、表格（仅限总计）和数据透视表中计算总计和小计。 # 在 Quick Sight 中使用关卡感知计算 等级感知计算 | | | --- | |    适用于：企业版和标准版  | 通过*等级感知计算*（LAC），您可以指定要计算窗口函数或聚合函数的粒度等级。LAC 函数有两种类型：等级感知计算 – 聚合（LAC-A）函数和等级感知计算 – 窗口（LAC-W）函数。 **Topics** + [LAC-A 函数](#level-aware-calculations-aggregate) + [LAC-A 函数](#level-aware-calculations-window) ## 等级感知计算 – 聚合（LAC-A）函数 LAC-A 函数 通过 LAC-A 函数，您可以指定在哪个等级对计算进行分组。通过向现有聚合函数（例如 `sum() , max() , count()`）添加参数，您可以定义聚合所需的任何分组依据等级。添加的等级可以是任何维度，其独立于添加到视觉对象的维度。例如： ``` sum(measure,[group_field_A]) ``` 要使用 LAC-A 函数，请在计算编辑器中直接键入这些函数，方法是将预期的聚合等级添加为括号中的第二个参数。以下是用于比较的聚合函数和 LAC-A 函数的示例。 + 聚合函数：`sum({sales})` + LAC-A 函数：`sum({sales}, [{Country},{Product}])` LAC-A 结果是用方括号 `[ ]` 中的指定级别计算的，可用作聚合函数的操作数。聚合函数的分组依据等级为视觉对象等级，**分组依据**字段添加到视觉对象的字段井中。 除了在方括号 `[ ]` 中创建静态 LAC 组密钥外，您还可以通过在方括号中放置参数 `$visualDimensions` 来使其动态适应视觉对象分组依据字段。这是系统提供的参数，与用户定义的参数截然不同。`[$visualDimensions]` 参数表示添加到当前视觉对象中**分组依据**字段井中的字段。以下示例说明如何将组密钥动态添加到视觉对象维度，或将组密钥从视觉对象维度中移除 + 带有动态添加组密钥的 LAC-A：`sum({sales}, [${visualDimensions},{Country},{Products}])` 在计算视觉对象等级聚合之前，它会计算按 `country`、`products` 以及**分组依据**字段井中的任何其他字段分组的销售总额。 + 带有动态移除组密钥的 LAC-A：`sum({sales}, [${visualDimensions},!{Country},!{Products}])` 在计算视觉对象等级聚合之前，它会计算按视觉对象**分组依据**字段井中的字段（`country` 和 `product` 除外）分组的销售总额。 您可以在 LAC 表达式中指定添加的组密钥或删除的组密钥，但不能同时指定两者。 以下聚合函数支持 LAC-A 函数： + [avg](avg-function.md) + [count](count-function.md) + [distinct\$1count](distinct_count-function.md) + [max](max-function.md) + [median](median-function.md) + [min](min-function.md) + [percentile](percentile-function.md) + [percentileCont](percentileCont-function.md) + [percentileDisc（百分位数）](percentileDisc-function.md) + [stdev](stdev-function.md) + [stdevp](stdevp-function.md) + [sum](sum-function.md) + [var](var-function.md) + [varp](varp-function.md) ### LAC-A 示例 您可以使用 LAC-A 函数执行以下操作： + 运行独立于与视觉对象中的等级的计算。例如，如果您进行以下计算，则仅汇总国家/地区等级的销售数量，但不汇总视觉对象中其他维度（区域或产品）的销售数量。 ``` sum({Sales},[{Country}]) ``` + 对不在视觉对象中的维度运行计算。例如，如果您使用以下函数，则可以按区域计算各个国家/地区的平均销售总额。 ``` sum({Sales},[{Country}]) ``` 尽管国家/地区不包含在视觉对象中，但 LAC-A 函数首先汇总国家/地区等级的销售额，然后通过视觉对象等级计算生成每个区域的平均销售额。如果未使用 LAC-A 函数来指定登记，则按每个区域的最低粒度等级（数据集的基本等级）计算平均销售额（显示在销售额列中）。 + 将 LAC-A 与其他聚合函数和 LAC-W 函数结合使用。有两种方法可以将 LAC-A 函数与其他函数嵌套。 + 创建计算时，可以编写嵌套语法。例如，LAC-A 函数可以与 LAC-W 函数嵌套，以计算每种产品平均价格的各国家/地区的总销售额： ``` sum(avgOver({Sales},[{Product}],PRE_AGG),[{Country}]) ``` + 将 LAC-A 函数添加到视觉对象时，可以将计算与您在字段井中选择的视觉对象等级聚合函数进一步嵌套。有关更改视觉对象中字段聚合的更多信息，请参阅 [使用字段井在字段上更改或添加聚合](changing-field-aggregation.md#change-field-aggregation-field-wells)。 ### LAC-A 限制 以下限制适用于 LAC-A 函数： + 所有累加性和非累加性聚合函数都支持 LAC-A 函数，例如 `sum()`、`count()` 和 `percentile()`。以 “if” 结尾的条件聚合函数（例如`sumif()`和）不支持 LAC-A 函数`countif()`，也不支持periodToDate以 “” 开头的周期聚合函数，例如`periodToDateSum()`和`periodToDateMax()`。 + 表和数据透视表中的 LAC-A 函数目前不支持行级和列级总计。在图表中添加行级或列级总计时，总数将显示为空白。其他非 LAC 维度不受影响。 + 目前不支持嵌套的 LAC-A 函数。支持与常规聚合函数和 LAC-W 函数嵌套的 LAC-A 函数的有限功能。 例如，有效函数如下所示： + `Aggregation(LAC-A())`。例如：`max(sum({sales}, [{country}]))` + `LAC-A(LAC-W())`。例如：`sum(sumOver({Sales},[{Product}],PRE_AGG), [{Country}])` 以下函数无效： + `LAC-A(Aggregation())`。例如：`sum(max({sales}), [{country}])` + `LAC-A(LAC-A())`。例如：`sum(max({sales}, [{country}]),[category])` + `LAC-W(LAC-A())`。例如：`sumOver(sum({Sales},[{Product}]),[{Country}],PRE_AGG)` ## 等级感知计算 – 窗口（LAC-A）函数 LAC-A 函数 通过 LAC-W 函数，您可以指定用于计算的窗口或分区。LAC-W 函数是一组可以在预筛选条件或预聚合等级运行的窗口函数，例如 `sumover()`、`(maxover)`、`denseRank`。例如：`sumOver(measure,[partition_field_A],pre_agg)`。 LAC-W 函数以前称为等级感知聚合（LAA）。 LAC-W 函数可以帮助您回答以下类型的问题： + 我有多少客户只下了 1 个采购订单？ 或 11 个？ 或 50 个？ 我们希望视觉对象使用计数作为维度而不是视觉对象中的度量。 + 对于终身支出超过 10 万美元的客户，每个细分市场的总销售额是多少？ 该视觉对象应只显示细分市场和每个细分市场的总销售额。 + 每个行业对整个公司利润的贡献（占总利润的百分比）是多少？ 我们希望能够筛选视觉对象以显示一些行业，以及它们如何为所展示行业的总销售额做出贡献。但是，我们还希望看到每个行业占整个公司总销售额的百分比（包括筛选出的行业）。 + 与行业平均值相比，每个类别的总销售额是多少？ 行业平均值应包括所有类别，即使在筛选后也是如此。 + 我的客户是如何分组到累积支出范围的？ 我们想使用分组作为维度而不是指标。 对于更复杂的问题，你可以在 Quick Sight 对你的设置进行评估的特定点之前注入计算或过滤器。要直接影响您的结果，您可以将计算级别关键字添加到表计算。有关 Quick Sight 如何评估查询的更多信息，请参阅[Amazon Quick Sight 中的评估顺序](order-of-evaluation-quicksight.md)。 LAC-W 函数支持以下计算等级： + **`PRE_FILTER`**— 在应用分析中的筛选器之前，Quick Sight 会评估预过滤器的计算结果。然后，将应用在这些预筛选计算上配置的所有筛选器。 + **`PRE_AGG`**— 在计算显示屏级别的聚合之前，Quick Sight 会执行预聚合计算。然后，将应用在这些预聚合计算上配置的所有筛选器。此工作发生在应用顶部和底部 *N* 个筛选器之前。 您可以将 `PRE_FILTER` 或 `PRE_AGG` 关键字用作以下表计算函数中的参数。在指定计算级别时，可在函数中使用未聚合的度量。例如，您可以使用 `countOver({ORDER ID}, [{Customer ID}], PRE_AGG)`。通过使用 `PRE_AGG`，您可以指定 `countOver` 在预聚合级别执行。 + [avgOver](avgOver-function.md) + [countOver](countOver-function.md) + [denseRank](denseRank-function.md) + [distinctCountOver](distinctCountOver-function.md) + [minOver](minOver-function.md) + [maxOver](maxOver-function.md) + [percentileRank](percentileRank-function.md) + [rank](rank-function.md) + [stdevOver](stdevOver-function.md) + [stdevpOver](stdevpOver-function.md) + [sumOver](sumOver-function.md) + [varOver](varOver-function.md) + [varpOver](varpOver-function.md) 默认情况下，每个函数的第一个参数都必须是聚合的度量。如果您使用 `PRE_FILTER` 或 `PRE_AGG`，则对第一个参数使用非聚合度量。 对于 LAC-W 函数，视觉对象聚合默认为 `MIN` 以消除重复项。要更改聚合，请打开字段的上下文菜单（右键单击），然后选择另一个不同聚合。 有关在现实生活场景中何时以及如何使用 LAC-W 函数的示例，请参阅 Amazon 大数据博客中的以下文章：[使用 Amazon 中的关卡感知聚合创建高级见解](https://www.amazonaws.cn/jp/blogs/big-data/create-advanced-insights-using-level-aware-aggregations-in-amazon-quicksight/)。QuickSight # Amazon Quick 的计算字段函数和运算符参考 函数和运算符 您可以在数据准备期间或从分析页面中向数据集添加计算字段。如果在数据准备期间将计算字段添加到数据集中，则可以在使用该数据集的所有分析中使用该字段。在将一个计算字段添加到分析中的数据集时，只能在此分析中使用该字段。 您可以使用以下函数和运算符来创建计算字段以转换数据。 **Topics** + [ # 运算符 ](arithmetic-and-comparison-operators.md) + [ # 按类别列出函数 ](functions-by-category.md) + [ # 函数 ](functions.md) + [ # 聚合函数 ](calculated-field-aggregations.md) + [ # 表计算函数 ](table-calculation-functions.md) # 运算符 您可以在计算字段中使用以下运算符。Quick 使用标准运算顺序：括号、指数、乘法、除法、加法、减法 (PEMDAS)。等于（=）和不等于（<>）比较区分大小写。 + 加 (\$1) + 减 (−) + 乘 (\$1) + 除 (/) + 取模（%）– 另请参阅以下列表中的 `mod()`。 + 幂（^）– 另请参阅以下列表中的 `exp()`。 + 等于 (=) + 不等于 (<>) + 大于（>） + 大于或等于 (>=) + 小于（<） + 小于或等于（<=） + AND + 或 + NOT Amazon Quick 支持将以下数学函数应用于表达式。 + `[https://docs.amazonaws.cn/quicksight/latest/user/mod-function.html](https://docs.amazonaws.cn/quicksight/latest/user/mod-function.html)(number, divisor)` – 查找将一个数字除以除数之后的余数。 + `[https://docs.amazonaws.cn/quicksight/latest/user/log-function.html](https://docs.amazonaws.cn/quicksight/latest/user/log-function.html)(expression) ` – 返回给定表达式的以 10 为底的对数。 + `[https://docs.amazonaws.cn/quicksight/latest/user/ln-function.html](https://docs.amazonaws.cn/quicksight/latest/user/ln-function.html)(expression) ` – 返回给定表达式的自然对数。 + `[https://docs.amazonaws.cn/quicksight/latest/user/abs-function.html](https://docs.amazonaws.cn/quicksight/latest/user/abs-function.html)(expression) ` – 返回给定表达式的绝对值。 + `[https://docs.amazonaws.cn/quicksight/latest/user/sqrt-function.html](https://docs.amazonaws.cn/quicksight/latest/user/sqrt-function.html)(expression) ` – 返回给定表达式的平方根。 + `[https://docs.amazonaws.cn/quicksight/latest/user/exp-function.html](https://docs.amazonaws.cn/quicksight/latest/user/exp-function.html)(expression) ` – 返回以自然常数 *e* 为底且以指定表达式为幂的值。 要使冗长的计算更易于阅读，您可以使用圆括号来澄清分组和计算优先级。在以下语句中，不需要圆括号。首先处理乘法语句，然后将结果与 5 相加，返回值 26。但是，圆括号使语句更易于阅读，因此也易于维护。 ``` 5 + (7 * 3) ``` 因为圆括号排在运算顺序的第一位，所以您可以改变运用其他运算符的顺序。例如，在以下语句中，先处理加法语句，然后将结果乘以 3 以返回值 36。 ``` (5 + 7) * 3 ``` ## 示例：算术运算符 多个运算符 以下示例使用多个算术运算符确定扣除折扣后的销售总额。 ``` (Quantity * Amount) - Discount ``` ## 示例：（/）除法 （/）除法 下面的示例使用除法将 3 除以 2。返回值 1.5。Amazon Quick 使用浮点除法。 ``` 3/2 ``` ## 示例：（=）等于 = (等于) 使用 = 执行区分大小写的值比较。比较为 TRUE 的行包括在结果集中。 在以下示例中，在结果中包含 `Region` 字段为 **South** 的行。如果 `Region` 为 **south**，则排除这些行。 ``` Region = 'South' ``` 在下例中，比较结果为 FALSE。 ``` Region = 'south' ``` 以下示例显示一个比较，它将 `Region` 全部转换为大写形式 (**SOUTH**)，然后与 **SOUTH** 进行比较。这会返回区域为 **south**、**South** 或 **SOUTH** 的行。 ``` toUpper(Region) = 'SOUTH' ``` ## 示例：（<>） <>（不等于） 不等号 <> 意味着*小于或大于*。 因此，如果 **x<>1**，则可以说成 *x 小于 1 或大于 1*。< 和 > 是一起计算的。或者说成 *x 是除 1 以外的任何值*。或者，*x 不等于 1*。 **注意** 使用 <>，而不是 \$1=。 下例比较 `Status Code` 与数字值。这会返回 `Status Code` 不等于 **1** 的行。 ``` statusCode <> 1 ``` 以下示例比较多个 `statusCode` 值。在此情况下，活动记录具有 `activeFlag = 1`。该示例返回以下条件之一适用的行： + 对于活动记录，显示状态不是 1 或 2 的行 + 对于非活动记录，显示状态为 99 或 -1 的行 ``` ( activeFlag = 1 AND (statusCode <> 1 AND statusCode <> 2) ) OR ( activeFlag = 0 AND (statusCode= 99 OR statusCode= -1) ) ``` ## 示例：(^) ^（幂） 幂符号 `^` 表示 * 的 * 次幂。您可以将幂运算符与任何数值字段和任何有效指数一起使用。 以下示例是 2 的 4 次幂或 (2 \$1 2 \$1 2 \$1 2) 的简单表达式。这会返回值 16。 ``` 2^4 ``` 以下示例计算收入字段的平方根。 ``` revenue^0.5 ``` ## 示例：AND、OR 和 NOT 使用 AND、OR 和 NOT 运算符来完善您的选择标准。当您需要显示不同比较之间的关系时，这些运算符很有用。 以下示例使用 AND、OR 和 NOT 来比较多个表达式。表达式中使用了条件运算符，以标记不在华盛顿或俄勒冈州、享受特别促销并且订单超过 10 个的最大客户。如果没有返回值，则使用值“n/a”。 ``` ifelse(( (NOT (State = 'WA' OR State = 'OR')) AND Orders > 10), 'Special Promotion XYZ', 'n/a') ``` ## 示例：创建比较列表如“in”或“not in” in/not in 此例使用运算符来创建比较，以查找在指定值列表中存在或不存在的值。 以下示例比较 `promoCode` 与一个指定值列表。该示例返回 `promoCode` 位于列表 **(1, 2, 3)** 中的行。 ``` promoCode = 1 OR promoCode = 2 OR promoCode = 3 ``` 以下示例比较 `promoCode` 与一个指定值列表。该示例返回 `promoCode` 没有位于列表 **(1, 2, 3)** 中的行。 ``` NOT(promoCode = 1 OR promoCode = 2 OR promoCode = 3 ) ``` 另一种表示方法是提供一个列表，其中 `promoCode` 不等于列表中的任何项。 ``` promoCode <> 1 AND promoCode <> 2 AND promoCode <> 3 ``` ## 示例：创建“between”比较 介于 该示例使用比较运算符创建一个比较，以显示介于两个值之间的值。 以下示例检查 `OrderDate` 并返回 `OrderDate` 介于 2016 年第一天与最后一天之间的行。在这种情况下，我们希望包含第一天和最后一天，因此我们在比较运算符上使用了“或等于”。 ``` OrderDate >= "1/1/2016" AND OrderDate <= "12/31/2016" ``` # 按类别列出函数 在本节中，您可以找到 Amazon Quick 中按类别排序的可用功能列表。 **Topics** + [ ## 聚合函数 ](#aggregate-functions) + [ ## 条件函数 ](#conditional-functions) + [ ## 日期函数 ](#date-functions) + [ ## 数字函数 ](#numeric-functions) + [ ## 数学函数 ](#mathematical-functions) + [ ## 字符串函数 ](#string-functions) + [ ## 表计算 ](#table-calculations) ## 聚合函数 Amazon Quick 中计算字段的聚合函数包括以下内容。这些仅在分析和可视化期间可用。所有这些函数都会返回按选定的一个或多个维度分组的值。对于每个聚合，还有一个有条件聚合。它们根据条件执行相同类型的聚合。 + [https://docs.amazonaws.cn/quicksight/latest/user/avg-function.html](https://docs.amazonaws.cn/quicksight/latest/user/avg-function.html) 计算指定度量中的一组数字的平均值，并按照选定的一个或多个维度分组。 + [https://docs.amazonaws.cn/quicksight/latest/user/avgIf-function.html](https://docs.amazonaws.cn/quicksight/latest/user/avgIf-function.html) 根据条件语句计算平均值。 + [https://docs.amazonaws.cn/quicksight/latest/user/count-function.html](https://docs.amazonaws.cn/quicksight/latest/user/count-function.html) 计算维度或度量中包含的值的个数，并按照选定的一个或多个维度分组。 + [https://docs.amazonaws.cn/quicksight/latest/user/countIf-function.html](https://docs.amazonaws.cn/quicksight/latest/user/countIf-function.html) 根据条件语句计算计数。 + [https://docs.amazonaws.cn/quicksight/latest/user/distinct_count-function.html](https://docs.amazonaws.cn/quicksight/latest/user/distinct_count-function.html) 计算维度或度量中包含的不同值的个数，并按照选定的一个或多个维度分组。 + [https://docs.amazonaws.cn/quicksight/latest/user/distinct_countIf-function.html](https://docs.amazonaws.cn/quicksight/latest/user/distinct_countIf-function.html) 根据条件语句计算不同值计数。 + [https://docs.amazonaws.cn/quicksight/latest/user/max-function.html](https://docs.amazonaws.cn/quicksight/latest/user/max-function.html) 返回指定度量的最大值，并按照选定的一个或多个维度分组。 + [https://docs.amazonaws.cn/quicksight/latest/user/maxIf-function.html](https://docs.amazonaws.cn/quicksight/latest/user/maxIf-function.html) 根据条件语句计算最大值。 + [https://docs.amazonaws.cn/quicksight/latest/user/median-function.html](https://docs.amazonaws.cn/quicksight/latest/user/median-function.html) 返回指定度量的中值，并按照选定的一个或多个维度进行分组。 + [https://docs.amazonaws.cn/quicksight/latest/user/medianIf-function.html](https://docs.amazonaws.cn/quicksight/latest/user/medianIf-function.html) 根据条件语句计算中位数。 + [https://docs.amazonaws.cn/quicksight/latest/user/min-function.html](https://docs.amazonaws.cn/quicksight/latest/user/min-function.html) 返回指定度量的最小值，并按照选定的一个或多个维度分组。 + [https://docs.amazonaws.cn/quicksight/latest/user/minIf-function.html](https://docs.amazonaws.cn/quicksight/latest/user/minIf-function.html) 根据条件语句计算最小值。 + [https://docs.amazonaws.cn/quicksight/latest/user/percentile-function.html](https://docs.amazonaws.cn/quicksight/latest/user/percentile-function.html)（`percentileDisc` 的别名）计算指定度量的第 *n* 个百分位数，并按照选定的一个或多个维度分组。 + [https://docs.amazonaws.cn/quicksight/latest/user/percentileCont-function.html](https://docs.amazonaws.cn/quicksight/latest/user/percentileCont-function.html) 根据指定度量的数字的连续分布计算第 *n* 个百分位数，并按照选定的一个或多个维度分组。 + [percentileDisc（百分位数）根据指定度量的实际数字（按所选一个或多个维度分组）](https://docs.amazonaws.cn/quicksight/latest/user/percentileDisc-function.html)计算第 *n* 个百分位数。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodToDateAvg-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodToDateAvg-function.html) 按给定时间粒度（例如一个季度）到某个时间点的指定度量计算一组数字的平均值。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodToDateCount-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodToDateCount-function.html) 按给定时间粒度（例如一个季度）到某个时间点的维度或度量（包括重复项）计算数值。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodToDateMax-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodToDateMax-function.html) 返回给定时间粒度（例如一个季度）到某个时间点的指定度量的最大值。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodToDateMedian-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodToDateMedian-function.html) 返回给定时间粒度（例如一个季度）到某个时间点的指定度量的中值。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodToDateMin-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodToDateMin-function.html) 返回给定时间粒度（例如一个季度）到某个时间点的指定度量或日期的最小值。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodToDatePercentile-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodToDatePercentile-function.html) 按给定时间粒度（例如一个季度）到某个时间点的度量中的实际值计算百分位数。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodToDatePercentileCont-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodToDatePercentileCont-function.html) 按给定时间粒度（例如一个季度）到某个时间点的度量中数值的连续分布计算百分位数。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodToDateStDev-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodToDateStDev-function.html) 根据样本按给定时间粒度（例如一个季度）到某个时间点的指定度量计算一组数字的标准差。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodToDateStDevP-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodToDateStDevP-function.html) 根据样本按给定时间粒度（例如一个季度）到某个时间点的指定度量计算一组数字的总体标准差。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodToDateSum-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodToDateSum-function.html) 按给定时间粒度（例如一个季度）到某个时间点的指定度量计算一组数字的和。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodToDateVar-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodToDateVar-function.html) 按给定时间粒度（例如一个季度）到某个时间点的指定度量计算一组数字的样本方差。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodToDateVarP-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodToDateVarP-function.html) 按给定时间粒度（例如一个季度）到某个时间点的指定度量计算一组数字的总体方差。 + [https://docs.amazonaws.cn/quicksight/latest/user/stdev-function.html](https://docs.amazonaws.cn/quicksight/latest/user/stdev-function.html) 根据样本按指定的度量计算一组数字的标准差，并按照选定的一个或多个维度分组。 + [https://docs.amazonaws.cn/quicksight/latest/user/stdevIf-function.html](https://docs.amazonaws.cn/quicksight/latest/user/stdevIf-function.html) 根据条件语句计算样本标准差。 + [https://docs.amazonaws.cn/quicksight/latest/user/stdevp-function.html](https://docs.amazonaws.cn/quicksight/latest/user/stdevp-function.html) 根据总体偏差计算指定度量中的一组数字的标准差，并按照选定的一个或多个维度分组。 + [https://docs.amazonaws.cn/quicksight/latest/user/stdevpIf-function.html](https://docs.amazonaws.cn/quicksight/latest/user/stdevpIf-function.html) 根据条件语句计算总体偏差。 + [https://docs.amazonaws.cn/quicksight/latest/user/var-function.html](https://docs.amazonaws.cn/quicksight/latest/user/var-function.html) 根据样本按指定的度量计算一组数字的方差，并按照选定的一个或多个维度分组。 + [https://docs.amazonaws.cn/quicksight/latest/user/varIf-function.html](https://docs.amazonaws.cn/quicksight/latest/user/varIf-function.html) 根据条件语句计算样本方差。 + [https://docs.amazonaws.cn/quicksight/latest/user/varp-function.html](https://docs.amazonaws.cn/quicksight/latest/user/varp-function.html) 根据总体偏差按指定的度量计算一组数字的方差，并按照选定的一个或多个维度分组。 + [https://docs.amazonaws.cn/quicksight/latest/user/varpIf-function.html](https://docs.amazonaws.cn/quicksight/latest/user/varpIf-function.html) 根据条件语句计算总体方差。 + [https://docs.amazonaws.cn/quicksight/latest/user/sum-function.html](https://docs.amazonaws.cn/quicksight/latest/user/sum-function.html) 按指定的度量对一组数字求和，并按照选定的一个或多个维度分组。 + [https://docs.amazonaws.cn/quicksight/latest/user/sumIf-function.html](https://docs.amazonaws.cn/quicksight/latest/user/sumIf-function.html) 根据条件语句计算总和。 ## 条件函数 Amazon Quick 中计算字段的条件函数包括以下内容： + [https://docs.amazonaws.cn/quicksight/latest/user/coalesce-function.html](https://docs.amazonaws.cn/quicksight/latest/user/coalesce-function.html) 返回第一个不为 null 的参数值。 + [https://docs.amazonaws.cn/quicksight/latest/user/ifelse-function.html](https://docs.amazonaws.cn/quicksight/latest/user/ifelse-function.html) 对一组 *if*/*then* 表达式对进行计算，并返回计算结果为 true 的第一个 *if* 参数的 *then* 参数值。 + [https://docs.amazonaws.cn/quicksight/latest/user/in-function.html](https://docs.amazonaws.cn/quicksight/latest/user/in-function.html) 评估一个表达式以查看它是否在给定的值列表中。 + [https://docs.amazonaws.cn/quicksight/latest/user/isNotNull-function.html](https://docs.amazonaws.cn/quicksight/latest/user/isNotNull-function.html) 对表达式求值以确定其是否为 null。 + [https://docs.amazonaws.cn/quicksight/latest/user/isNull-function.html](https://docs.amazonaws.cn/quicksight/latest/user/isNull-function.html) 对表达式求值以确定其是否为 null。如果表达式为 null，`isNull` 将返回 true，否则，将返回 false。 + [https://docs.amazonaws.cn/quicksight/latest/user/notIn-function.html](https://docs.amazonaws.cn/quicksight/latest/user/notIn-function.html) 评估一个表达式以查看它是否不在给定的值列表中。 + [https://docs.amazonaws.cn/quicksight/latest/user/nullIf-function.html](https://docs.amazonaws.cn/quicksight/latest/user/nullIf-function.html) 比较两个表达式。如果表达式相等，该函数返回 null。如果表达式不相等，该函数返回第一个表达式。 + [https://docs.amazonaws.cn/quicksight/latest/user/switch-function.html](https://docs.amazonaws.cn/quicksight/latest/user/switch-function.html) 返回与第一个等于条件表达式的标签相匹配的表达式。 ## 日期函数 Amazon Quick 中计算字段的日期函数包括以下内容： + [https://docs.amazonaws.cn/quicksight/latest/user/addDateTime-function.html](https://docs.amazonaws.cn/quicksight/latest/user/addDateTime-function.html) 在提供的日期或时间中增加或减少时间单位。 + [https://docs.amazonaws.cn/quicksight/latest/user/addWorkDays-function.html](https://docs.amazonaws.cn/quicksight/latest/user/addWorkDays-function.html) 将给定的工作日数与提供的日期或时间相加或相减。 + [https://docs.amazonaws.cn/quicksight/latest/user/dateDiff-function.html](https://docs.amazonaws.cn/quicksight/latest/user/dateDiff-function.html) 返回两个日期字段相差的天数。 + [https://docs.amazonaws.cn/quicksight/latest/user/epochDate-function.html](https://docs.amazonaws.cn/quicksight/latest/user/epochDate-function.html) 将纪元日期转换为标准日期。 + [https://docs.amazonaws.cn/quicksight/latest/user/extract-function.html](https://docs.amazonaws.cn/quicksight/latest/user/extract-function.html) 返回日期值的指定部分。 + [https://docs.amazonaws.cn/quicksight/latest/user/formatDate-function.html](https://docs.amazonaws.cn/quicksight/latest/user/formatDate-function.html) 使用您指定的模式格式化日期。 + 如果给定的日期时间值是工作日，[https://docs.amazonaws.cn/quicksight/latest/user/isWorkDay-function.html](https://docs.amazonaws.cn/quicksight/latest/user/isWorkDay-function.html) 返回 TRUE。 + [https://docs.amazonaws.cn/quicksight/latest/user/netWorkDays-function.html](https://docs.amazonaws.cn/quicksight/latest/user/netWorkDays-function.html) 返回所提供的两个日期值之间的工作日数。 + [https://docs.amazonaws.cn/quicksight/latest/user/now-function.html](https://docs.amazonaws.cn/quicksight/latest/user/now-function.html) 返回当前日期和时间，同时将设置用于数据库，或将 UTC 用于文件和 Salesforce。 + [https://docs.amazonaws.cn/quicksight/latest/user/truncDate-function.html](https://docs.amazonaws.cn/quicksight/latest/user/truncDate-function.html) 返回表示日期指定部分的日期值。 ## 数字函数 Amazon Quick 中计算字段的数值函数包括以下内容： + [https://docs.amazonaws.cn/quicksight/latest/user/ceil-function.html](https://docs.amazonaws.cn/quicksight/latest/user/ceil-function.html) 将小数值向上舍入为大于它的最接近整数。 + [https://docs.amazonaws.cn/quicksight/latest/user/decimalToInt-function.html](https://docs.amazonaws.cn/quicksight/latest/user/decimalToInt-function.html) 将小数值转换为整数。 + [https://docs.amazonaws.cn/quicksight/latest/user/floor-function.html](https://docs.amazonaws.cn/quicksight/latest/user/floor-function.html) 将小数值向下舍入到小于它的最接近整数。 + [https://docs.amazonaws.cn/quicksight/latest/user/intToDecimal-function.html](https://docs.amazonaws.cn/quicksight/latest/user/intToDecimal-function.html) 将整数值转换为小数。 + [https://docs.amazonaws.cn/quicksight/latest/user/round-function.html](https://docs.amazonaws.cn/quicksight/latest/user/round-function.html) 将小数值舍入为最接近的整数，或者，如果指定了精度，则舍入到最接近的小数位数。 ## 数学函数 Amazon Quick 中计算字段的数学函数包括以下内容： + `[https://docs.amazonaws.cn/quicksight/latest/user/mod-function.html](https://docs.amazonaws.cn/quicksight/latest/user/mod-function.html)(number, divisor)` – 查找将一个数字除以除数之后的余数。 + `[https://docs.amazonaws.cn/quicksight/latest/user/log-function.html](https://docs.amazonaws.cn/quicksight/latest/user/log-function.html)(expression) ` – 返回给定表达式的以 10 为底的对数。 + `[https://docs.amazonaws.cn/quicksight/latest/user/ln-function.html](https://docs.amazonaws.cn/quicksight/latest/user/ln-function.html)(expression) ` – 返回给定表达式的自然对数。 + `[https://docs.amazonaws.cn/quicksight/latest/user/abs-function.html](https://docs.amazonaws.cn/quicksight/latest/user/abs-function.html)(expression) ` – 返回给定表达式的绝对值。 + `[https://docs.amazonaws.cn/quicksight/latest/user/sqrt-function.html](https://docs.amazonaws.cn/quicksight/latest/user/sqrt-function.html)(expression) ` – 返回给定表达式的平方根。 + `[https://docs.amazonaws.cn/quicksight/latest/user/exp-function.html](https://docs.amazonaws.cn/quicksight/latest/user/exp-function.html)(expression) ` – 返回以自然常数 *e* 为底且以指定表达式为幂的值。 ## 字符串函数 Amazon Quick 中计算字段的字符串（文本）函数包括以下内容： + [https://docs.amazonaws.cn/quicksight/latest/user/concat-function.html](https://docs.amazonaws.cn/quicksight/latest/user/concat-function.html) 连接两个或多个字符串。 + [https://docs.amazonaws.cn/quicksight/latest/user/contains-function.html](https://docs.amazonaws.cn/quicksight/latest/user/contains-function.html) 检查表达式是否包含子字符串。 + [https://docs.amazonaws.cn/quicksight/latest/user/endsWith-function.html](https://docs.amazonaws.cn/quicksight/latest/user/endsWith-function.html) 检查表达式是否以指定的子字符串结尾。 + [https://docs.amazonaws.cn/quicksight/latest/user/left-function.html](https://docs.amazonaws.cn/quicksight/latest/user/left-function.html) 返回字符串最左侧指定数量的字符。 + [https://docs.amazonaws.cn/quicksight/latest/user/locate-function.html](https://docs.amazonaws.cn/quicksight/latest/user/locate-function.html) 查找另一个字符串内的某个子字符串，并返回该子字符串之前的字符数。 + [https://docs.amazonaws.cn/quicksight/latest/user/ltrim-function.html](https://docs.amazonaws.cn/quicksight/latest/user/ltrim-function.html) 从字符串中移除前置空格。 + [https://docs.amazonaws.cn/quicksight/latest/user/parseDate-function.html](https://docs.amazonaws.cn/quicksight/latest/user/parseDate-function.html) 解析一个字符串，以确定它是否包含某个日期值，如果找到则返回该日期。 + [https://docs.amazonaws.cn/quicksight/latest/user/parseDecimal-function.html](https://docs.amazonaws.cn/quicksight/latest/user/parseDecimal-function.html) 解析字符串以确定其是否包含小数值。 + [https://docs.amazonaws.cn/quicksight/latest/user/parseInt-function.html](https://docs.amazonaws.cn/quicksight/latest/user/parseInt-function.html) 解析字符串以确定其是否包含整数值。 + [https://docs.amazonaws.cn/quicksight/latest/user/parseJson-function.html](https://docs.amazonaws.cn/quicksight/latest/user/parseJson-function.html) 解析来自本机 JSON 或文本字段中 JSON 对象的值。 + [https://docs.amazonaws.cn/quicksight/latest/user/replace-function.html](https://docs.amazonaws.cn/quicksight/latest/user/replace-function.html) 将一个字符串的一部分用新字符串替换。 + [https://docs.amazonaws.cn/quicksight/latest/user/right-function.html](https://docs.amazonaws.cn/quicksight/latest/user/right-function.html) 返回字符串最右侧指定数量的字符。 + [https://docs.amazonaws.cn/quicksight/latest/user/rtrim-function.html](https://docs.amazonaws.cn/quicksight/latest/user/rtrim-function.html) 从字符串中移除尾随空格。 + [https://docs.amazonaws.cn/quicksight/latest/user/split-function.html](https://docs.amazonaws.cn/quicksight/latest/user/split-function.html) 根据您选择的分隔符将字符串拆分为一个子字符串数组，并返回由位置指定的项目。 + [https://docs.amazonaws.cn/quicksight/latest/user/startsWith-function.html](https://docs.amazonaws.cn/quicksight/latest/user/startsWith-function.html) 检查表达式是否以指定的子字符串开头。 + [https://docs.amazonaws.cn/quicksight/latest/user/strlen-function.html](https://docs.amazonaws.cn/quicksight/latest/user/strlen-function.html) 返回一个字符串中的字符数。 + [https://docs.amazonaws.cn/quicksight/latest/user/substring-function.html](https://docs.amazonaws.cn/quicksight/latest/user/substring-function.html) 从指定位置开始，返回一个字符串中指定数量的字符。 + [https://docs.amazonaws.cn/quicksight/latest/user/toLower-function.html](https://docs.amazonaws.cn/quicksight/latest/user/toLower-function.html) 将字符串全部转为小写格式。 + [https://docs.amazonaws.cn/quicksight/latest/user/toString-function.html](https://docs.amazonaws.cn/quicksight/latest/user/toString-function.html) 将输入表达式转为字符串格式。 + [https://docs.amazonaws.cn/quicksight/latest/user/toUpper-function.html](https://docs.amazonaws.cn/quicksight/latest/user/toUpper-function.html) 将字符串全部转为大写格式。 + [https://docs.amazonaws.cn/quicksight/latest/user/trim-function.html](https://docs.amazonaws.cn/quicksight/latest/user/trim-function.html) 从字符串中同时移除前置和尾随空格。 ## 表计算 表计算由一组在分析中提供上下文的函数组成。它们为扩充的聚合分析提供支持。通过使用这些计算，您可以满足常见的业务方案要求，如计算总数的百分比、运行总和、差值、常见基准和排名。 在分析特定视觉对象中的数据时，您可以将表计算应用于当前数据集，以了解维度如何影响度量或它们如何相互影响。可视化数据是基于当前数据集的结果集，并应用了所有筛选条件、字段选择和自定义项。要查看该结果集的确切内容，您可以将视觉对象导出为文件。表计算函数 对数据执行运算以显示字段之间的关系。 **基于查找的函数** + [https://docs.amazonaws.cn/quicksight/latest/user/difference-function.html](https://docs.amazonaws.cn/quicksight/latest/user/difference-function.html) 计算基于一组分区和排序的度量与基于另一组分区和排序的度量之间的差值。 + [https://docs.amazonaws.cn/quicksight/latest/user/lag-function.html](https://docs.amazonaws.cn/quicksight/latest/user/lag-function.html) 计算度量的滞后（上一个）值。 + [https://docs.amazonaws.cn/quicksight/latest/user/lead-function.html](https://docs.amazonaws.cn/quicksight/latest/user/lead-function.html) 计算度量的前导（下一个）值。 + [https://docs.amazonaws.cn/quicksight/latest/user/percentDifference-function.html](https://docs.amazonaws.cn/quicksight/latest/user/percentDifference-function.html) 计算当前值和比较值之间的百分比差值。 **Over 函数** + [https://docs.amazonaws.cn/quicksight/latest/user/avgOver-function.html](https://docs.amazonaws.cn/quicksight/latest/user/avgOver-function.html) 计算度量在一个或多个维度中的平均值。 + [https://docs.amazonaws.cn/quicksight/latest/user/countOver-function.html](https://docs.amazonaws.cn/quicksight/latest/user/countOver-function.html) 计算字段在一个或多个维度中的计数。 + [https://docs.amazonaws.cn/quicksight/latest/user/distinctCountOver-function.html](https://docs.amazonaws.cn/quicksight/latest/user/distinctCountOver-function.html) 计算指定等级上按指定属性划分的操作数的不同计数。 + [https://docs.amazonaws.cn/quicksight/latest/user/maxOver-function.html](https://docs.amazonaws.cn/quicksight/latest/user/maxOver-function.html) 计算度量在一个或多个维度中的最大值。 + [https://docs.amazonaws.cn/quicksight/latest/user/minOver-function.html](https://docs.amazonaws.cn/quicksight/latest/user/minOver-function.html) 度量在一个或多个维度中的最小值。 + [https://docs.amazonaws.cn/quicksight/latest/user/percentileOver-function.html](https://docs.amazonaws.cn/quicksight/latest/user/percentileOver-function.html)（`percentileDiscOver` 的别名）计算按维度列表分区的度量的第 *n* 个百分位数。 + [https://docs.amazonaws.cn/quicksight/latest/user/percentileContOver-function.html](https://docs.amazonaws.cn/quicksight/latest/user/percentileContOver-function.html) 根据按维度列表分区的度量的数字的连续分布计算第 *n* 个百分位数。 + [https://docs.amazonaws.cn/quicksight/latest/user/percentileDiscOver-function.html](https://docs.amazonaws.cn/quicksight/latest/user/percentileDiscOver-function.html) 根据按维度列表分区的度量的实际数字计算第 *n* 个百分位数。 + [https://docs.amazonaws.cn/quicksight/latest/user/percentOfTotal-function.html](https://docs.amazonaws.cn/quicksight/latest/user/percentOfTotal-function.html) 计算度量在总数中所占的百分比。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodOverPeriodDifference-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodOverPeriodDifference-function.html) 计算按期间粒度和偏移量指定的两个不同时间段内的度量差异。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodOverPeriodLastValue-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodOverPeriodLastValue-function.html) 计算按周期粒度和偏移量指定的上一个时间段中度量的最后一个（上一个）值。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodOverPeriodPercentDifference-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodOverPeriodPercentDifference-function.html) 计算按期间粒度和偏移量指定的两个不同时间段内的度量差异百分比。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodToDateAvgOverTime-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodToDateAvgOverTime-function.html) 计算给定时间粒度（例如一个季度）到某个时间点的度量的平均值。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodToDateCountOverTime-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodToDateCountOverTime-function.html) 计算给定时间粒度（例如一个季度）到某个时间点的维度或度量的计数。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodToDateMaxOverTime-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodToDateMaxOverTime-function.html) 计算给定时间粒度（例如一个季度）到某个时间点的维度或日期的最大值。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodToDateMinOverTime-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodToDateMinOverTime-function.html) 计算给定时间粒度（例如一个季度）到某个时间点的维度或日期的最小值。 + [https://docs.amazonaws.cn/quicksight/latest/user/periodToDateSumOverTime-function.html](https://docs.amazonaws.cn/quicksight/latest/user/periodToDateSumOverTime-function.html) 计算给定时间粒度（例如一个季度）到某个时间点的度量的总和。 + [https://docs.amazonaws.cn/quicksight/latest/user/sumOver-function.html](https://docs.amazonaws.cn/quicksight/latest/user/sumOver-function.html) 计算度量在一个或多个维度中的总和。 + [https://docs.amazonaws.cn/quicksight/latest/user/stdevOver-function.html](https://docs.amazonaws.cn/quicksight/latest/user/stdevOver-function.html) 根据样本计算按选定的一个属性或多个属性划分的指定度量的标准差。 + [https://docs.amazonaws.cn/quicksight/latest/user/stdevpOver-function.html](https://docs.amazonaws.cn/quicksight/latest/user/stdevpOver-function.html) 根据总体偏差计算按选定的一个属性或多个属性划分的指定度量的标准差。 + [https://docs.amazonaws.cn/quicksight/latest/user/varOver-function.html](https://docs.amazonaws.cn/quicksight/latest/user/varOver-function.html) 根据样本计算按选定的一个属性或多个属性划分的指定度量的方差。 + [https://docs.amazonaws.cn/quicksight/latest/user/varpOver-function.html](https://docs.amazonaws.cn/quicksight/latest/user/varpOver-function.html) 根据总体偏差计算按选定的一个属性或多个属性划分的指定度量的方差。 **排名函数** + [https://docs.amazonaws.cn/quicksight/latest/user/rank-function.html](https://docs.amazonaws.cn/quicksight/latest/user/rank-function.html) 计算度量或维度的排名。 + [https://docs.amazonaws.cn/quicksight/latest/user/denseRank-function.html](https://docs.amazonaws.cn/quicksight/latest/user/denseRank-function.html) 计算度量或维度的排名，忽略重复值。 + [https://docs.amazonaws.cn/quicksight/latest/user/percentileRank-function.html](https://docs.amazonaws.cn/quicksight/latest/user/percentileRank-function.html) 根据百分位数计算指标或维度的排名。 **运行函数** + [https://docs.amazonaws.cn/quicksight/latest/user/runningAvg-function.html](https://docs.amazonaws.cn/quicksight/latest/user/runningAvg-function.html) 计算度量的运行平均值。 + [https://docs.amazonaws.cn/quicksight/latest/user/runningCount-function.html](https://docs.amazonaws.cn/quicksight/latest/user/runningCount-function.html) 计算度量的运行计数。 + [https://docs.amazonaws.cn/quicksight/latest/user/runningMax-function.html](https://docs.amazonaws.cn/quicksight/latest/user/runningMax-function.html) 计算度量的运行最大值。 + [https://docs.amazonaws.cn/quicksight/latest/user/runningMin-function.html](https://docs.amazonaws.cn/quicksight/latest/user/runningMin-function.html) 计算度量的运行最小值。 + [https://docs.amazonaws.cn/quicksight/latest/user/runningSum-function.html](https://docs.amazonaws.cn/quicksight/latest/user/runningSum-function.html) 计算度量的运行总和。 **窗口函数** + [https://docs.amazonaws.cn/quicksight/latest/user/firstValue-function.html](https://docs.amazonaws.cn/quicksight/latest/user/firstValue-function.html) 计算按指定属性划分和排序的聚合度量或维度的第一个值。 + [https://docs.amazonaws.cn/quicksight/latest/user/lastValue-function.html](https://docs.amazonaws.cn/quicksight/latest/user/lastValue-function.html) 计算按指定属性划分和排序的聚合度量或维度的最后一个值。 + [https://docs.amazonaws.cn/quicksight/latest/user/windowAvg-function.html](https://docs.amazonaws.cn/quicksight/latest/user/windowAvg-function.html) 计算按指定属性进行分区和排序的自定义窗口中聚合度量的平均值。 + [https://docs.amazonaws.cn/quicksight/latest/user/windowCount-function.html](https://docs.amazonaws.cn/quicksight/latest/user/windowCount-function.html) 计算按指定属性进行分区和排序的自定义窗口中聚合度量的计数。 + [https://docs.amazonaws.cn/quicksight/latest/user/windowMax-function.html](https://docs.amazonaws.cn/quicksight/latest/user/windowMax-function.html) 计算按指定属性进行分区和排序的自定义窗口中聚合度量的最大值。 + [https://docs.amazonaws.cn/quicksight/latest/user/windowMin-function.html](https://docs.amazonaws.cn/quicksight/latest/user/windowMin-function.html) 计算按指定属性进行分区和排序的自定义窗口中聚合度量的最小值。 + [https://docs.amazonaws.cn/quicksight/latest/user/windowSum-function.html](https://docs.amazonaws.cn/quicksight/latest/user/windowSum-function.html) 计算按指定属性进行分区和排序的自定义窗口中聚合度量的总和。 # 函数 在本节中，您可以找到 Amazon Quick 中提供的功能列表。要查看按类别排序的函数列表以及简要定义，请参阅[按类别划分的函数](https://docs.amazonaws.cn/quicksight/latest/user/functions-by-category.html)。 **Topics** + [ # addDateTime ](addDateTime-function.md) + [ # addWorkDays ](addWorkDays-function.md) + [ # Abs ](abs-function.md) + [ # Ceil ](ceil-function.md) + [ # Coalesce ](coalesce-function.md) + [ # Concat ](concat-function.md) + [ # contains ](contains-function.md) + [ # decimalToInt ](decimalToInt-function.md) + [ # dateDiff ](dateDiff-function.md) + [ # endsWith ](endsWith-function.md) + [ # epochDate ](epochDate-function.md) + [ # Exp ](exp-function.md) + [ # Extract ](extract-function.md) + [ # Floor ](floor-function.md) + [ # formatDate ](formatDate-function.md) + [ # Ifelse ](ifelse-function.md) + [ # in ](in-function.md) + [ # intToDecimal ](intToDecimal-function.md) + [ # isNotNull ](isNotNull-function.md) + [ # isNull ](isNull-function.md) + [ # isWorkDay ](isWorkDay-function.md) + [ # Left ](left-function.md) + [ # Locate ](locate-function.md) + [ # Log ](log-function.md) + [ # Ln ](ln-function.md) + [ # Ltrim ](ltrim-function.md) + [ # Mod ](mod-function.md) + [ # netWorkDays ](netWorkDays-function.md) + [ # Now ](now-function.md) + [ # notIn ](notIn-function.md) + [ # nullIf ](nullIf-function.md) + [ # parseDate ](parseDate-function.md) + [ # parseDecimal ](parseDecimal-function.md) + [ # parseInt ](parseInt-function.md) + [ # parseJson ](parseJson-function.md) + [ # Replace ](replace-function.md) + [ # Right ](right-function.md) + [ # Round ](round-function.md) + [ # Rtrim ](rtrim-function.md) + [ # Split ](split-function.md) + [ # Sqrt ](sqrt-function.md) + [ # startsWith ](startsWith-function.md) + [ # Strlen ](strlen-function.md) + [ # Substring ](substring-function.md) + [ # switch ](switch-function.md) + [ # toLower ](toLower-function.md) + [ # toString ](toString-function.md) + [ # toUpper ](toUpper-function.md) + [ # trim ](trim-function.md) + [ # truncDate ](truncDate-function.md) # addDateTime `addDateTime` 在一个日期时间值中加上或减去一个时间单位。例如，`addDateTime(2,'YYYY',parseDate('02-JUL-2018', 'dd-MMM-yyyy') )` 将返回 `02-JUL-2020`。您可以使用该函数对日期和时间数据执行日期运算。 ## 语法 ``` addDateTime(amount, period, datetime) ``` ## Arguments *amount* 一个正或负的整数值，表示您希望在提供的日期时间字段中增加或减少的时间。 *时段* 一个正值或负值，表示您希望在提供的日期时间字段中增加或减少的时间。有效时间段如下所示： + YYYY：返回日期的年份部分。 + Q：返回日期所属的季度（1–4）。 + MM：返回日期的月份部分。 + DD：返回日期的日期部分。 + WK：返回日期的星期部分。在 Amazon Quick 中，本周从周日开始。 + HH：返回日期的小时部分。 + MI：返回日期的分钟部分。 + SS：返回日期的秒部分。 + MS：返回日期的毫秒部分。 *datetime* 您希望执行日期运算的日期或时间。 ## 返回类型 日期时间 ## 示例 假设您具有一个名为 `purchase_date` 并具有以下值的字段。 ``` 2018 May 13 13:24 2017 Jan 31 23:06 2016 Dec 28 06:45 ``` 通过使用以下计算，`addDateTime` 修改这些值，如下所示。 ``` addDateTime(-2, 'YYYY', purchaseDate) 2016 May 13 13:24 2015 Jan 31 23:06 2014 Dec 28 06:45 addDateTime(4, 'DD', purchaseDate) 2018 May 17 13:24 2017 Feb 4 23:06 2017 Jan 1 06:45 addDateTime(20, 'MI', purchaseDate) 2018 May 13 13:44 2017 Jan 31 23:26 2016 Dec 28 07:05 ``` # addWorkDays `addWorkDays` 将指定的工作日数与给定的日期值相加或相减。该函数返回工作日的日期，该日期落在给定输入日期值之后或之前的指定工作日。 ## 语法 ``` addWorkDays(initDate, numWorkDays) ``` ## Arguments *initDate* 用作计算开始日期的有效非 NULL 日期。 + **数据集字段** – 要向其添加此函数的数据集中的任何 `date` 字段。 + **日期函数** – 从其他 `date` 函数输出的任何日期，例如 `parseDate`、`epochDate`、`addDateTime` 等。 **Example** ``` addWorkDays(epochDate(1659484800), numWorkDays) ``` + **计算字段**-任何返回`date`值的快速计算字段。 **Example** ``` calcFieldStartDate = addDateTime(10, “DD”, startDate) addWorkDays(calcFieldStartDate, numWorkDays) ``` + **参数**-任何 Quick `datetime` 参数。 **Example** ``` addWorkDays($paramStartDate, numWorkDays) ``` + 上述参数值的任意组合。 *numWorkDays* 用作计算结束日期的非 NULL 整数。 + **文本** – 直接在表达式编辑器中键入的整数文本。 **Example** ``` ``` + **数据集字段** – 数据集中的任何日期字段 **Example** ``` ``` + **标量函数或计算**-任何从另一个函数返回整数输出的标量 Quick 函数`decimalToInt`，例如`abs`，等等。 **Example** ``` addWorkDays(initDate, decimalToInt(sqrt (abs(numWorkDays)) ) ) ``` + **计算字段**-任何返回`date`值的快速计算字段。 **Example** ``` someOtherIntegerCalcField = (num_days * 2) + 12 addWorkDays(initDate, someOtherIntegerCalcField) ``` + **参数**-任何 Quick `datetime` 参数。 **Example** ``` addWorkDays(initDate, $param_numWorkDays) ``` + 上述参数值的任意组合。 ## 返回类型 整数 ## 输出值 预期的输出值包括： + 正整数（当 start\$1date < end\$1date 时） + 负整数（当 start\$1date > end\$1date 时） + 当其中一个或两个参数从 `dataset field` 中获得空值时，则为 NULL。 ## 输入错误 不允许使用的参数值会导致错误，如以下示例所示。 + 不允许在表达式中使用文本 NULL 作为参数。 **Example** ``` addWorkDays(NULL, numWorkDays) ``` **Example** ``` Error At least one of the arguments in this function does not have correct type. Correct the expression and choose Create again. ``` + 不允许在表达式中使用字符串文本作为参数，或者使用除日期之外的任何其他数据类型。在以下示例中，字符串 **"2022-08-10"** 看起来像日期，但实际上是一个字符串。要使用该字符串，您必须使用可转换为日期数据类型的函数。 **Example** ``` addWorkDays("2022-08-10", 10) ``` **Example** ``` Error Expression addWorkDays("2022-08-10", numWorkDays) for function addWorkDays has incorrect argument type addWorkDays(String, Number). Function syntax expects Date, Integer. ``` ## 示例 正整数作为 `numWorkDays` 参数将生成输入日期将来的日期。负整数作为 `numWorkDays` 参数将生成输入日期过去的结果日期。无论输入日期是工作日还是周末，`numWorkDays` 参数的零值都生成与输入日期相同的值。 `addWorkDays` 函数的运算粒度为：`DAY`。在任何低于或高于 `DAY` 等级的粒度下都无法保持准确度。 ``` addWorkDays(startDate, endDate) ``` 假设有一个名为 `employmentStartDate` 的字段，其值如下： ``` 2022-08-10 2022-08-06 2022-08-07 ``` 使用上面的字段并进行以下计算，`addWorkDays` 返回修改后的值，如下所示： ``` addWorkDays(employmentStartDate, 7) 2022-08-19 2022-08-16 2022-08-16 addWorkDays(employmentStartDate, -5) 2022-08-02 2022-08-01 2022-08-03 addWorkDays(employmentStartDate, 0) 2022-08-10 2022-08-06 2022-08-07 ``` 以下示例根据每位员工的实际工作天数计算 2 年内支付给每位员工的按比例奖金总额。 ``` last_day_of_work = addWorkDays(employment_start_date, 730) total_days_worked = netWorkDays(employment_start_date, last_day_of_work) total_bonus = total_days_worked * bonus_per_day ``` ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/addWorkDays-function-example.png) # Abs `abs` 返回给定表达式的绝对值。 ## 语法 ``` abs(expression) ``` ## Arguments *expression* 表达式必须是数字。它可以是字段名、文本值或其他函数。 # Ceil `ceil` 将小数值向上舍入为大于它的最接近整数。例如，`ceil(29.02)` 将返回 `30`。 ## 语法 ``` ceil(decimal) ``` ## Arguments *decimal* 使用小数数据类型的字段、文本值（如 **17.62**）或对输出小数的其他函数的调用。 ## 返回类型 整数 ## 示例 以下示例将一个小数字段向上舍入为大于它的最接近整数。 ``` ceil(salesAmount) ``` 以下是给定的字段值。 ``` 20.13 892.03 57.54 ``` 对于这些字段值，将返回以下值。 ``` 21 893 58 ``` # Coalesce `coalesce` 返回第一个不为 null 的参数值。当找到非 null 值时，将不计算该列表中的剩余参数。如果所有参数都为 null，则结果为 null。0 长度字符串是有效值，系统不将其等同于 null。 ## 语法 ``` coalesce(expression1, expression2 [, expression3, ...]) ``` ## Arguments `coalesce` 接受两个或多个表达式作为参数。所有表达式必须具有相同的数据类型或能够隐式转换为相同的数据类型。 *expression* 该表达式可以是数字、日期时间或字符串。它可以是字段名、文本值或其他函数。 ## 返回类型 `coalesce` 返回数据类型与输入参数相同的值。 ## 示例 下面的示例检索某位客户的账单地址（如果存在）、其街道地址（如果没有账单地址）或返回“No address listed (未列出地址)”（如果两个地址都不存在）。 ``` coalesce(billingAddress, streetAddress, 'No address listed') ``` # Concat Concat `concat` 连接两个或多个字符串。 ## 语法 ``` concat(expression1, expression2 [, expression3 ...]) ``` ## Arguments `concat` 接受两个或多个字符串表达式作为参数。 *expression* 表达式必须是字符串。它可以是使用字符串数据类型的字段的名称、文本值（如 **'12 Main Street'**）或对输出字符串的其他函数的调用。 ## 返回类型 字符串 ## 示例 以下示例连接三个字符串字段，并添加适当的间距。 ``` concat(salutation, ' ', firstName, ' ', lastName) ``` 以下是给定的字段值。 ``` salutation firstName lastName ------------------------------------------------------- Ms. Li Juan Dr. Ana Carolina Silva Mr. Nikhil Jayashankar ``` 对于这些字段值，将返回以下值。 ``` Ms. Li Juan Dr. Ana Carolina Silva Mr. Nikhil Jayashankar ``` 以下示例连接两个字符串文本值。 ``` concat('Hello', 'world') ``` 将返回以下值。 ``` Helloworld ``` # contains contains `contains` 评估您指定的子字符串是否存在于表达式中。如果表达式包含子字符串，则返回 true，否则返回 false。 ## 语法 ``` contains(expression, substring, string-comparison-mode) ``` ## Arguments *expression* 表达式必须是字符串。它可以是使用字符串数据类型的字段的名称、文本值（如 **'12 Main Street'**）或对输出字符串的其他函数的调用。 *substring* 要根据*表达式*检查的字符集。子字符串可在*表达式*中出现一次或多次。 *string-comparison-mode* （可选）指定要使用的字符串比较模式： + `CASE_SENSITIVE` – 字符串比较区分大小写。 + `CASE_INSENSITIVE` – 字符串比较不区分大小写。 留空时此值默认为 `CASE_SENSITIVE`。 ## 返回类型 布尔值 ## 示例 ### 默认区分大小写的示例 以下区分大小写的示例评估 `state_nm` 是否包含 **New**。 ``` contains(state_nm, "New") ``` 以下是给定的字段值。 ``` New York new york ``` 对于这些字段值，将返回以下值。 ``` true false ``` ### 不区分大小写的示例 以下不区分大小写的示例评估 `state_nm` 是否包含 **new**。 ``` contains(state_nm, "new", CASE_INSENSITIVE) ``` 以下是给定的字段值。 ``` New York new york ``` 对于这些字段值，将返回以下值。 ``` true true ``` ### 带条件语句的示例 包含函数可用作以下 If 函数中的条件语句：[avgIf](https://docs.amazonaws.cn/quicksight/latest/user/avgIf-function.html)、[minIf](https://docs.amazonaws.cn/quicksight/latest/user/minIf-function.html)、[distinct\$1countIf](https://docs.amazonaws.cn/quicksight/latest/user/distinct_countIf-function.html)、[countIf](https://docs.amazonaws.cn/quicksight/latest/user/countIf-function.html)、[maxIf](https://docs.amazonaws.cn/quicksight/latest/user/maxIf-function.html)、[medianIf](https://docs.amazonaws.cn/quicksight/latest/user/medianIf-function.html)、[stdevIf](https://docs.amazonaws.cn/quicksight/latest/user/stdevIf-function.html)、[stdevpIf](https://docs.amazonaws.cn/quicksight/latest/user/stdevpIf-function.html)、[sumIf](https://docs.amazonaws.cn/quicksight/latest/user/sumIf-function.html)、[varIf](https://docs.amazonaws.cn/quicksight/latest/user/varIf-function.html) 和 [varpIf](https://docs.amazonaws.cn/quicksight/latest/user/varpIf-function.html)。 以下示例仅在 `state_nm` 包含 **New** 时才对 `Sales` 进行求和。 ``` sumIf(Sales,contains(state_nm, "New")) ``` ### 不包含示例 条件 `NOT` 运算符可用于评估表达式是否不包含指定的子字符串。 ``` NOT(contains(state_nm, "New")) ``` ### 使用数值的示例 通过应用 `toString` 函数，可以在表达式或子字符串参数中使用数值。 ``` contains(state_nm, toString(5) ) ``` # decimalToInt `decimalToInt` 删除小数点和后面的数字以将小数值转换为整数数据类型。`decimalToInt` 不向上舍入。例如，`decimalToInt(29.99)` 将返回 `29`。 ## 语法 ``` decimalToInt(decimal) ``` ## Arguments *decimal* 使用小数数据类型的字段、文本值（如 **17.62**）或对输出小数的其他函数的调用。 ## 返回类型 整数 ## 示例 以下示例将一个小数字段转换为整数。 ``` decimalToInt(salesAmount) ``` 以下是给定的字段值。 ``` 20.13 892.03 57.54 ``` 对于这些字段值，将返回以下值。 ``` 20 892 57 ``` # dateDiff `dateDiff` 返回两个日期字段相差的天数。如果包含期间的值，则 `dateDiff` 返回期间间隔中的差异，而不是天数差异。 ## 语法 ``` dateDiff(date1, date2,[period]) ``` ## Arguments `dateDiff` 接受两个日期作为参数。指定期间是可选的。 *日期 1* 比较中的第一个日期。它可以是日期字段，也可以是对输出日期的其他函数的调用。 *日期 2* 比较中的第二个日期。它可以是日期字段，也可以是对输出日期的其他函数的调用。 *时段* 要返回的差异的期间（用引号括起来）。有效时间段如下所示： + YYYY：返回日期的年份部分。 + 问：这将返回日期所属季度的第一天的日期。 + MM：返回日期的月份部分。 + DD：返回日期的日期部分。 + WK：返回日期的星期部分。在 Amazon Quick 中，本周从周日开始。 + HH：返回日期的小时部分。 + MI：返回日期的分钟部分。 + SS：返回日期的秒部分。 + MS：返回日期的毫秒部分。 ## 返回类型 整数 ## 示例 以下示例返回两个日期相差的天数。 ``` dateDiff(orderDate, shipDate, "MM") ``` 以下是给定的字段值。 ``` orderDate shipdate ============================= 01/01/18 03/05/18 09/13/17 10/20/17 ``` 对于这些字段值，将返回以下值。 ``` 2 1 ``` # endsWith endsWith `endsWith` 评估表达式是否以您指定的子字符串结尾。如果表达式以子字符串结尾，`endsWith` 返回 true，否则返回 false。 ## 语法 ``` endsWith(expression, substring, string-comparison-mode) ``` ## Arguments *expression* 表达式必须是字符串。它可以是使用字符串数据类型的字段的名称、文本值（如 **'12 Main Street'**）或对输出字符串的其他函数的调用。 *substring* 要根据*表达式*检查的字符集。子字符串可在*表达式*中出现一次或多次。 *string-comparison-mode* （可选）指定要使用的字符串比较模式： + `CASE_SENSITIVE` – 字符串比较区分大小写。 + `CASE_INSENSITIVE` – 字符串比较不区分大小写。 留空时此值默认为 `CASE_SENSITIVE`。 ## 返回类型 布尔值 ## 示例 ### 默认区分大小写的示例 以下区分大小写的示例评估 `state_nm` 是否以 **"York"** 结尾。 ``` endsWith(state_nm, "York") ``` 以下是给定的字段值。 ``` New York new york ``` 对于这些字段值，将返回以下值。 ``` true false ``` ### 不区分大小写的示例 以下不区分大小写的示例评估 `state_nm` 是否以 **"york"** 结尾。 ``` endsWith(state_nm, "york", CASE_INSENSITIVE) ``` 以下是给定的字段值。 ``` New York new york ``` 对于这些字段值，将返回以下值。 ``` true true ``` ### 带条件语句的示例 `endsWith` 函数可用作以下 If 函数中的条件语句：[avgIf](https://docs.amazonaws.cn/quicksight/latest/user/avgIf-function.html)、[minIf](https://docs.amazonaws.cn/quicksight/latest/user/minIf-function.html)、[distinct\$1countIf](https://docs.amazonaws.cn/quicksight/latest/user/distinct_countIf-function.html)、[countIf](https://docs.amazonaws.cn/quicksight/latest/user/countIf-function.html)、[maxIf](https://docs.amazonaws.cn/quicksight/latest/user/maxIf-function.html)、[medianIf](https://docs.amazonaws.cn/quicksight/latest/user/medianIf-function.html)、[stdevIf](https://docs.amazonaws.cn/quicksight/latest/user/stdevIf-function.html)、[stdevpIf](https://docs.amazonaws.cn/quicksight/latest/user/stdevpIf-function.html)、[sumIf](https://docs.amazonaws.cn/quicksight/latest/user/sumIf-function.html)、[varIf](https://docs.amazonaws.cn/quicksight/latest/user/varIf-function.html) 和 [varpIf](https://docs.amazonaws.cn/quicksight/latest/user/varpIf-function.html)。 以下示例仅在 `state_nm` 以 **"York"** 结尾为时才对 `Sales` 进行求和。 ``` sumIf(Sales,endsWith(state_nm, "York")) ``` ### 不包含示例 条件 `NOT` 运算符可用于评估表达式是否不以指定的子字符串开头。 ``` NOT(endsWith(state_nm, "York")) ``` ### 使用数值的示例 通过应用 `toString` 函数，可以在表达式或子字符串参数中使用数值。 ``` endsWith(state_nm, toString(5) ) ``` # epochDate `epochDate`[使用 Joda 项目文档中类中指定的格式模式语法，将纪元日期转换为 yyyy-mm-dd **T** kk: mm: ss.sss **Z** 格式的标准日期。 DateTimeFormat](http://www.joda.org/joda-time/apidocs/org/joda/time/format/DateTimeFormat.html)例如，`2015-10-15T19:11:51.003Z`。 `epochDate`支持与基于 Quick (SPICE) 中存储的数据集的分析一起使用。 ## 语法 ``` epochDate(epochdate) ``` ## Arguments *epochdate* 一个纪元日期，它是以整数 (自 1970 年 1 月 1 日 00:00:00 UTC 以来经过的秒数) 形式表示的日期。 *epochdate* 必须为整数。它可以是使用整数数据类型的字段的名称、字面整数值，也可以是对输出整数的其他函数的调用。如果整数值大于 10 位数，则会丢弃第 10 位以后的数字。 ## 返回类型 日期 ## 示例 以下示例将纪元日期转换为标准日期。 ``` epochDate(3100768000) ``` 将返回以下值。 ``` 2068-04-04T12:26:40.000Z ``` # Exp `exp` 返回以自然常数 e 为底且以给定表达式为幂的值。 ## 语法 ``` exp(expression) ``` ## Arguments *expression* 表达式必须是数字。它可以是字段名、文本值或其他函数。 # Extract `extract` 返回日期值的指定部分。如果对不包含时间信息的日期发出时间相关部分请求，则返回 0。 ## 语法 ``` extract(period, date) ``` ## Arguments *时段* 希望从日期值中提取的时间段。有效时间段如下所示： + YYYY：返回日期的年份部分。 + Q：返回日期所属的季度（1–4）。 + MM：返回日期的月份部分。 + DD：返回日期的日期部分。 + WD：返回周日期 (以整数表示，星期日为 1)。 + HH：返回日期的小时部分。 + MI：返回日期的分钟部分。 + SS：返回日期的秒部分。 + MS：返回日期的毫秒部分。 **注意** 在版本 0.216 以下的 Presto 数据库中，不支持提取毫秒。 *date* 它可以是日期字段，也可以是对输出日期的其他函数的调用。 ## 返回类型 整数 ## 示例 以下示例从日期值中提取日期。 ``` extract('DD', orderDate) ``` 以下是给定的字段值。 ``` orderDate ========= 01/01/14 09/13/16 ``` 对于这些字段值，将返回以下值。 ``` 01 13 ``` # Floor `floor` 将小数值向下舍入到小于它的最接近整数。例如，`floor(29.08)` 将返回 `29`。 ## 语法 ``` floor(decimal) ``` ## Arguments *decimal* 使用小数数据类型的字段、文本值（如 **17.62**）或对输出小数的其他函数的调用。 ## 返回类型 整数 ## 示例 以下示例将一个小数字段向下舍入为小于它的最接近整数。 ``` floor(salesAmount) ``` 以下是给定的字段值。 ``` 20.13 892.03 57.54 ``` 对于这些字段值，将返回以下值。 ``` 20 892 57 ``` # formatDate `formatDate` 使用您指定的模式格式化日期。在准备数据时，可以使用 `formatDate` 重新格式化日期。要在分析中重新格式化日期，请从日期字段的上下文菜单中选择格式选项。 ## 语法 ``` formatDate(date, ['format']) ``` ## Arguments *date* 它可以是日期字段，也可以是对输出日期的其他函数的调用。 *format* (可选) 包含要应用的格式模式的字符串。此参数接受[支持的日期格式中指定的格式](https://docs.amazonaws.cn/quicksight/latest/user/supported-date-formats.html)模式。 如果不指定格式，则此字符串默认为 yyyy-MM-dd**T**kk:mm:ss:SSS 格式。 ## 返回类型 字符串 ## 示例 以下示例设置 UTC 日期的格式。 ``` formatDate(orderDate, 'dd-MMM-yyyy') ``` 以下是给定的字段值。 ``` order date ========= 2012-12-14T00:00:00.000Z 2013-12-29T00:00:00.000Z 2012-11-15T00:00:00.000Z ``` 对于这些字段值，将返回以下值。 ``` 13 Dec 2012 28 Dec 2013 14 Nov 2012 ``` ## 示例 如果日期包含单引号或撇号，例如 `yyyyMMdd'T'HHmmss`，则可以使用以下方法之一来处理此日期格式。 + 使用双引号括住整个日期，如以下示例所示： ``` formatDate({myDateField}, "yyyyMMdd'T'HHmmss") ``` + 通过在单引号或撇号的左侧添加反斜杠 (`\`) 来转义单引号或撇号，如以下示例所示： ``` formatDate({myDateField}, 'yyyyMMdd\'T\'HHmmss') ``` # Ifelse `ifelse` 对一组 *if*/*then* 表达式对进行计算，并返回计算结果为 true 的第一个 *if* 参数的 *then* 参数值。如果所有 *if* 参数的计算结果都不为 true，则返回 *else* 参数的值。 ## 语法 ``` ifelse(if-expression-1, then-expression-1 [, if-expression-n, then-expression-n ...], else-expression) ``` ## Arguments `ifelse` 需要一个或多个 *if*/*then* 表达式对，*else* 参数只需要一个表达式。 *if-expression* 表达式的计算结果为 true 或 false。它可以是字段名称（如 **address1**）、文本值（如 **'Unknown'**）或其他函数（如 `toString(salesAmount)`）。例如，`isNotNull(FieldName)`。 如果您在 `if` 参数中使用了多个 AND 和 OR 运算符，请给语句加上括号以确定处理顺序。例如，以下 `if` 参数返回 2000 年 1、2 或 5 月份的记录。 ``` ifelse((month = 5 OR month < 3) AND year = 2000, 'yes', 'no') ``` 以下 `if` 参数使用相同的运算符，但返回任意年份的 5 月份的记录，或者返回 2000 年 1 或 2 月份的记录。 ``` ifelse(month = 5 OR (month < 3 AND year = 2000), 'yes', 'no') ``` *then-expression* 在 *if* 参数的计算结果为 true 时，将返回该表达式。它可以是字段名称（如 **address1**）、文本值（如 **'Unknown'**）或对其他函数的调用。该表达式的数据类型必须与其他 `then` 参数和 `else` 参数相同。 *else-expression* 该表达式在所有 *if* 参数的计算结果都不为 true 时返回。它可以是字段名称（如 **address1**）、文本值（如 **'Unknown'**）或其他函数（如 `toString(salesAmount)`）。该表达式的数据类型必须与所有 `then` 参数相同。 ## 返回类型 `ifelse` 返回与 *then-expression* 中的值具有相同数据类型的值。*then* 和 *else* 表达式返回的所有数据都必须是相同的数据类型或转换为相同的数据类型。 ## 示例 以下示例为字段 `country` 生成一列别名。 ``` ifelse(country = "United States", "US", country = "China", "CN", country = "India", "IN", "Others") ``` 对于此类用例，根据文本列表评估字段中的每个值，并返回与第一个匹配值相对应的结果，建议使用函数 switch 来简化您的工作。可以使用 [https://docs.amazonaws.cn/quicksight/latest/user/switch-function.html](https://docs.amazonaws.cn/quicksight/latest/user/switch-function.html) 将前面的示例重写为以下语句： ``` switch(country,"United States","US","China","CN","India","IN","Others") ``` 以下示例将每位客户的销售额归类为人类可读的级别。 ``` ifelse(salesPerCustomer < 1000, “VERY_LOW”, salesPerCustomer < 10000, “LOW”, salesPerCustomer < 100000, “MEDIUM”, “HIGH”) ``` 以下示例使用 AND、OR 和 NOT 来比较多个表达式，表达式中使用了条件运算符，以标记不在华盛顿或俄勒冈州、享受特别促销并且订单超过 10 个的最大客户。如果没有返回值，则使用值 `'n/a'`。 ``` ifelse(( (NOT (State = 'WA' OR State = 'OR')) AND Orders > 10), 'Special Promotion XYZ', 'n/a') ``` 以下示例仅使用 OR 生成一个新列，该列包含与每个 `country` 对应的大洲名称。 ``` ifelse(country = "United States" OR country = "Canada", "North America", country = "China" OR country = "India" OR country = "Japan", "Asia", "Others") ``` 可以简化前面的示例，如下一个示例所示。以下示例使用 `ifelse` 和 [https://docs.amazonaws.cn/quicksight/latest/user/in-function.html](https://docs.amazonaws.cn/quicksight/latest/user/in-function.html) 在新列中为测试值位于文本列表中的任何行创建值。您也可以将 `ifelse` 与 [https://docs.amazonaws.cn/quicksight/latest/user/notIn-function.html](https://docs.amazonaws.cn/quicksight/latest/user/notIn-function.html) 搭配使用。 ``` ifelse(in(country,["United States", "Canada"]), "North America", in(country,["China","Japan","India"]),"Asia","Others") ``` 作者可以将文本列表保存在多值参数中，并在 [https://docs.amazonaws.cn/quicksight/latest/user/in-function.html](https://docs.amazonaws.cn/quicksight/latest/user/in-function.html) 或 [https://docs.amazonaws.cn/quicksight/latest/user/notIn-function.html](https://docs.amazonaws.cn/quicksight/latest/user/notIn-function.html) 函数中使用该参数。除了文本列表存储在两个多值参数中之外，以下示例与前面的示例相同。 ``` ifelse(in(country,${NorthAmericaCountryParam}), "North America", in(country,${AsiaCountryParam}),"Asia", "Others") ``` 以下示例根据销售总额为销售记录分配一个组。每个 `if-then` 短语的结构都模仿了 *between* 的行为，这个关键字目前在计算字段表达式中不起作用。例如，比较 `salesTotal >= 0 AND salesTotal < 500` 的结果返回的值与 SQL 比较 `salesTotal between 0 and 499` 的值相同。 ``` ifelse(salesTotal >= 0 AND salesTotal < 500, 'Group 1', salesTotal >= 500 AND salesTotal < 1000, 'Group 2', 'Group 3') ``` 以下示例通过使用 `coalesce` 返回第一个非 NULL 值来测试 NULL 值。无需记住日期字段中 NULL 的含义，而是可以使用可读的描述来代替。如果断开连接日期为 NULL，则该示例将返回暂停日期，除非这两个日期均为 NULL。然后 `coalesce(DiscoDate, SuspendDate, '12/31/2491')` 返回 `'12/31/2491'`。返回值必须与其他数据类型匹配。这个日期可能看起来像是一个不寻常的值，但是 25 世纪的日期合理地模拟了“时间结束”，即数据集市中的最高日期。 ``` ifelse ( (coalesce(DiscoDate, SuspendDate, '12/31/2491') = '12/31/2491'), 'Active subscriber', 'Inactive subscriber') ``` 以下内容以更具可读性的格式显示了一个更复杂的示例，只是为了说明您不需要将代码全部压缩成一长行。此示例提供了对调查结果值的多重比较。它处理此字段的潜在 NULL 值，并对两个可接受的范围进行分类。它还会标记一个需要更多测试的范围和另一个无效（超出范围）的范围。对于所有剩余值，它会应用 `else` 条件，并将该行标记为在该行上的日期三年后需要重新测试。 ``` ifelse ( isNull({SurveyResult}), 'Untested', {SurveyResult}=1, 'Range 1', {SurveyResult}=2, 'Range 2', {SurveyResult}=3, 'Need more testing', {SurveyResult}=99, 'Out of Range', concat ( 'Retest by ', toString ( addDateTime(3, "YYYY", {Date}) ) ) ) ``` 以下示例将“手动”创建的区域名称分配给一组州。它还使用空格和 `/* */` 中包装的注释来简化代码的维护。 ``` ifelse ( /* NE REGION*/ locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0, 'Northeast', /* SE REGION*/ locate('Georgia, Alabama, South Carolina, Louisiana',{State}) > 0, 'Southeast', 'Other Region' ) ``` 区域标记的逻辑分解如下： 1. 我们列出了要为每个区域设置的州，用引号将每个列表括起来，使每个列表成为一个字符串，如下所示： + `'New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire'` + `'Georgia, Alabama, South Carolina, Louisiana'` + 您可以添加更多设置，也可以根据需要使用国家/地区、城市、省份或 What3Words。 1. 我们询问列表中是否找到了 `State`（每行）的值，如果在列表中找到该州，则使用 `locate` 函数返回一个非零值，如下所示。 ``` locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) and locate('Georgia, Alabama, South Carolina, Louisiana',{State}) ``` 1. `locate` 函数返回的是数字而不是 `TRUE` 或 `FALSE`，但 `ifelse` 需要使用 `TRUE`/`FALSE` 布尔值。为了解决这个问题，我们可以将 `locate` 的结果与一个数字进行比较。如果该州在列表中，则返回值大于零。 1. 询问该州是否存在。 ``` locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0 ``` 1. 如果存在该区域，则将其标记为特定区域，在本例中为东北区域。 ``` /*The if expression:*/ locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0, /*The then expression:*/ 'Northeast', ``` 1. 因为我们有不在列表中的州，也因为 `ifelse` 需要单个 `else` 表达式，所以我们提供 `'Other Region'` 作为剩余州的标签。 ``` /*The if expression:*/ locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0, /*The then expression:*/ 'Northeast', /*The else expression:*/ 'Other Region' ``` 1. 我们将所有这些都包装在 `ifelse( )` 函数中以获得最终版本。以下示例省略了原始版本中的东南区域的州。您可以重新添加这些州来代替 *``* 标签。 如果要添加更多区域，则可以构造这两行的更多副本，并根据自己的目的更改州列表。您可以将区域名称更改为适合自己的名称，也可以将字段名称从 `State` 更改为所需的任何名称。 ``` ifelse ( /*The if expression:*/ locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0, /*The then expression:*/ 'Northeast', /**/ /*The else expression:*/ 'Other Region' ) ``` **注意** 还有其他方法可以对 if 表达式进行初始比较。例如，假设您提出了一个问题：“这个列表中没有缺少哪些州？” 而不是“列表上有哪些州？” 如果您这样做，可能会用不同的措辞。您可以将 locate 语句与零进行比较以查找列表中缺少的值，然后使用 NOT 运算符将它们归类为“未缺失”，如下所示。 ``` /*The if expression:*/ NOT (locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) = 0), ``` 两个版本都是正确的。您选择的版本应该对您和您的团队最有意义，这样您就可以轻松对其进行维护。如果所有选项看起来都相同，请选择最简单的选项。 # in in `in` 评估文本列表中是否存在表达式。如果列表包含表达式，则返回 true，否则返回 false。对于字符串类型输入，`in` 区分大小写。 `in` 接受两种文本列表，一种是手动输入的列表，另一种是[多值参数](https://docs.amazonaws.cn/quicksight/latest/user/parameters-in-quicksight.html)。 ## 语法 使用手动输入的列表： ``` in(expression, [literal-1, ...]) ``` 使用多值参数： ``` in(expression, $multivalue_parameter) ``` ## 参数 *expression* 要与文本列表中的元素进行比较的表达式。可以是字段名称（例如 `address`）、字面值（例如“**Unknown**”）、单值参数或对另一个标量函数的调用，前提是此函数不是聚合函数或表计算。 *文本列表* （必填）这可以是手动输入的列表或多值参数。此参数最多接受 5,000 个元素。但是，在直接查询第三方数据来源（例如 Oracle 或 Teradata）时，限制可能会更小。 + ***手动输入的列表*** – 列表中的一个或多个要与表达式进行比较的文本值。列表应用方括号括起来。所有要比较的文本必须与表达式具有相同的数据类型。 + ***多值参数*** – 作为文本列表传入的预定义多值参数。多值参数必须与表达式具有相同的数据类型。 ## 返回类型 布尔值：TRUE/FALSE ## 使用静态列表的示例 以下示例评估 `origin_state_name` 字段的字符串列表中的值。比较字符串类型输入时，`in` 仅支持区分大小写的比较。 ``` in(origin_state_name,["Georgia", "Ohio", "Texas"]) ``` 以下是给定的字段值。 ``` "Washington" "ohio" "Texas" ``` 对于这些字段值，将返回以下值。 ``` false false true ``` 第三个返回值为 true，因为只有“Texas”是包含的值之一。 以下示例评估 `fl_date` 字段的字符串列表中的值。为了匹配类型，`toString` 用于将日期类型转换为字符串类型。 ``` in(toString(fl_date),["2015-05-14","2015-05-15","2015-05-16"]) ``` ![\[函数示例结果的图像，以表格形式显示。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/in-function-example-manual-list.png) 表达式参数中支持文本和 NULL 值，以便与列表中的文本进行比较。以下两个示例都将生成一列 TRUE 值的新列。 ``` in("Washington",["Washington","Ohio"]) ``` ``` in(NULL,[NULL,"Ohio"]) ``` ## 使用多值参数的示例 假设作者创建了一个包含所有州名列表的[多值参数](https://docs.amazonaws.cn/quicksight/latest/user/parameters-in-quicksight.html)。然后，作者添加了一个控件，允许读者从列表中选择值。 接下来，读者从参数的下拉列表控件中选择三个值，即“Georgia”、“Ohio”和“Texas”。在本例中，以下表达式等同于第一个示例，其中这三个州名称作为文本列表传递，以便与 `original_state_name` 字段进行比较。 ``` in (origin_state_name, ${stateName MultivalueParameter}) ``` ## 使用 `ifelse` 的示例 `in` 可以作为布尔值嵌套在其他函数中。一个例子是，作者可以计算列表中的任何表达式并使用 `in` 和 `ifelse` 返回他们想要的值。以下示例评估航班的 `dest_state_name` 是否位于特定的美国州列表中，并根据比较结果返回不同的州类别。 ``` ifelse(in(dest_state_name,["Washington", "Oregon","California"]), "WestCoastUSState", "Other US State") ``` ![\[函数示例结果的图像，以表格形式显示。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/in-function-with-ifelse.png) # intToDecimal `intToDecimal` 将整数值转换为小数数据类型。 ## 语法 ``` intToDecimal(integer) ``` ## Arguments *int* 使用整数数据类型的字段、文本值（如 **14**）或对输出整数的其他函数的调用。 ## 返回类型 传统数据准备体验中的十进制（固定）。 全新的数据准备体验中的十进制（浮点型）。 ## 示例 以下示例将一个整数字段转换为小数。 ``` intToDecimal(price) ``` 以下是给定的字段值。 ``` 20 892 57 ``` 对于这些字段值，将返回以下值。 ``` 20.0 892.0 58.0 ``` 您可以在分析中应用任意格式设置，例如，将 `price` 格式化为货币。 # isNotNull `isNotNull` 对表达式求值以确定其是否为 null。如果表达式不为 null，`isNotNull` 将返回 true，否则，将返回 false。 ## 语法 ``` isNotNull(expression) ``` ## Arguments *expression* 表达式的计算结果为 null 或非 null。它可以是字段名称（如 **address1**）或对输出字符串的其他函数的调用。 ## 返回类型 布尔值 ## 示例 以下示例计算 sales\$1amount 字段的值是否为 null。 ``` isNotNull(salesAmount) ``` 以下是给定的字段值。 ``` 20.13 (null) 57.54 ``` 对于这些字段值，将返回以下值。 ``` true false true ``` # isNull `isNull` 对表达式求值以确定其是否为 null。如果表达式为 null，`isNull` 将返回 true，否则，将返回 false。 ## 语法 ``` isNull(expression) ``` ## Arguments *expression* 表达式的计算结果为 null 或非 null。它可以是字段名称（如 **address1**）或对输出字符串的其他函数的调用。 ## 返回类型 布尔值 ## 示例 以下示例计算 sales\$1amount 字段的值是否为 null。 ``` isNull(salesAmount) ``` 以下是给定的字段值。 ``` 20.13 (null) 57.54 ``` 对于这些字段值，将返回以下值。 ``` false true false ``` 以下示例测试 `ifelse` 语句中的 NULL 值，改为返回人类可读的值。 ``` ifelse( isNull({ActiveFlag}) , 'Inactive', 'Active') ``` # isWorkDay `isWorkDay` 评估给定的日期时间值以确定该值是否为工作日。 `isWorkDay` 假设标准每周工作 5 天，从星期一开始，到星期五结束。假设星期六和星期日为周末。该函数始终按 `DAY` 粒度计算其结果，并且不包括给定的输入日期。 ## 语法 ``` isWorkDay(inputDate) ``` ## Arguments *inputDate* 要评估的日期时间值。有效值如下所示： + 数据集字段：要向其添加此函数的数据集中的任何 `date` 字段。 + 日期函数：从其他 `date` 函数输出的任何日期，例如，`parseDate`。 + 计算字段：任何返回`date`值的快速计算字段。 + 参数：任何 Quick `DateTime` 参数。 ## 返回类型 整数（`0` 或 `1`） ## 示例 以下示例确定 `application_date` 字段是否为工作日。 假设有一个名为 `application_date` 的字段，其值如下： ``` 2022-08-10 2022-08-06 2022-08-07 ``` 当您使用这些字段并添加以下计算时，`isWorkDay` 返回以下值： ``` isWorkDay({application_date}) 1 0 0 ``` 以下示例使用条件格式筛选在工作日结束雇佣的员工，并确定他们的雇佣是在工作日还是周末开始： ``` is_start_date_work_day = isWorkDay(employment_start_date) is_end_date_work_day = isWorkDay(employment_end_date) ``` ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/isWorkDay-example.png) # Left 靠左对齐 `left` 返回字符串最左侧的字符，包括空格。您可以指定要返回的字符数。 ## 语法 ``` left(expression, limit) ``` ## Arguments *expression* 表达式必须是字符串。它可以是使用字符串数据类型的字段的名称、文本值（如 **'12 Main Street'**）或对输出字符串的其他函数的调用。 *limit* 要从 *expression* 返回的字符数，从字符串中的第一个字符开始。 ## 返回类型 字符串 ## 示例 以下示例返回字符串中的前 3 个字符。 ``` left('Seattle Store #14', 3) ``` 将返回以下值。 ``` Sea ``` # Locate Locate `locate` 查找您在一个字符串中指定的子字符串，并返回子字符串的第一个字符在该字符串中的位置。如果未找到子字符串，该函数将返回 0。该函数以 1 为基准。 ## 语法 ``` locate(expression, substring, start) ``` ## Arguments *expression* 表达式必须是字符串。它可以是使用字符串数据类型的字段的名称、文本值（如 **'12 Main Street'**）或对输出字符串的其他函数的调用。 *substring* 您要在 *expression* 中查找的一组字符。子字符串可在 *expression* 中出现一次或多次。 *start* (可选) 如果 *substring* 出现多次，请使用 *start* 确定该函数应从字符串中的哪一位置开始查找子字符串。例如，假设您要查找某个子字符串的第二个示例，并且您认为它通常会出现在前 10 个字符之后，则指定 *start* (开始) 值为 10。应该从 1 开始。 ## 返回类型 整数 ## 示例 以下示例返回有关子字符串“and”在字符串中首次出现的位置的信息。 ``` locate('1 and 2 and 3 and 4', 'and') ``` 将返回以下值。 ``` 3 ``` 以下示例返回有关子字符串“and”在字符串中第四个字符后首次出现的位置的信息。 ``` locate('1 and 2 and 3 and 4', 'and', 4) ``` 将返回以下值。 ``` 9 ``` # Log `log` 返回给定表达式的以 10 为底的对数。 ## 语法 ``` log(expression) ``` ## Arguments *expression* 表达式必须是数字。它可以是字段名、文本值或其他函数。 # Ln `ln` 返回给定表达式的自然对数。 ## 语法 ``` ln(expression) ``` ## Arguments *expression* 表达式必须是数字。它可以是字段名、文本值或其他函数。 # Ltrim Ltrim `ltrim` 从字符串中移除前置空格。 ## 语法 ``` ltrim(expression) ``` ## Arguments *expression* 表达式必须是字符串。它可以是使用字符串数据类型的字段的名称、文本值（如 **'12 Main Street'**）或对输出字符串的其他函数的调用。 ## 返回类型 字符串 ## 示例 以下示例从字符串中删除前置空格。 ``` ltrim(' Seattle Store #14') ``` 将返回以下值。 ``` Seattle Store #14 ``` # Mod 使用 `mod` 函数查找将一个数字除以除数之后的余数。您可以互换使用 `mod` 函数或取模运算符 (%)。 ## 语法 ``` mod(number, divisor) ``` ``` number%divisor ``` ## Arguments *number* 数字是您要除以并查找其余数的正整数。 *除数* 除数是您要除的正整数。如果除数为零，则此函数将返回除以 0 错误。 ## 示例 以下示例返回 17 除以 6 时的取模。第一个示例使用 % 运算符，第二个示例使用 mod 函数。 ``` 17%6 ``` ``` mod( 17, 6 ) ``` 将返回以下值。 ``` 5 ``` # netWorkDays `netWorkDays`返回提供的两个日期字段之间的工作日数，甚至返回使用其他快速日期函数（例如`parseDate`或`epochDate`作为整数）生成的自定义日期值。 `netWorkDays` 假设标准每周工作 5 天，从星期一开始，到星期五结束。假设星期六和星期日为周末。计算结果包括 `startDate` 和 `endDate`。该函数运行并显示 DAY 粒度的结果。 ## 语法 ``` netWorkDays(startDate, endDate) ``` ## Arguments *startDate* 用作计算开始日期的有效非 NULL 日期。 + 数据集字段：要向其添加此函数的数据集中的任何 `date` 字段。 + 日期函数：从其他 `date` 函数输出的任何日期，例如，`parseDate`。 + 计算字段：任何返回`date`值的快速计算字段。 + 参数：任何 Quick `DateTime` 参数。 + 上述参数值的任意组合。 *endDate* 用作计算结束日期的有效非 NULL 日期。 + 数据集字段：要向其添加此函数的数据集中的任何 `date` 字段。 + 日期函数：从其他 `date` 函数输出的任何日期，例如，`parseDate`。 + 计算字段：任何返回`date`值的快速计算字段。 + 参数：任何 Quick `DateTime` 参数。 + 上述参数值的任意组合。 ## 返回类型 整数 ## 输出值 预期的输出值包括： + 正整数（当 start\$1date < end\$1date 时） + 负整数（当 start\$1date > end\$1date 时） + 当其中一个或两个参数从 `dataset field` 中获得空值时，则为 NULL。 ## 示例 以下示例返回介于两个日期之间的工作日数。 假设有一个名为 `application_date` 的字段，其值如下： ``` netWorkDays({startDate}, {endDate}) ``` 以下是给定的字段值。 ``` startDate endDate netWorkDays 9/4/2022 9/11/2022 5 9/9/2022 9/2/2022 -6 9/10/2022 9/11/2022 0 9/12/2022 9/12/2022 1 ``` 以下示例计算每位员工的工作天数和为每位员工每天支出的工资： ``` days_worked = netWorkDays({employment_start_date}, {employment_end_date}) salary_per_day = {salary}/{days_worked} ``` 以下示例使用条件格式筛选在工作日结束雇佣的员工，并确定他们的雇佣是在工作日还是周末开始： ``` is_start_date_work_day = netWorkDays(employment_start_date) is_end_date_work_day = netWorkDays(employment_end_date) ``` ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/netWorkDays-function-example.png) # Now 对于直接查询数据库的数据库数据集，`now` 使用数据库服务器指定的设置和格式返回当前日期和时间。对于 SPICE 和 Salesforce 数据集，`now` 会返回 UTC 日期和时间，格式为 `yyyy-MM-ddTkk:mm:ss:SSSZ`（例如，2015-10-15T19:11:51:003Z）。 ## 语法 ``` now() ``` ## 返回类型 日期 # notIn notIn `notIn` 评估文本列表中是否存在表达式。如果列表不包含表达式，`notIn` 返回 true，否则返回 false。对于字符串类型输入，`notIn` 区分大小写。 `notIn` 接受两种文本列表，一种是手动输入的列表，另一种是[多值参数](https://docs.amazonaws.cn/quicksight/latest/user/parameters-in-quicksight.html)。 ## 语法 使用手动输入的列表： ``` notIn(expression, [literal-1, ...]) ``` 使用多值参数： ``` notIn(expression, $multivalue_parameter) ``` ## 参数 *expression* 要与文本列表中的元素进行比较的表达式。可以是字段名称（例如 `address`）、字面值（例如“**Unknown**”）、单值参数或对另一个标量函数的调用，前提是此函数不是聚合函数或表计算。 *文本列表* （必填）这可以是手动输入的列表或多值参数。此参数最多接受 5,000 个元素。但是，在直接查询第三方数据来源（例如 Oracle 或 Teradata）时，限制可能会更小。 + ***手动输入的列表*** – 列表中的一个或多个要与表达式进行比较的文本值。列表应用方括号括起来。所有要比较的文本必须与表达式具有相同的数据类型。 + ***多值参数*** – 作为文本列表传入的预定义多值参数。多值参数必须与表达式具有相同的数据类型。 ## 返回类型 布尔值：TRUE/FALSE ## 使用手动输入列表的示例 以下示例评估 `origin_state_name` 字段的字符串列表中的值。比较字符串类型输入时，`notIn` 仅支持区分大小写的比较。 ``` notIn(origin_state_name,["Georgia", "Ohio", "Texas"]) ``` 以下是给定的字段值。 ``` "Washington" "ohio" "Texas" ``` 对于这些字段值，将返回以下值。 ``` true true false ``` 第三个返回值为 false，因为只有“Texas”是排除的值之一。 以下示例评估 `fl_date` 字段的字符串列表中的值。为了匹配类型，`toString` 用于将日期类型转换为字符串类型。 ``` notIn(toString(fl_date),["2015-05-14","2015-05-15","2015-05-16"]) ``` ![\[函数示例结果的图像，以表格形式显示。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/notin-function-example-manual-list.png) 表达式参数中支持文本和 NULL 值，以便与列表中的文本进行比较。以下两个示例都将生成一列 FALSE 值的新列。 ``` notIn("Washington",["Washington","Ohio"]) ``` ``` notIn(NULL,[NULL,"Ohio"]) ``` ## 使用多值参数的示例 假设作者创建了一个包含所有州名列表的[多值参数](https://docs.amazonaws.cn/quicksight/latest/user/parameters-in-quicksight.html)。然后，作者添加了一个控件，允许读者从列表中选择值。 接下来，读者从参数的下拉列表控件中选择三个值，即“Georgia”、“Ohio”和“Texas”。在本例中，以下表达式等同于第一个示例，其中这三个州名称作为文本列表传递，以便与 `original_state_name` 字段进行比较。 ``` notIn (origin_state_name, ${stateName MultivalueParameter}) ``` ## 使用 `ifelse` 的示例 `notIn` 可以作为布尔值嵌套在其他函数中。一个例子是，作者可以计算列表中的任何表达式并使用 `notIn` 和 `ifelse` 返回他们想要的值。以下示例评估航班的 `dest_state_name` 是否位于特定的美国州列表中，并根据比较结果返回不同的州类别。 ``` ifelse(notIn(dest_state_name,["Washington", "Oregon","California"]), "notWestCoastUSState", "WestCoastUSState") ``` ![\[函数示例结果的图像，以表格形式显示。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/notin-function-with-ifelse.png) # nullIf `nullIf` 比较两个表达式。如果表达式相等，该函数返回 null。如果表达式不相等，该函数返回第一个表达式。 ## 语法 ``` nullIf(expression1, expression2) ``` ## Arguments `nullIf` 接受两个表达式作为参数。 *expression* 该表达式可以是数字、日期时间或字符串。它可以是字段名、文本值或其他函数。 ## 返回类型 字符串 ## 示例 如果发货延迟的原因未知，以下示例将返回 null。 ``` nullIf(delayReason, 'unknown') ``` 以下是给定的字段值。 ``` delayReason ============ unknown back ordered weather delay ``` 对于这些字段值，将返回以下值。 ``` (null) back ordered weather delay ``` # parseDate parseDate `parseDate`解析字符串以确定其是否包含日期值，并以该格式返回标准日期`yyyy-MM-ddTkk:mm:ss.SSSZ`（使用 Joda 项目文档中 C [lass DateTimeFormat](http://www.joda.org/joda-time/apidocs/org/joda/time/format/DateTimeFormat.html) 中指定的格式模式语法），例如 2015-10-15T19:11:51.003 Z。该函数返回所有包含某个有效格式日期的行，并跳过任何其他行，包括具有 null 值的行。 Quick 支持的日期范围为世界标准时间 1900 年 1 月 1 日 00:00:00:00 至世界标准时间 2037 年 12 月 31 日 23:59:59。有关更多信息，请参阅[支持的日期格式](https://docs.amazonaws.cn/quicksight/latest/user/supported-date-formats.html)。 ## 语法 ``` parseDate(expression, ['format']) ``` ## Arguments *expression* 表达式必须是字符串。它可以是使用字符串数据类型的字段的名称、文本值（如 **'1/1/2016'**）或对输出字符串的其他函数的调用。 *format* (可选) 包含 *date\$1string* 必须匹配的格式模式的字符串。例如，如果您使用的字段包含类似的数据**01/03/2016**，则可以指定格式 “MM/dd/yyyy”。如果不指定格式，则默认为 `yyyy-MM-dd`。将跳过数据不符合 *format* 的行。 根据所使用的数据集类型，支持不同的日期格式。可以使用下表了解支持的日期格式的详细信息。 **** [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/quick/latest/userguide/parseDate-function.html) ## 返回类型 日期 ## 示例 下面的示例对 `prodDate` 进行求值以确定其是否包含日期值。 ``` parseDate(prodDate, 'MM/dd/yyyy') ``` 以下是给定的字段值。 ``` prodDate -------- 01-01-1999 12/31/2006 1/18/1982 7/4/2010 ``` 对于这些字段值，将返回以下行。 ``` 12-31-2006T00:00:00.000Z 01-18-1982T00:00:00.000Z 07-04-2010T00:00:00.000Z ``` # parseDecimal parseDecimal `parseDecimal` 解析字符串以确定其是否包含小数值。该函数返回包含小数、整数或 null 值的所有行，并跳过所有其他行。如果行包含整数值，则作为最多有 4 位小数的小数返回。例如，值“2”返回为“2.0”。 ## 语法 ``` parseDecimal(expression) ``` ## Arguments *expression* 表达式必须是字符串。它可以是使用字符串数据类型的字段的名称、文本值（如 **'9.62'**）或对输出字符串的其他函数的调用。 ## 返回类型 传统数据准备体验中的十进制（固定）。 全新的数据准备体验中的十进制（浮点型）。 ## 示例 下面的示例对 `fee` 进行求值以确定其是否包含小数值。 ``` parseDecimal(fee) ``` 以下是给定的字段值。 ``` fee -------- 2 2a 12.13 3b 3.9 (null) 198.353398 ``` 对于这些字段值，将返回以下行。 ``` 2.0 12.13 3.9 (null) 198.3533 ``` # parseInt parseInt `parseInt` 解析字符串以确定其是否包含整数值。该函数返回包含小数、整数或 null 值的所有行，并跳过所有其他行。如果行包含小数值，则返回向下舍入到的最接近的整数。例如，值“2.99”返回为“2”。 ## 语法 ``` parseInt(expression) ``` ## Arguments *expression* 表达式必须是字符串。它可以是使用字符串数据类型的字段的名称、文本值（如 **'3'**）或对输出字符串的其他函数的调用。 ## 返回类型 整数 ## 示例 下面的示例对 `feeType` 进行求值以确定其是否包含整数值。 ``` parseInt(feeType) ``` 以下是给定的字段值。 ``` feeType -------- 2 2.1 2a 3 3b (null) 5 ``` 对于这些字段值，将返回以下行。 ``` 2 2 3 (null) 5 ``` # parseJson parseJson 使用 `parseJson` 从 JSON 对象提取值。 如果您的数据集存储在 Quick 中SPICE，则可以在准备数据集`parseJson`时使用，但不能在分析期间存储在计算字段中。 对于直接查询，您可以在数据准备和分析期间使用 `parseJson`。`parseJson` 函数适用于字符串或 JSON 本机数据类型，具体视方言而定（如下表所示）。 | Dialect | Type | | --- | --- | | PostgreSQL | JSON | | Amazon Redshift | 字符串 | | Microsoft SQL Server | 字符串 | | MySQL | JSON | | Teradata | JSON | | Oracle | 字符串 | | ：Presto | 字符串 | | Snowflake | 半结构化数据类型对象和数组 | | Hive | 字符串 | ## 语法 ``` parseJson(fieldName, path) ``` ## Arguments *fieldName* 包含您要解析的 JSON 对象的字段。 *path* 要从 JSON 对象中解析的数据元素的路径。路径参数仅支持字母、数字和空格。有效的路径语法包括： + *\$1* – 根对象 + *.* – 子运算符 + *[ ]* – 数组的下标运算符 ## 返回类型 字符串 ## 示例 以下示例评估传入的 JSON 以检索项目数量的值。通过在数据准备期间使用它，您可以从 JSON 创建表。 ``` parseJson({jsonField}, “$.items.qty”) ``` 下面显示了 JSON 内容。 ``` { "customer": "John Doe", "items": { "product": "Beer", "qty": 6 }, "list1": [ "val1", "val2" ], "list2": [ { "list21key1": "list1value1" } ] } ``` 在本示例中，将返回以下值。 ``` 6 ``` ## 示例 以下示例评估 `JSONObject1` 以提取第一个键值对（KVP）（其标签为 `"State"`），并将该值分配给正在创建的计算字段。 ``` parseJson(JSONObject1, “$.state”) ``` 以下是给定的字段值。 ``` JSONObject1 ----------- {"State":"New York","Product":"Produce","Date Sold":"1/16/2018","Sales Amount":"$3423.39"} {"State":"North Carolina","Product":"Bakery Products","Date Sold":"2/1/2018","Sales Amount":"$3226.42"} {"State":"Utah","Product":"Water","Date Sold":"4/24/2018","Sales Amount":"$7001.52"} ``` 对于这些字段值，将返回以下行。 ``` New York North Carolina Utah ``` # Replace Replace（替换） `replace` 将字符串的一部分替换为您指定的其他字符串。 ## 语法 ``` replace(expression, substring, replacement) ``` ## Arguments *expression* 表达式必须是字符串。它可以是使用字符串数据类型的字段的名称、文本值（如 **'12 Main Street'**）或对输出字符串的其他函数的调用。 *substring* *expression* 中您要替换的一组字符。子字符串可在 *expression* 中出现一次或多次。 *replacement* 您要用来替换 *substring* 的字符串。 ## 返回类型 字符串 ## 示例 以下示例将子字符串“and”替换为“or”。 ``` replace('1 and 2 and 3', 'and', 'or') ``` 返回以下字符串。 ``` 1 or 2 or 3 ``` # Right 靠右对齐 `right` 返回字符串中最右侧的字符，包括空格。您可以指定要返回的字符数。 ## 语法 ``` right(expression, limit) ``` ## Arguments *expression* 表达式必须是字符串。它可以是使用字符串数据类型的字段的名称、文本值（如 **'12 Main Street'**）或对输出字符串的其他函数的调用。 *limit* 要从 *expression* 返回的字符数，从字符串中的最后一个字符开始。 ## 返回类型 字符串 ## 示例 以下示例返回字符串中的最后 5 个字符。 ``` right('Seattle Store#14', 12) ``` 将返回以下值。 ``` tle Store#14 ``` # Round `round` 将小数值舍入为最接近的整数 (如果未指定小数位数) 或舍入到最接近的小数位数 (如果指定小数位数)。 ## 语法 ``` round(decimal, scale) ``` ## Arguments *decimal* 使用小数数据类型的字段、文本值（如 **17.62**）或对输出小数的其他函数的调用。 *小数位数* 用于返回值的小数位数。 ## 返回类型 | 操作数 | 旧版数据准备体验中的返回类型 | 全新的数据准备体验中的返回类型 | | --- | --- | --- | | INT | 十进制（固定） | 十进制（固定） | | 十进制（固定） | 十进制（固定） | 十进制（固定） | | 十进制（浮点数） | 十进制（固定） | 十进制（浮点数） | ## 示例 以下示例将一个小数字段舍入为最接近的两位小数。 ``` round(salesAmount, 2) ``` 以下是给定的字段值。 ``` 20.1307 892.0388 57.5447 ``` 对于这些字段值，将返回以下值。 ``` 20.13 892.04 58.54 ``` # Rtrim Rtrim `rtrim` 从字符串中移除尾随空格。 ## 语法 ``` rtrim(expression) ``` ## Arguments *expression* 表达式必须是字符串。它可以是使用字符串数据类型的字段的名称、文本值（如 **'12 Main Street'**）或对输出字符串的其他函数的调用。 ## 返回类型 字符串 ## 示例 以下示例从字符串中删除尾随空格。 ``` rtrim('Seattle Store #14 ') ``` 对于这些字段值，将返回以下值。 ``` Seattle Store #14 ``` # Split 拆分 `split` 根据您选择的分隔符将字符串拆分为一个子字符串数组，并返回由位置指定的项目。 只能在准备数据期间将 `split` 添加到计算字段，而不是添加到分析中。对 Microsoft SQL Server 的直接查询不支持此函数。 ## 语法 ``` split(expression, delimiter , position) ``` ## Arguments *expression* 表达式必须是字符串。它可以是使用字符串数据类型的字段的名称、文本值（如 **'12 Main Street;1402 35th Ave;1818 Elm Ct;11 Janes Lane'**）或对输出字符串的其他函数的调用。 *分隔符* 划定在何处将字符串拆分为子字符串的字符。例如，`split('one|two|three', '|', 2)` 变为以下内容。 ``` one two three ``` 如果选择 `position = 2`，`split` 将返回 `'two'`。 *position* (必需) 要从数组中返回的项目的位置。数组中的第一个项目的位置为 1。 ## 返回类型 字符串数组 ## 示例 以下示例将字符串拆分为一个数组 (将分号字符 (;) 作为分隔符)，并返回数组的第三个元素。 ``` split('123 Test St;1402 35th Ave;1818 Elm Ct;11 Janes Lane', ';', 3) ``` 将返回以下项目。 ``` 1818 Elm Ct ``` 该函数跳过包含 null 值或空字符串的项目。 # Sqrt `sqrt` 返回给定表达式的平方根。 ## 语法 ``` sqrt(expression) ``` ## Arguments *expression* 表达式必须是数字。它可以是字段名、文本值或其他函数。 # startsWith startsWith `startsWith` 评估表达式是否以您指定的子字符串开头。如果表达式以子字符串开头，`startsWith` 返回 true，否则返回 false。 ## 语法 ``` startsWith(expression, substring, string-comparison-mode) ``` ## Arguments *expression* 表达式必须是字符串。它可以是使用字符串数据类型的字段的名称、文本值（如 **'12 Main Street'**）或对输出字符串的其他函数的调用。 *substring* 要根据*表达式*检查的字符集。子字符串可在*表达式*中出现一次或多次。 *string-comparison-mode* （可选）指定要使用的字符串比较模式： + `CASE_SENSITIVE` – 字符串比较区分大小写。 + `CASE_INSENSITIVE` – 字符串比较不区分大小写。 留空时此值默认为 `CASE_SENSITIVE`。 ## 返回类型 布尔值 ## 示例 ### 默认区分大小写的示例 以下区分大小写的示例评估 `state_nm` 是否以 **New** 开头。 ``` startsWith(state_nm, "New") ``` 以下是给定的字段值。 ``` New York new york ``` 对于这些字段值，将返回以下值。 ``` true false ``` ### 不区分大小写的示例 以下不区分大小写的示例评估 `state_nm` 是否以 **new** 开头。 ``` startsWith(state_nm, "new", CASE_INSENSITIVE) ``` 以下是给定的字段值。 ``` New York new york ``` 对于这些字段值，将返回以下值。 ``` true true ``` ### 带条件语句的示例 `startsWith` 函数可用作以下 If 函数中的条件语句：[avgIf](https://docs.amazonaws.cn/quicksight/latest/user/avgIf-function.html)、[minIf](https://docs.amazonaws.cn/quicksight/latest/user/minIf-function.html)、[distinct\$1countIf](https://docs.amazonaws.cn/quicksight/latest/user/distinct_countIf-function.html)、[countIf](https://docs.amazonaws.cn/quicksight/latest/user/countIf-function.html)、[maxIf](https://docs.amazonaws.cn/quicksight/latest/user/maxIf-function.html)、[medianIf](https://docs.amazonaws.cn/quicksight/latest/user/medianIf-function.html)、[stdevIf](https://docs.amazonaws.cn/quicksight/latest/user/stdevIf-function.html)、[stdevpIf](https://docs.amazonaws.cn/quicksight/latest/user/stdevpIf-function.html)、[sumIf](https://docs.amazonaws.cn/quicksight/latest/user/sumIf-function.html)、[varIf](https://docs.amazonaws.cn/quicksight/latest/user/varIf-function.html) 和 [varpIf](https://docs.amazonaws.cn/quicksight/latest/user/varpIf-function.html)。 以下示例仅当 state\$1nm 以 **New** 开头时才对 `Sales` 求和。 ``` sumIf(Sales,startsWith(state_nm, "New")) ``` ### 不包含示例 条件 `NOT` 运算符可用于评估表达式是否不以指定的子字符串开头。 ``` NOT(startsWith(state_nm, "New")) ``` ### 使用数值的示例 通过应用 `toString` 函数，可以在表达式或子字符串参数中使用数值。 ``` startsWith(state_nm, toString(5) ) ``` # Strlen Strlen `strlen` 返回字符串的字符数，包括空格。 ## 语法 ``` strlen(expression) ``` ## Arguments *expression* expression 可以是使用字符串数据类型的字段的名称（如 **address1**）、文本值（如 **'Unknown'**）或其他函数（如 `substring(field_name,0,5)`）。 ## 返回类型 整数 ## 示例 以下示例返回指定字符串的长度。 ``` strlen('1421 Main Street') ``` 将返回以下值。 ``` 16 ``` # Substring Substring `substring` 返回字符串中的字符，从 *start* 参数指定的位置开始，延续 *length* 参数指定的字符数。 ## 语法 ``` substring(expression, start, length) ``` ## Arguments *expression* expression 可以是使用字符串数据类型的字段的名称（如 **address1**）、文本值（如 **'Unknown'**）或其他函数（如 `substring(field_name,1,5)`）。 *start* 开始字符的位置。*start* 包含在内，因此，起始位置的字符是返回值中的第一个字符。*start* 的最小值为 1。 *length* 在 *start* 后面包含的其他字符数。*length* 包含 *start*，因此，返回的最后一个字符是起始字符后面的第（*length* – 1）个字符。 ## 返回类型 字符串 ## 示例 以下示例返回字符串中第 13 个到第 19 个字符。字符串的开头是索引 1，所以您从第一个字符开始计数。 ``` substring('Fantasy and Science Fiction',13,7) ``` 将返回以下值。 ``` Science ``` # switch `switch` 在一组文本标签和 *return-expression* 配对中，将 *condition-expression* 与文本标签进行比较。然后，它返回与第一个等于 *condition-expression* 的文本标签相对应的 *return-expression*。如果没有等于 *condition-expression* 的标签，则 `switch` 返回 *default-expression*。每个 *return-expression* 和 *default-expression* 必须具有相同的数据类型。 ## 语法 ``` switch(condition-expression, label-1, return-expression-1 [, label-n, return-expression-n ...], default-expression) ``` ## Arguments `switch` 需要一个或多个 *if*/*then* 表达式对，*else* 参数只需要一个表达式。 *condition-expression* 要与标签文本进行比较的表达式。它可以是字段名称（如 `address`）、文本值（如“`Unknown`”）或其他函数（如 `toString(salesAmount)`）。 *label* 要与 *condition-expression* 参数进行比较的文本，所有文本的数据类型都必须与 *condition-expression* 参数相同。`switch` 最多可接受 5000 个标签。 *return-expression* 其标签的值等于 *condition-expression* 的值时返回的表达式。它可以是字段名称（如 `address`）、文本值（如“`Unknown`”）或其他函数（如 `toString(salesAmount)`）。所有 *return-expression* 参数必须与 *default-expression* 具有相同的数据类型。 *default-expression* 任何标签参数的值都不等于 *condition-expression* 的值时返回的表达式。它可以是字段名称（如 `address`）、文本值（如“`Unknown`”）或其他函数（如 `toString(salesAmount)`）。*default-expression* 必须与所有 *return-expression* 参数具有相同的数据类型。 ## 返回类型 `switch` 返回与 *return-expression* 中的值具有相同数据类型的值。*return-expression* 和 *default-expression* 返回的所有数据都必须是相同的数据类型或转换为相同的数据类型。 ## 一般示例 以下示例返回输入区域名称的 Amazon Web Services 区域 代码。 ``` switch(region_name, "US East (N. Virginia)", "us-east-1", "Europe (Ireland)", "eu-west-1", "US West (N. California)", "us-west-1", "other regions") ``` 以下是给定的字段值。 ``` "US East (N. Virginia)" "US West (N. California)" "Asia Pacific (Tokyo)" ``` 对于这些字段值，将返回以下值。 ``` "us-east-1" "us-west-1" "other regions" ``` ## 使用 switch 替换 `ifelse` 以下 `ifelse` 用例等同于前面的示例，当 `ifelse` 评估一个字段的值是否等于不同的文本值时，改用 `switch` 是更好的选择。 ``` ifelse(region_name = "US East (N. Virginia)", "us-east-1", region_name = "Europe (Ireland)", "eu-west-1", region_name = "US West (N. California)", "us-west-1", "other regions") ``` ## 表达式作为返回值 以下示例在 *return-expressions* 中使用表达式： ``` switch({origin_city_name}, "Albany, NY", {arr_delay} + 20, "Alexandria, LA", {arr_delay} - 10, "New York, NY", {arr_delay} * 2, {arr_delay}) ``` 前面的示例更改了从特定城市起飞的每个航班的预期延误时间。 ![\[函数示例结果的图像，以表格形式显示。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/switch-function-example.png) # toLower toLower `toLower` 将字符串全部设置为小写格式。`toLower` 跳过包含 null 值的行。 ## 语法 ``` toLower(expression) ``` ## Arguments *expression* 表达式必须是字符串。它可以是使用字符串数据类型的字段的名称、文本值（如 **'12 Main Street'**）或对输出字符串的其他函数的调用。 ## 返回类型 字符串 ## 示例 以下示例将一个字符串值转换为小写。 ``` toLower('Seattle Store #14') ``` 将返回以下值。 ``` seattle store #14 ``` # toString toString `toString` 将输入表达式设置为字符串格式。`toString` 跳过包含 null 值的行。 ## 语法 ``` toString(expression) ``` ## Arguments *expression* expression 可以是任意数据类型的字段、文本值（如 **14.62**）或对返回任意数据类型的其他函数的调用。 ## 返回类型 字符串 ## 示例 下面的示例将 `payDate`（使用`date`数据类型）的值作为字符串返回。 ``` toString(payDate) ``` 以下是给定的字段值。 ``` payDate -------- 1992-11-14T00:00:00.000Z 2012-10-12T00:00:00.000Z 1973-04-08T00:00:00.000Z ``` 对于这些字段值，将返回以下行。 ``` 1992-11-14T00:00:00.000Z 2012-10-12T00:00:00.000Z 1973-04-08T00:00:00.000Z ``` # toUpper toUpper `toUpper` 将字符串全部设置为小写格式。`toUpper` 跳过包含 null 值的行。 ## 语法 ``` toUpper(expression) ``` ## Arguments *expression* 表达式必须是字符串。它可以是使用字符串数据类型的字段的名称、文本值（如 **'12 Main Street'**）或对输出字符串的其他函数的调用。 ## 返回类型 字符串 ## 示例 以下示例将一个字符串值转换为大写。 ``` toUpper('Seattle Store #14') ``` 将返回以下值。 ``` SEATTLE STORE #14 ``` # trim trim `trim` 从字符串中同时移除前置和尾随空格。 ## 语法 ``` trim(expression) ``` ## Arguments *expression* 表达式必须是字符串。它可以是使用字符串数据类型的字段的名称、文本值（如 **'12 Main Street'**）或对输出字符串的其他函数的调用。 ## 返回类型 字符串 ## 示例 以下示例从字符串中删除尾随空格。 ``` trim(' Seattle Store #14 ') ``` 对于这些字段值，将返回以下值。 ``` Seattle Store #14 ``` # truncDate `truncDate` 返回表示日期指定部分的日期值。例如，请求值 2012-09-02T00:00:00.000Z 的年份部分将返回 2012-01-01T00:00:00.000Z。如果为不包含时间信息的日期指定时间相关的时间段，则返回初始日期值 (不进行任何更改)。 ## 语法 ``` truncDate('period', date) ``` ## Arguments *时段* 希望返回的日期的时间段。有效时间段如下所示： + YYYY：返回日期的年份部分。 + 问：这将返回日期所属季度的第一天的日期。 + MM：返回日期的月份部分。 + DD：返回日期的日期部分。 + WK：返回日期的星期部分。在 Amazon Quick 中，本周从周日开始。 + HH：返回日期的小时部分。 + MI：返回日期的分钟部分。 + SS：返回日期的秒部分。 + MS：返回日期的毫秒部分。 *date* 它可以是日期字段，也可以是对输出日期的其他函数的调用。 ## 返回类型 日期 ## 示例 以下示例返回表示订单日期月份的日期。 ``` truncDate('MM', orderDate) ``` 以下是给定的字段值。 ``` orderDate ========= 2012-12-14T00:00:00.000Z 2013-12-29T00:00:00.000Z 2012-11-15T00:00:00.000Z ``` 对于这些字段值，将返回以下值。 ``` 2012-12-01T00:00:00.000Z 2013-12-01T00:00:00.000Z 2012-11-01T00:00:00.000Z ``` # 聚合函数 聚合函数仅在分析和可视化期间可用。所有这些函数都会返回按选定的一个或多个维度分组的值。对于每个聚合，还有一个有条件聚合。它们根据条件执行相同类型的聚合。 当计算字段公式包含一个聚合时，它将成为自定义聚合。为了确保您的数据显示准确，Amazon Quick 采用以下规则： + 自定义聚合不能包含嵌套的聚合函数。例如，此公式不起作用：`sum(avg(x)/avg(y))`。但是，在聚合函数的内部或外部嵌套非聚合函数有效。例如，`ceil(avg(x))` 可工作。`avg(ceil(x))` 也是如此。 + 自定义聚合在任何组合中都不能同时包含聚合和非聚合字段。例如，此公式不起作用：`Sum(sales)+quantity`。 + 筛选条件组不能同时包含聚合字段和非聚合字段。 + 自定义聚合无法转换为维度。它们也无法作为维度放入字段井。 + 在数据透视表中，自定义聚合无法添加到表计算。 + 包含自定义聚合的散点图在字段井中的 **Group/Color** 下至少需要一个维度。 有关支持的函数和运算符的更多信息，请参阅 [Amazon Quick 的计算字段函数和运算符参考](https://docs.amazonaws.cn/quicksight/latest/user/calculated-field-reference.html)。 Quick 中计算字段的聚合函数包括以下内容。 **Topics** + [ # avg ](avg-function.md) + [ # avgIf ](avgIf-function.md) + [ # count ](count-function.md) + [ # countIf ](countIf-function.md) + [ # distinct\$1count ](distinct_count-function.md) + [ # distinct\$1countIf ](distinct_countIf-function.md) + [ # max ](max-function.md) + [ # maxIf ](maxIf-function.md) + [ # median ](median-function.md) + [ # medianIf ](medianIf-function.md) + [ # min ](min-function.md) + [ # minIf ](minIf-function.md) + [ # percentile ](percentile-function.md) + [ # percentileCont ](percentileCont-function.md) + [ # percentileDisc（百分位数） ](percentileDisc-function.md) + [ # periodToDateAvg ](periodToDateAvg-function.md) + [ # periodToDateCount ](periodToDateCount-function.md) + [ # periodToDateMax ](periodToDateMax-function.md) + [ # periodToDateMedian ](periodToDateMedian-function.md) + [ # periodToDateMin ](periodToDateMin-function.md) + [ # periodToDatePercentile ](periodToDatePercentile-function.md) + [ # periodToDatePercentileCont ](periodToDatePercentileCont-function.md) + [ # periodToDateStDev ](periodToDateStDev-function.md) + [ # periodToDateStDevP ](periodToDateStDevP-function.md) + [ # periodToDateSum ](periodToDateSum-function.md) + [ # periodToDateVar ](periodToDateVar-function.md) + [ # periodToDateVarP ](periodToDateVarP-function.md) + [ # stdev ](stdev-function.md) + [ # stdevp ](stdevp-function.md) + [ # stdevIf ](stdevIf-function.md) + [ # stdevpIf ](stdevpIf-function.md) + [ # sum ](sum-function.md) + [ # sumIf ](sumIf-function.md) + [ # var ](var-function.md) + [ # varIf ](varIf-function.md) + [ # varp ](varp-function.md) + [ # varpIf ](varpIf-function.md) # avg `avg` 函数以指定的度量计算一组数字的平均值，按照选定的一个或多个维度分组。例如，`avg(salesAmount)` 返回该度量的平均值，按 (可选的) 选定维度分组。 ## 语法 ``` avg(decimal, [group-by level]) ``` ## Arguments *decimal* 参数必须是一个度量。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *分组依据等级* （可选）指定聚合分组依据的等级。添加的等级可以是任何维度，也可以是独立于添加到视觉对象的维度。 参数必须是一个维度字段。分组依据等级必须用方括号 `[ ]` 括起来。有关更多信息，请参阅[级别感知计算-聚合 (LAC-A](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html)) 函数。 ## 示例 以下示例计算平均销售额。 ``` avg({Sales}) ``` 您还可以使用视图或数据集中的一个或多个维度来指定在哪个等级对计算进行分组。这称为 LAC-A 函数。有关 LAC-A 函数的更多信息，请参阅[级别感知计算-聚合 (LAC-](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html) A) 函数。以下示例计算国家/地区等级的平均销售额，但不计算视觉对象中其他维度（区域或产品）的平均销售额。 ``` avg({Sales}, [{Country}]) ``` ![\[仅在国家/地区等级汇总平均销售数量。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/avg-function-example.png) # avgIf 根据条件语句，`avgIf` 函数以指定的度量计算一组数字的平均值，按照选定的一个或多个维度分组。例如，如果条件的计算结果为 true，`avgIf(ProdRev,CalendarDay >= ${BasePeriodStartDate} AND CalendarDay <= ${BasePeriodEndDate} AND SourcingType <> 'Indirect')` 返回该度量的平均值，按（可选的）选定维度分组。 ## 语法 ``` avgIf(dimension or measure, condition) ``` ## Arguments *decimal* 参数必须是一个度量。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *condition* 单个语句中的一个或多个条件。 # count `count` 函数计算维度或度量中包含的值的个数，按照选定的一个或多个维度分组。例如，`count(product type)` 返回产品类型的总数，按 (可选的) 选定维度分组，包括任何重复项。`count(sales)` 函数返回完成销售的总数，按 (可选的) 选定维度分组，如销售人员。 ## 语法 ``` count(dimension or measure, [group-by level]) ``` ## Arguments *维度或度量* 参数必须是一个度量或一个维度。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *分组依据等级* （可选）指定聚合分组依据的等级。添加的等级可以是任何维度，也可以是独立于添加到视觉对象的维度。 参数必须是一个维度字段。分组依据等级必须用方括号 `[ ]` 括起来。有关更多信息，请参阅[级别感知计算-聚合 (LAC-A](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html)) 函数。 ## 示例 以下示例按视觉对象中的指定维度计算销售数量。在此示例中，显示了按月计算的销售数量。 ``` count({Sales}) ``` ![\[按月计算的销售数量。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/count-function-example.png) 您还可以使用视图或数据集中的一个或多个维度来指定在哪个等级对计算进行分组。这称为 LAC-A 函数。有关 LAC-A 函数的更多信息，请参阅[级别感知计算-聚合 (LAC-](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html) A) 函数。以下示例计算国家/地区等级的销售数量，但不计算视觉对象中其他维度（区域或产品）的销售数量。 ``` count({Sales}, [{Country}]) ``` ![\[仅在国家/地区等级汇总销售数量。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/count-function-example2.png) # countIf 根据条件语句，`countIf` 函数计算维度或度量中包含的值的个数，按照选定的一个或多个维度分组。 ## 语法 ``` countIf(dimension or measure, condition) ``` ## Arguments *维度或度量* 参数必须是一个度量或一个维度。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *condition* 单个语句中的一个或多个条件。 ## 返回类型 整数 ## 示例 以下函数返回符合条件的销售交易 (`Revenue`) 数量，包括任何重复项。 ``` countIf ( Revenue, # Conditions CalendarDay >= ${BasePeriodStartDate} AND CalendarDay <= ${BasePeriodEndDate} AND SourcingType <> 'Indirect' ) ``` # distinct\$1count `distinct_count` 函数计算维度或度量中包含的不同值的个数，按照选定的一个或多个维度分组。例如，`distinct_count(product type)` 返回唯一产品类型的总数，按 (可选的) 选定维度分组，不包括重复项。`distinct_count(ship date)` 函数返回完成配送产品的日期总数，按 (可选的) 选定维度分组，如区域。 ## 语法 ``` distinct_count(dimension or measure, [group-by level]) ``` ## Arguments *维度或度量* 参数必须是一个度量或一个维度。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *分组依据等级* （可选）指定聚合分组依据的等级。添加的等级可以是任何维度，也可以是独立于添加到视觉对象的维度。 参数必须是一个维度字段。分组依据等级必须用方括号 `[ ]` 括起来。有关更多信息，请参阅[级别感知计算-聚合 (LAC-A](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html)) 函数。 ## 示例 以下示例计算订购商品的日期总数，按视觉对象中的选定维度（如区域）分组。 ``` distinct_count({Order Date}) ``` ![\[每个区域订购商品的日期总数。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/distinct_count-function-example.png) 您还可以使用视图或数据集中的一个或多个维度来指定在哪个等级对计算进行分组。这称为 LAC-A 函数。有关 LAC-A 函数的更多信息，请参阅[级别感知计算-聚合 (LAC-](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html) A) 函数。以下示例计算国家/地区等级的平均销售额，但不计算视觉对象中其他维度（区域）的平均销售额。 ``` distinct_count({Order Date}, [Country]) ``` ![\[每个国家/地区订购商品的日期总数。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/distinct_count-function-example2.png) # distinct\$1countIf 根据条件语句，`distinct_countIf` 函数计算维度或度量中包含的不同值的个数，按照选定的一个或多个维度分组。例如，`distinct_countIf(product type)` 返回唯一产品类型的总数，按 (可选的) 选定维度分组，不包括重复项。如果条件的计算结果为 true，`distinct_countIf(ProdRev,CalendarDay >= ${BasePeriodStartDate} AND CalendarDay <= ${BasePeriodEndDate} AND SourcingType <> 'Indirect')` 函数返回完成配送产品的日期总数，按（可选的）选定维度（如区域）分组。 ## 语法 ``` distinct_countIf(dimension or measure, condition) ``` ## Arguments *维度或度量* 参数必须是一个度量或一个维度。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *condition* 单个语句中的一个或多个条件。 # max `max` 函数返回指定度量或日期的最大值，按照选定的一个或多个维度分组。例如，`max(sales goal)` 返回最大销售目标，按 (可选的) 选定维度分组。 ## 语法 ``` max(measure, [group-by level]) ``` ## Arguments *度量* 参数必须是一个度量或一个日期。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 最大日期仅在表和数据透视表的 **Value (值)** 字段井中起作用。 *分组依据等级* （可选）指定聚合分组依据的等级。添加的等级可以是任何维度，也可以是独立于添加到视觉对象的维度。 参数必须是一个维度字段。分组依据等级必须用方括号 `[ ]` 括起来。有关更多信息，请参阅[级别感知计算-聚合 (LAC-A](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html)) 函数。 ## 示例 以下示例将返回每个区域的最大销售额。将其与总销售额、最小销售额和销售额中值进行比较。 ``` max({Sales}) ``` ![\[每个区域的最大销售额。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/min-max-median-function-example.png) 您还可以使用视图或数据集中的一个或多个维度来指定在哪个等级对计算进行分组。这称为 LAC-A 函数。有关 LAC-A 函数的更多信息，请参阅[级别感知计算-聚合 (LAC-](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html) A) 函数。以下示例计算国家/地区等级的最大销售额，但不计算视觉对象中其他维度（区域）的最大销售额。 ``` max({Sales}, [Country]) ``` ![\[每个国家/地区的最大销售额。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/max-function-example2.png) # maxIf 根据条件语句，`maxIf` 函数返回指定度量的最大值，按照选定的一个或多个维度分组。例如，如果条件的计算结果为 true，`maxIf(ProdRev,CalendarDay >= ${BasePeriodStartDate} AND CalendarDay <= ${BasePeriodEndDate} AND SourcingType <> 'Indirect')` 返回最大销售目标，按（可选的）选定维度分组。 ## 语法 ``` maxIf(measure, condition) ``` ## Arguments *度量* 参数必须是一个度量。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *condition* 单个语句中的一个或多个条件。 # median `median` 聚合返回指定度量的中值，并按照选定的一个或多个维度进行分组。例如，`median(revenue)` 返回按（可选）选定维度分组的收入中值。 ## 语法 ``` median(measure, [group-by level]) ``` ## Arguments *度量* 参数必须是一个度量。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *分组依据等级* （可选）指定聚合分组依据的等级。添加的等级可以是任何维度，也可以是独立于添加到视觉对象的维度。 参数必须是一个维度字段。分组依据等级必须用方括号 `[ ]` 括起来。有关更多信息，请参阅[级别感知计算-聚合 (LAC-A](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html)) 函数。 ## 示例 以下示例将返回每个区域的销售额中值。将其与总销售额、最大销售额和最小销售额进行比较。 ``` median({Sales}) ``` ![\[每个区域的销售额中值。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/min-max-median-function-example.png) 您还可以使用视图或数据集中的一个或多个维度来指定在哪个等级对计算进行分组。这称为 LAC-A 函数。有关 LAC-A 函数的更多信息，请参阅[级别感知计算-聚合 (LAC-](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html) A) 函数。以下示例计算国家/地区等级的销售额中值，但不计算视觉对象中其他维度（区域）的销售额中值。 ``` median({Sales}, [Country]) ``` ![\[每个国家/地区的销售额中值。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/median-function-example2.png) # medianIf 根据条件语句，`medianIf` 聚合返回指定度量的中值，并按照选定的一个或多个维度进行分组。例如，如果条件的计算结果为 true 时，`medianIf(Revenue,SaleDate >= ${BasePeriodStartDate} AND SaleDate <= ${BasePeriodEndDate})` 返回收入中值，按（可选的）选定维度分组。 ## 语法 ``` medianIf(measure, condition) ``` ## Arguments *度量* 参数必须是一个度量。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *condition* 单个语句中的一个或多个条件。 # min `min` 函数返回指定度量或日期的最小值，按照选定的一个或多个维度分组。例如，`min(return rate)` 返回最小收益率，按 (可选的) 选定维度分组。 ## 语法 ``` min(measure, [group-by level]) ``` ## Arguments *度量* 参数必须是一个度量或一个日期。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 最小日期仅在表和数据透视表的 **Value (值)** 字段井中起作用。 *分组依据等级* （可选）指定聚合分组依据的等级。添加的等级可以是任何维度，也可以是独立于添加到视觉对象的维度。 参数必须是一个维度字段。分组依据等级必须用方括号 `[ ]` 括起来。有关更多信息，请参阅[级别感知计算-聚合 (LAC-A](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html)) 函数。 ## 示例 以下示例返回每个区域的最小销售值。将其与总销售额、最大销售额和销售额中值进行比较。 ``` min({Sales}) ``` ![\[每个区域的最小销售额。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/min-max-median-function-example.png) 您还可以使用视图或数据集中的一个或多个维度来指定在哪个等级对计算进行分组。这称为 LAC-A 函数。有关 LAC-A 函数的更多信息，请参阅[级别感知计算-聚合 (LAC-](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html) A) 函数。以下示例计算国家/地区等级的最小销售额，但不计算视觉对象中其他维度（区域）的最小销售额。 ``` min({Sales}, [Country]) ``` ![\[每个国家/地区的最小销售额。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/min-function-example2.png) # minIf 根据条件语句，`minIf` 函数返回指定度量的最小值，按照选定的一个或多个维度分组。例如，如果条件的计算结果为 true 时，`minIf(ProdRev,CalendarDay >= ${BasePeriodStartDate} AND CalendarDay <= ${BasePeriodEndDate} AND SourcingType <> 'Indirect')` 返回最小收益率，按（可选的）选定维度分组。 ## 语法 ``` minIf(measure, condition) ``` ## Arguments *度量* 参数必须是一个度量。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *condition* 单个语句中的一个或多个条件。 # percentile `percentile` 函数计算度量中值的百分位数，按字段井中的维度分组。Quick 中有两种百分位数计算可供选择： + [https://docs.amazonaws.cn/quicksight/latest/user/percentileCont-function.html](https://docs.amazonaws.cn/quicksight/latest/user/percentileCont-function.html) 使用线性内插来确定结果。 + [percentileDisc（百分位数）](https://docs.amazonaws.cn/quicksight/latest/user/percentileDisc-function.html)使用实际值来确定结果。 `percentile` 函数是 `percentileDisc` 的别名。 # percentileCont `percentileCont` 函数根据度量中数字的连续分布计算百分位数。其使用字段井中应用的分组和排序。其回答了如下问题：哪些值代表这个百分位数？ 要返回数据集中可能不存在的精确的百分位数值，请使用 `percentileCont`。要返回数据集中存在的最接近的百分位数值，请改用 `percentileDisc`。 ## 语法 ``` percentileCont(expression, percentile, [group-by level]) ``` ## Arguments *度量* 指定用于计算百分位数的数值。参数必须是一个度量或指标。计算中将忽略 Null。 *percentile* 百分位数值可以是任何介于 0-100 的数字常数。百分比值 50 计算度量的中值。 *分组依据等级* （可选）指定聚合分组依据的等级。添加的等级可以是任何维度，也可以是独立于添加到视觉对象的维度。 参数必须是一个维度字段。分组依据等级必须用方括号 `[ ]` 括起来。有关更多信息，请参阅[级别感知计算-聚合 (LAC-A](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html)) 函数。 ## 返回值 函数的结果为数字。 ## 使用说明 `percentileCont` 函数根据指定度量中值的连续分布计算结果。根据视觉对象中的设置对值进行排序后，通过在值之间进行线性内插计算得出结果。其不同于 `percentileDisc`，后者只是从聚合的一组值中返回值。`percentileCont` 的结果可能存在于指定度量的值中，也可能不存在。 ## percentileCont 的示例 示例 以下示例帮助解释 percentileCont 的工作原理。 **Example 比较中值、`percentileCont` 和 `percentileDisc`** 以下示例使用 `median`、`percentileCont` 和 `percentileDisc` 函数显示维度（类别）的中值。中值与 percentileCont 值相同。`percentileCont` 内插一个值，该值可能存在于数据集中，也可能不存在。但是，`percentileDisc` 始终显示数据集中存在的值，因此两个结果可能不匹配。本示例的最后一列显示了两个值之间的差异。每个计算字段的代码如下所示： + `50%Cont = percentileCont( example , 50 )` + `median = median( example )` + `50%Disc = percentileDisc( example , 50 )` + `Cont-Disc = percentileCont( example , 50 ) − percentileDisc( example , 50 )` + `example = left( category, 1 )`（举一个更简单的例子，我们使用这个表达式将类别的名称缩短为它们的第一个字母。） ``` example median 50%Cont 50%Disc Cont-Disc -------- ----------- ------------ -------------- ------------ A 22.48 22.48 22.24 0.24 B 20.96 20.96 20.95 0.01 C 24.92 24.92 24.92 0 D 24.935 24.935 24.92 0.015 E 14.48 14.48 13.99 0.49 ``` **Example 第 100 个百分位数为最大值** 以下示例显示了 `example` 字段的各种 `percentileCont` 值。计算字段 `n%Cont` 定义为 `percentileCont( {example} ,n)`。每列中的内插值表示属于该百分位数存储桶的数字。在某些情况下，实际数据值与内插值相匹配。例如，列 `100%Cont` 每行显示相同的值，因为 6783.02 是最大的数字。 ``` example 50%Cont 75%Cont 99%Cont 100%Cont --------- ----------- ----------- ------------ ----------- A 20.97 84.307 699.99 6783.02 B 20.99 88.84 880.98 6783.02 C 20.99 90.48 842.925 6783.02 D 21.38 85.99 808.49 6783.02 ``` 您还可以使用视图或数据集中的一个或多个维度来指定在哪个等级对计算进行分组。这称为 LAC-A 函数。有关 LAC-A 函数的更多信息，请参阅[级别感知计算-聚合 (LAC-](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html) A) 函数。以下示例根据数字在国家/地区等级的连续分布来计算第 30 个百分位数，但不计算视觉对象中其他维度（区域）的第 30 个百分位数。 ``` percentileCont({Sales}, 30, [Country]) ``` ![\[每个国家/地区的销售额百分位数。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/percentileCont-function-example-lac.png) # percentileDisc（百分位数） `percentileDisc` 函数根据 `measure` 中的实际数字计算百分位数。其使用字段井中应用的分组和排序。`percentile` 函数是 `percentileDisc` 的别名。 使用此函数回答以下问题：此百分位数中存在哪些实际数据点？ 要返回数据集中存在的最接近的百分位数值，请使用 `percentileDisc`。要返回数据集中可能不存在的精确的百分位数值，请改用 `percentileCont`。 ## 语法 ``` percentileDisc(expression, percentile, [group-by level]) ``` ## Arguments *度量* 指定用于计算百分位数的数值。参数必须是一个度量或指标。计算中将忽略 Null。 *percentile* 百分位数值可以是任何介于 0-100 的数字常数。百分比值 50 计算度量的中值。 *分组依据等级* （可选）指定聚合分组依据的等级。添加的等级可以是任何维度，也可以是独立于添加到视觉对象的维度。 参数必须是一个维度字段。分组依据等级必须用方括号 `[ ]` 括起来。有关更多信息，请参阅[级别感知计算-聚合 (LAC-A](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html)) 函数。 ## 返回值 函数的结果为数字。 ## 使用说明 `percentileDisc` 是一个假定离散分布模型的逆分布函数。该函数具有一个百分比值和一个排序规范，并返回给定集合中的元素。 对于给定的百分位数值 `P`，`percentileDisc` 使用视觉对象中的排序值，并返回大于或等于 `P` 的最小累积分布值的值。 ## percentileDisc 的示例 示例 以下示例帮助解释 percentileDisc 的工作原理。 **Example 比较中值、`percentileDisc` 和 `percentileCont`** 以下示例使用 `percentileCont`、`percentileDisc` 和 `median` 函数显示维度（类别）的中值。中值与 percentileCont 值相同。`percentileCont` 内插一个值，该值可能存在于数据集中，也可能不存在。但是，`percentileDisc` 始终显示数据集中存在的最接近的值，因此两个结果可能不匹配。本示例的最后一列显示了两个值之间的差异。每个计算字段的代码如下所示： + `50%Cont = percentileCont( example , 50 )` + `median = median( example )` + `50%Disc = percentileDisc( example , 50 )` + `Cont-Disc = percentileCont( example , 50 ) − percentileDisc( example , 50 )` + `example = left( category, 1 )`（举一个更简单的例子，我们使用这个表达式将类别的名称缩短为它们的第一个字母。） ``` example median 50%Cont 50%Disc Cont-Disc -------- ----------- ------------ -------------- ------------ A 22.48 22.48 22.24 0.24 B 20.96 20.96 20.95 0.01 C 24.92 24.92 24.92 0 D 24.935 24.935 24.92 0.015 E 14.48 14.48 13.99 0.49 ``` **Example 第 100 个百分位数为最大值** 以下示例显示了 `example` 字段的各种 `percentileDisc` 值。计算字段 `n%Disc` 定义为 `percentileDisc( {example} ,n)`。每列中的值都是数据集中的实际数字。 ``` example 50%Disc 75%Disc 99%Disc 100%Disc -------- ----------- ------------ -------------- ------------ A 20.97 73.98 699.99 6783.02 B 42.19 88.84 820.08 6783.02 C 30.52 90.48 733.44 6783.02 D 41.38 85.99 901.29 6783.0 ``` 您还可以使用视图或数据集中的一个或多个维度来指定在哪个等级对计算进行分组。这称为 LAC-A 函数。有关 LAC-A 函数的更多信息，请参阅[级别感知计算-聚合 (LAC-](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html) A) 函数。以下示例根据数字在国家/地区等级的连续分布来计算第 30 个百分位数，但不计算视觉对象中其他维度（区域）的第 30 个百分位数。 ``` percentile({Sales}, 30, [Country]) ``` ![\[每个国家/地区的销售额百分位数。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/percentile-function-example-lac.png) # periodToDateAvg `periodToDateAvg` 函数按给定时间粒度（例如一个季度）到某个时间点（相对于该时间段）的指定度量计算一组数值的平均值。 ## 语法 ``` periodToDateAvg( measure, dateTime, period, endDate (optional)) ``` ## Arguments *度量* 参数必须是一个字段。结果中的 Null 值会被忽略。文本值不起作用。 *dateTime* 计算 PeriodToDate聚合的日期维度。 *时段* 您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 *endDate* （可选）您要结束计算periodToDate 聚合的日期维度。如果省略，默认为 `now()`。 ## 示例 以下示例计算 06-30-21 当周每种付款类型 week-to-date的最低票价金额。为了简单起见，我们只筛选了单笔付款。2021 年 6 月 30 日是星期三。Quick 在周日开始新的一周。在我们的示例中，就是 2021 年 6 月 27 日。 ``` periodToDateAvg(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy")) ``` ![\[这是示例计算的结果图像。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/PTDAvgResults.png) # periodToDateCount `periodToDateCount` 函数按给定时间粒度（例如一个季度）到某个时间点（相对于该时间段）的维度或度量（包括重复项）计算数值。 ## 语法 ``` periodToDateCount( measure, dateTime, period, endDate (optional)) ``` ## Arguments *度量* 参数必须是一个字段。结果中的 Null 值会被忽略。文本值不起作用。 *dateTime* 计算 PeriodToDate聚合的日期维度。 *时段* 您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 *endDate* （可选）您要结束计算periodToDate 聚合的日期维度。如果省略，默认为 `now()`。 ## 示例 以下示例计算 06-30-21 当周每种付款类型 week-to-date的最低票价金额。为了简单起见，我们只筛选了单笔付款。2021 年 6 月 30 日是星期三。Quick 在周日开始新的一周。在我们的示例中，就是 2021 年 6 月 27 日。 ``` periodToDateCount(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy")) ``` ![\[这是示例计算的结果图像。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/PTDCountResults.png) # periodToDateMax `periodToDateMax` 函数返回给定时间粒度（例如一个季度）到某个时间点（相对于该时间点）的指定度量的最大值。 ## 语法 ``` periodToDateMax( measure, dateTime, period, endDate (optional)) ``` ## Arguments *度量* 参数必须是一个字段。结果中的 Null 值会被忽略。文本值不起作用。 *dateTime* 计算 PeriodToDate聚合的日期维度。 *时段* 您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 *endDate* （可选）您要结束计算periodToDate 聚合的日期维度。如果省略，默认为 `now()`。 ## 示例 以下示例计算 06-30-21 当周每种付款类型 week-to-date的最低票价金额。为了简单起见，我们只筛选了单笔付款。2021 年 6 月 30 日是星期三。Quick 在周日开始新的一周。在我们的示例中，就是 2021 年 6 月 27 日。 ``` periodToDateMax(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy")) ``` ![\[这是示例计算的结果图像。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/PTDMaxResults.png) # periodToDateMedian `periodToDateMedian` 函数返回给定时间粒度（例如一个季度）到某个时间点（相对于该时间段）的指定度量的中值。 ## 语法 ``` periodToDateMedian( measure, dateTime, period, endDate (optional)) ``` ## Arguments *度量* 参数必须是一个字段。结果中的 Null 值会被忽略。文本值不起作用。 *dateTime* 计算 PeriodToDate聚合的日期维度。 *时段* 您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 *endDate* （可选）您要结束计算periodToDate 聚合的日期维度。如果省略，默认为 `now()`。 ## 示例 以下示例计算 06-30-21 当周每种付款类型 week-to-date的最低票价金额。为了简单起见，我们只筛选了单笔付款。2021 年 6 月 30 日是星期三。Quick 在周日开始新的一周。在我们的示例中，就是 2021 年 6 月 27 日。 ``` periodToDateMedian(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy")) ``` ![\[这是示例计算的结果图像。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/PTDMedianResults.png) # periodToDateMin `periodToDateMin` 函数返回给定时间粒度（例如一个季度）到某个时间点（相对于该时间段）的指定度量或日期的最小值。 ## 语法 ``` periodToDateMin( measure, dateTime, period, endDate (optional)) ``` ## Arguments *度量* 参数必须是一个字段。结果中的 Null 值会被忽略。文本值不起作用。 *dateTime* 计算 PeriodToDate聚合的日期维度。 *时段* 您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 *endDate* （可选）您要结束计算periodToDate 聚合的日期维度。如果省略，默认为 `now()`。 ## 示例 以下示例计算 06-30-21 当周每种付款类型 week-to-date的最低票价金额。为了简单起见，我们只筛选了单笔付款。2021 年 6 月 30 日是星期三。Quick 在周日开始新的一周。在我们的示例中，就是 2021 年 6 月 27 日。 ``` periodToDateMin(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy")) ``` ![\[这是示例计算的结果图像。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/PTDMinResults.png) # periodToDatePercentile `periodToDatePercentile` 函数按给定时间粒度（例如一个季度）到某个时间点（相对于该时间段）的度量中的实际数值计算百分位数。其使用字段井中应用的分组和排序。 要返回数据集中存在的最接近的百分位数值，请使用 `periodToDatePercentile`。要返回数据集中可能不存在的精确的百分位数值，请改用 `periodToDatePercentileCont`。 ## 语法 ``` periodToDatePercentile( measure, percentile, dateTime, period, endDate (optional)) ``` ## Arguments *度量* 参数必须是一个字段。结果中的 Null 值会被忽略。文本值不起作用。 *percentile* 百分位数值可以是任何介于 0-100 的数字常数。百分位数 50 计算度量的中值。 *dateTime* 计算 PeriodToDate聚合所依据的日期维度。 *时段* 您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 *endDate* （可选）您要结束计算periodToDate 聚合的日期维度。如果省略，默认为 `now()`。 ## 示例 以下示例计算了 06-30- week-to-date 21 当周每种付款类型票价金额的第 90 个百分位数。为了简单起见，我们只筛选了单笔付款。2021 年 6 月 30 日是星期三。Quick 在周日开始新的一周。在我们的示例中，就是 2021 年 6 月 27 日。 ``` periodToDatePercentile(fare_amount, 90, pickupDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy")) ``` ![\[这是示例计算的收益图像。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/PTDPercentileResults.png) # periodToDatePercentileCont `periodToDatePercentileCont` 函数按给定时间粒度（例如一个季度）到该时间段某个时间点的度量中数值的连续分布计算百分位数。其使用字段井中应用的分组和排序。 要返回数据集中可能不存在的精确的百分位数值，请使用 `periodToDatePercentileCont`。要返回数据集中存在的最接近的百分位数值，请改用 `periodToDatePercentile`。 ## 语法 ``` periodToDatePercentileCont( measure, percentile, dateTime, period, endDate (optional)) ``` ## Arguments *度量* 参数必须是一个字段。结果中的 Null 值会被忽略。文本值不起作用。 *percentile* 百分位数值可以是任何介于 0-100 的数字常数。百分位数 50 计算度量的中值。 *dateTime* 计算 PeriodToDate聚合所依据的日期维度。 *时段* 您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 *endDate* （可选）您要结束计算periodToDate 聚合的日期维度。如果省略，默认为 `now()`。 ## 示例 以下示例计算了 06-30- week-to-date 21 当周每种付款类型票价金额的第 90 个百分位数。为了简单起见，我们只筛选了单笔付款。2021 年 6 月 30 日是星期三。Quick 在周日开始新的一周。在我们的示例中，就是 2021 年 6 月 27 日。 ``` periodToDatePercentileCont(fare_amount, 90, pickupDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy")) ``` ![\[这是示例计算的收益图像。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/PTDContPercentileResults.png) # periodToDateStDev `periodToDateStDev` 函数按给定时间粒度（例如一个季度）到某个时间点（基于示例并相对于该时间段）的指定度量计算一组数值的标准偏差。 ## 语法 ``` periodToDateStDev( measure, dateTime, period, endDate (optional)) ``` ## Arguments *度量* 参数必须是一个字段。结果中的 Null 值会被忽略。文本值不起作用。 *dateTime* 计算 PeriodToDate聚合的日期维度。 *时段* （可选）您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 *endDate* （可选）您要结束计算periodToDate 聚合的日期维度。如果省略，默认为 `now()`。 ## 示例 以下示例计算 06-30-21 当周每种付款类型 week-to-date的最低票价金额。为了简单起见，我们只筛选了单笔付款。2021 年 6 月 30 日是星期三。Quick 在周日开始新的一周。在我们的示例中，就是 2021 年 6 月 27 日。 ``` periodToDateStDev(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy")) ``` ![\[这是示例计算的结果图像。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/PTDStDevResults.png) # periodToDateStDevP `periodToDateStDevP` 函数按给定时间粒度（例如一个季度）到某个时间点（基于该时间段的示例）的指定度量计算一组数值的总体标准偏差。 ## 语法 ``` periodToDateStDevP( measure, dateTime, period, endDate (optional)) ``` ## Arguments *度量* 参数必须是一个字段。结果中的 Null 值会被忽略。文本值不起作用。 *dateTime* 计算 PeriodToDate聚合的日期维度。 *时段* 您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 *endDate* （可选）您要结束计算periodToDate 聚合的日期维度。如果省略，默认为 `now()`。 ## 示例 以下示例计算 06-30-21 当周每种付款类型 week-to-date的最低票价金额。为了简单起见，我们只筛选了单笔付款。2021 年 6 月 30 日是星期三。Quick 在周日开始新的一周。在我们的示例中，就是 2021 年 6 月 27 日。 ``` periodToDateStDevP(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy")) ``` ![\[这是示例计算的结果图像。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/PTDStDevPResults.png) # periodToDateSum `periodToDateSum` 函数添加给定时间粒度（例如一个季度）到某个时间点（相对于该时间段）的指定度量。 ## 语法 ``` periodToDateSum( measure, dateTime, period, endDate) ``` ## Arguments *度量* 参数必须是一个字段。结果中的 Null 值会被忽略。文本值不起作用。 *dateTime* 计算 PeriodToDate聚合的日期维度。 *时段* 您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 *endDate* （可选）您要结束计算periodToDate 聚合的日期维度。如果省略，默认为 `now()`。 ## 示例 以下示例计算 2021 年 6 月 30 日当周每种付款类型的本周迄今付款总额。为了简单起见，我们只筛选了单笔付款。2021 年 6 月 30 日是星期三。Quick 在周日开始新的一周。在我们的示例中，就是 2021 年 6 月 27 日。 ``` periodToDateSum(fare_amount, pickUpDateTime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy")) ``` ![\[这是示例的结果图像（附插图）。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/PTDSumResults.png) # periodToDateVar `periodToDateVar` 函数按给定时间粒度（例如一个季度）到该时间段的某个时间点的指定度量计算一组数值的样本方差。 ## 语法 ``` periodToDateVar( measure, dateTime, period, endDate (optional)) ``` ## Arguments *度量* 参数必须是一个字段。结果中的 Null 值会被忽略。文本值不起作用。 *dateTime* 计算 PeriodToDate聚合的日期维度。 *时段* 您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 *endDate* （可选）您要结束计算periodToDate 聚合的日期维度。如果省略，默认为 `now()`。 ## 示例 以下示例计算 06-30-21 当周每种付款类型 week-to-date的最低票价金额。为了简单起见，我们只筛选了单笔付款。2021 年 6 月 30 日是星期三。Quick 在周日开始新的一周。在我们的示例中，就是 2021 年 6 月 27 日。 ``` periodToDateVar(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy")) ``` ![\[这是示例计算的结果图像。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/PTDVarResults.png) # periodToDateVarP `periodToDateVarP` 函数按给定时间粒度（例如一个季度）到某个时间点（相对于该时间段）的指定度量计算一组数值的总体方差。 ## 语法 ``` periodToDateVarP( measure, dateTime, period, endDate (optional)) ``` ## Arguments *度量* 参数必须是一个字段。结果中的 Null 值会被忽略。文本值不起作用。 *dateTime* 计算 PeriodToDate聚合的日期维度。 *时段* 您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 *endDate* （可选）您要结束计算periodToDate 聚合的日期维度。如果省略，默认为 `now()`。 ## 示例 以下示例计算 06-30-21 当周每种付款类型 week-to-date的最低票价金额。为了简单起见，我们只筛选了单笔付款。2021 年 6 月 30 日是星期三。Quick 在周日开始新的一周。在我们的示例中，就是 2021 年 6 月 27 日。 ``` periodToDateVarP(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy")) ``` ![\[这是示例计算的结果图像。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/PTDVarPResults.png) # stdev `stdev` 函数根据样本计算指定度量中按选定的一个维度或多个维度分组的一组数字的标准差。 ## 语法 ``` stdev(measure, [group-by level]) ``` ## Arguments *度量* 参数必须是一个度量。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *分组依据等级* （可选）指定聚合分组依据的等级。添加的等级可以是任何维度，也可以是独立于添加到视觉对象的维度。 参数必须是一个维度字段。分组依据等级必须用方括号 `[ ]` 括起来。有关更多信息，请参阅[级别感知计算-聚合 (LAC-A](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html)) 函数。 ## 示例 以下示例使用记录的测试分数样本返回一个等级的测试分数标准偏差。 ``` stdev({Score}) ``` 您还可以使用视图或数据集中的一个或多个维度来指定在哪个等级对计算进行分组。这称为 LAC-A 函数。有关 LAC-A 函数的更多信息，请参阅[级别感知计算-聚合 (LAC-](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html) A) 函数。以下示例计算主题等级的测试分数标准偏差，但不计算视觉对象中其他维度（等级）的测试分数标准偏差。 ``` stdev({Score}, [Subject]) ``` # stdevp `stdevp` 函数计算指定度量中按选定的一个维度或多个维度分组的一组数字的标准差。 ## 语法 ``` stdevp(measure, [group-by level]) ``` ## Arguments *度量* 参数必须是一个度量。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *分组依据等级* （可选）指定聚合分组依据的等级。添加的等级可以是任何维度，也可以是独立于添加到视觉对象的维度。 参数必须是一个维度字段。分组依据等级必须用方括号 `[ ]` 括起来。有关更多信息，请参阅[级别感知计算-聚合 (LAC-A](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html)) 函数。 ## 示例 以下示例使用记录的所有分数返回一个等级的测试分数标准偏差。 ``` stdevp({Score}) ``` 您还可以使用视图或数据集中的一个或多个维度来指定在哪个等级对计算进行分组。这称为 LAC-A 函数。有关 LAC-A 函数的更多信息，请参阅[级别感知计算-聚合 (LAC-](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html) A) 函数。以下示例使用记录的所有分数计算主题等级的测试分数标准偏差，但不计算视觉对象中其他维度（等级）的测试分数标准偏差。 ``` stdevp({Score}, [Subject]) ``` # stdevIf 基于条件语句，`stdevIf` 函数根据样本计算指定度量中按选定的一个维度或多个维度分组的一组数字的标准差。 ## 语法 ``` stdevIf(measure, conditions) ``` ## Arguments *度量* 参数必须是一个度量。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *condition* 单个语句中的一个或多个条件。 # stdevpIf 基于条件语句，`stdevpIf` 函数根据总体偏差计算指定度量中按选定的一个维度或多个维度分组的一组数字的标准差。 ## 语法 ``` stdevpIf(measure, conditions) ``` ## Arguments *度量* 参数必须是一个度量。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *condition* 单个语句中的一个或多个条件。 # sum `sum` 函数以指定的度量添加一组数字，按照选定的一个或多个维度分组。例如，`sum(profit amount)` 返回利润总额，按 (可选的) 选定维度分组。 ## 语法 ``` sum(measure, [group-by level]) ``` ## Arguments *度量* 参数必须是一个度量。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *分组依据等级* （可选）指定聚合分组依据的等级。添加的等级可以是任何维度，也可以是独立于添加到视觉对象的维度。 参数必须是一个维度字段。分组依据等级必须用方括号 `[ ]` 括起来。有关更多信息，请参阅[级别感知计算-聚合 (LAC-A](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html)) 函数。 ## 示例 以下示例返回销售总额。 ``` sum({Sales}) ``` 您还可以使用视图或数据集中的一个或多个维度来指定在哪个等级对计算进行分组。这称为 LAC-A 函数。有关 LAC-A 函数的更多信息，请参阅[级别感知计算-聚合 (LAC-](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html) A) 函数。以下示例计算国家/地区等级的销售总额，但不计算视觉对象中其他维度（区域或产品）的销售总额。 ``` sum(Sales, [Country]) ``` ![\[每个国家/地区的销售总额。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/sum-function-example.png) # sumIf 根据条件语句，`sumIf` 函数以指定的度量对一组数字求和，按照选定的一个或多个维度分组。例如，如果条件的计算结果为 true，`sumIf(ProdRev,CalendarDay >= ${BasePeriodStartDate} AND CalendarDay <= ${BasePeriodEndDate} AND SourcingType <> 'Indirect')` 返回利润总额，按（可选的）选定维度分组。 ## 语法 ``` sumIf(measure, conditions) ``` ## Arguments *度量* 参数必须是一个度量。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *condition* 单个语句中的一个或多个条件。 ## 示例 以下示例使用带 `sumIf` 的计算字段来显示销售额（如果 `Segment` 等于 `SMB`）。 ``` sumIf(Sales, Segment=’SMB’) ``` ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/sumIfCalc.png) 以下示例使用带 `sumIf` 的计算字段来显示销售额（如果 `Segment` 等于 `SMB` 并且年份 `Order Date` 晚于 2022）。 ``` sumIf(Sales, Segment=’SMB’ AND {Order Date} >=’2022-01-01’) ``` # var `var` 函数计算指定度量中按选定的一个维度或多个维度分组的一组数字的样本方差。 ## 语法 ``` var(measure, [group-by level]) ``` ## Arguments *度量* 参数必须是一个度量。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *分组依据等级* （可选）指定聚合分组依据的等级。添加的等级可以是任何维度，也可以是独立于添加到视觉对象的维度。 参数必须是一个维度字段。分组依据等级必须用方括号 `[ ]` 括起来。有关更多信息，请参阅[级别感知计算-聚合 (LAC-A](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html)) 函数。 ## 示例 以下示例返回测试分数样本的方差。 ``` var({Scores}) ``` 您还可以使用视图或数据集中的一个或多个维度来指定在哪个等级对计算进行分组。这称为 LAC-A 函数。有关 LAC-A 函数的更多信息，请参阅[级别感知计算-聚合 (LAC-](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html) A) 函数。以下示例返回主题等级的测试分数样本的方差，但不返回视觉对象中其他维度（等级）的测试分数样本方差。 ``` var({Scores}, [Subject] ``` # varIf 基于条件语句，`varIf` 函数根据样本计算指定度量中按选定的一个维度或多个维度分组的一组数字的方差。 ## 语法 ``` varIf(measure, conditions) ``` ## Arguments *度量* 参数必须是一个度量。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *condition* 单个语句中的一个或多个条件。 # varp `varp` 函数计算指定度量中按选定的一个维度或多个维度分组的一组数字的总体方差。 ## 语法 ``` varp(measure, [group-by level]) ``` ## Arguments *度量* 参数必须是一个度量。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *分组依据等级* （可选）指定聚合分组依据的等级。添加的等级可以是任何维度，也可以是独立于添加到视觉对象的维度。 参数必须是一个维度字段。分组依据等级必须用方括号 `[ ]` 括起来。有关更多信息，请参阅[级别感知计算-聚合 (LAC-A](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html)) 函数。 ## 示例 以下示例返回测试分数的总体方差。 ``` varp({Scores}) ``` 您还可以使用视图或数据集中的一个或多个维度来指定在哪个等级对计算进行分组。这称为 LAC-A 函数。有关 LAC-A 函数的更多信息，请参阅[级别感知计算-聚合 (LAC-](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations-aggregate.html) A) 函数。以下示例返回主题等级的测试分数总体方差，但不返回视觉对象中其他维度（等级）的测试分数总体方差。 ``` varp({Scores}, [Subject] ``` # varpIf 基于条件语句，`varpIf` 函数根据总体偏差计算指定度量中按选定的一个维度或多个维度分组的一组数字的方差。 ## 语法 ``` varpIf(measure, conditions) ``` ## Arguments *度量* 参数必须是一个度量。结果中的 Null 值会被忽略。文本值不起作用。参数必须是一个字段。 *condition* 单个语句中的一个或多个条件。 # 表计算函数 在分析特定视觉对象中的数据时，您可以将表计算应用于当前数据集，以了解维度如何影响度量或它们如何相互影响。*可视化数据*是基于当前数据集的结果集，并应用了所有筛选条件、字段选择和自定义项。要查看该结果集的确切内容，您可以将视觉对象导出为文件。*表计算函数* 对数据执行运算以显示字段之间的关系。 在本节中，您可以找到表计算中可用函数的列表，这些函数可以在 Amazon Quick 中对可视化数据执行。 要查看按类别排序的函数列表以及简要定义，请参阅[按类别划分的函数](https://docs.amazonaws.cn/quicksight/latest/user/functions-by-category.html)。 **Topics** + [ # difference ](difference-function.md) + [ # distinctCountOver ](distinctCountOver-function.md) + [ # lag ](lag-function.md) + [ # lead ](lead-function.md) + [ # percentDifference ](percentDifference-function.md) + [ # avgOver ](avgOver-function.md) + [ # countOver ](countOver-function.md) + [ # maxOver ](maxOver-function.md) + [ # minOver ](minOver-function.md) + [ # percentileOver ](percentileOver-function.md) + [ # percentileContOver ](percentileContOver-function.md) + [ # percentileDiscOver ](percentileDiscOver-function.md) + [ # percentOfTotal ](percentOfTotal-function.md) + [ # periodOverPeriodDifference ](periodOverPeriodDifference-function.md) + [ # periodOverPeriodLastValue ](periodOverPeriodLastValue-function.md) + [ # periodOverPeriodPercentDifference ](periodOverPeriodPercentDifference-function.md) + [ # periodToDateAvgOverTime ](periodToDateAvgOverTime-function.md) + [ # periodToDateCountOverTime ](periodToDateCountOverTime-function.md) + [ # periodToDateMaxOverTime ](periodToDateMaxOverTime-function.md) + [ # periodToDateMinOverTime ](periodToDateMinOverTime-function.md) + [ # periodToDateSumOverTime ](periodToDateSumOverTime-function.md) + [ # stdevOver ](stdevOver-function.md) + [ # stdevpOver ](stdevpOver-function.md) + [ # varOver ](varOver-function.md) + [ # varpOver ](varpOver-function.md) + [ # sumOver ](sumOver-function.md) + [ # denseRank ](denseRank-function.md) + [ # rank ](rank-function.md) + [ # percentileRank ](percentileRank-function.md) + [ # runningAvg ](runningAvg-function.md) + [ # runningCount ](runningCount-function.md) + [ # runningMax ](runningMax-function.md) + [ # runningMin ](runningMin-function.md) + [ # runningSum ](runningSum-function.md) + [ # firstValue ](firstValue-function.md) + [ # lastValue ](lastValue-function.md) + [ # windowAvg ](windowAvg-function.md) + [ # windowCount ](windowCount-function.md) + [ # windowMax ](windowMax-function.md) + [ # windowMin ](windowMin-function.md) + [ # windowSum ](windowSum-function.md) # difference `difference` 函数计算基于一组分区和排序的度量与基于其他分区和排序的度量之间的差值。 `difference` 函数支持与基于 SPICE 和直接查询数据集的分析结合使用。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` difference ( measure ,[ sortorder_field ASC_or_DESC, ... ] ,lookup_index, ,[ partition field, ... ] ) ``` ## 参数 *度量* 要查看差值的聚合度量。 *排序顺序字段* 要在对数据排序时使用的一个或多个度量和维度（以逗号分隔）。您可以指定升序 (**ASC**) 或降序 (**DESC**) 排序顺序。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *查找索引* 查找索引可以为正数或负数，表示排序中的下一行（正数）或排序中的上一行（负数）。查找索引可以为 1-2,147,483,647。对于引擎 MySQL、MariaDB 和 Aurora MySQL 兼容版，查找索引仅限为 1。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 ## 示例 以下示例计算 `sum({Billed Amount})` 和下一行之间的差值（按 `Customer Region` 升序排序并按 `Service Line` 分区）。 ``` difference( sum( {Billed Amount} ), [{Customer Region} ASC], 1, [{Service Line}] ) ``` 以下示例计算 `Billed Amount` 和下一行之间的差值（按 `[{Customer Region}]` 分区）。表计算中的字段位于视觉对象的字段井中。 ``` difference( sum( {Billed Amount} ), [{Customer Region} ASC], 1 ) ``` 红色突出显示部分显示每个金额如何相加 ( a \$1 b = c ) 以显示金额 a 和 c 之间的差值。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/differenceCalc.png) # distinctCountOver `distinctCountOver` 函数计算指定等级上按指定属性划分的操作数的不同计数。支持的等级为 `PRE_FILTER` 和 `PRE_AGG`。操作数必须是未聚合的。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` distinctCountOver ( measure or dimension field ,[ partition_field, ... ] ,calculation level ) ``` ## 参数 *度量或维度字段* 要进行计算的度量或维度，例如 `{Sales Amt}`。有效值为 `PRE_FILTER` 和 `PRE_AGG`。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *计算级别* （可选）指定要使用的计算级别： + **`PRE_FILTER`** – 在数据集筛选条件之前计算预筛选条件计算。 + **`PRE_AGG`** – 在将聚合以及前 *N* 个和后 N 个筛选条件应用于视觉对象之前计算预聚合计算。 空白时此值默认为 `POST_AGG_FILTER`。`POST_AGG_FILTER` 不是此操作的有效等级，将导致错误消息。有关更多信息，请参阅在 [Amazon Quick 中使用关卡感知计算](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations.html)。 ## 示例 以下示例获取在 `PRE_AGG` 等级按 `City` 和 `State` 分区的 `Sales` 的不同计数。 ``` distinctCountOver ( Sales, [City, State], PRE_AGG ) ``` # lag `lag` 函数计算基于指定分区和排序的度量的滞后（上一个）值。 `lag` 支持用于基于 SPICE 和直接查询数据集的分析。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` lag ( lag ( measure ,[ sortorder_field ASC_or_DESC, ... ] ,lookup_index ,[ partition_field, ... ] )] ) ``` ## 参数 *度量* 要获取滞后值的度量。这可能包括聚合，例如，`sum({Sales Amt})`。 *排序顺序字段* 要在对数据排序时使用的一个或多个度量和维度（以逗号分隔）。您可以指定升序 (**ASC**) 或降序 (**DESC**) 排序顺序。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *查找索引* 查找索引可以为正数或负数，表示排序中的下一行（正数）或排序中的上一行（负数）。查找索引可以为 1-2,147,483,647。对于引擎 MySQL、MariaDB 和 Amazon Aurora MySQL 兼容版，查找索引仅限为 1。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 ## 示例 以下示例计算上一个 `sum(sales)`（按源州/省分区并按 `cancellation_code` 升序排序顺序排序）。 ``` lag ( sum(Sales), [cancellation_code ASC], 1, [origin_state_nm] ) ``` 以下示例使用计算字段和 `lag` 在当前行的金额旁边显示上一行的销售额（按 `Order Date` 排序）。表计算中的字段位于视觉对象的字段井中。 ``` lag( sum({Sales}), [{Order Date} ASC], 1 ) ``` 以下屏幕截图显示了示例的结果。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/lagCalc.png) 以下示例使用计算字段和 `lag` 在当前行的金额旁边显示上一行的销售额（按 `Order Date` 排序，按 `Segment` 划分）。 ``` lag ( sum(Sales), [Order Date ASC], 1, [Segment] ) ``` 以下屏幕截图显示了示例的结果。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/lagCalc2.png) # lead `lead` 函数计算基于指定分区和排序的度量的前导（下一个）值。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` lead ( measure ,[ sortorder_field ASC_or_DESC, ... ] ,lookup_index, ,[ partition_field, ... ] ) ``` ## 参数 *度量* 要获取前导值的度量。这可能包括聚合，例如，`sum({Sales Amt})`。 *排序顺序字段* 要在对数据排序时使用的一个或多个度量和维度（以逗号分隔）。您可以指定升序 (**ASC**) 或降序 (**DESC**) 排序顺序。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *查找索引* 查找索引可以为正数或负数，表示排序中的下一行（正数）或排序中的上一行（负数）。查找索引可以为 1-2,147,483,647。对于引擎 MySQL、MariaDB 和 Amazon Aurora MySQL 兼容版，查找索引仅限为 1。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 ## 示例 以下示例计算下一个 `sum(sales)`（按源州/省分区并按 `cancellation_code` 升序排序顺序排序）。 ``` lead ( sum(sales), [cancellation_code ASC], 1, [origin_state_nm] ) ``` 以下示例使用计算字段和 lead 在当前行的金额旁边显示下一行的金额（按 `Customer Segment` 排序）。表计算中的字段位于视觉对象的字段井中。 ``` lead( sum({Billed Amount}), [{Customer Segment} ASC], 1 ) ``` 以下屏幕截图显示了示例的结果。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/leadCalc.png) # percentDifference `percentDifference` 函数根据分区、排序和查找索引计算当前值和比较值之间的百分比差值。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` percentDifference ( measure ,[ sortorder_field ASC_or_DESC, ... ] ,lookup index ,[ partition_field, ... ] ) ``` ## 参数 *度量* 要查看百分比差值的聚合度量。 *排序顺序字段* 要在对数据排序时使用的一个或多个度量和维度（以逗号分隔）。您可以指定升序 (**ASC**) 或降序 (**DESC**) 排序顺序。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *查找索引* 查找索引可以为正数或负数，表示排序中的下一行（正数）或排序中的上一行（负数）。查找索引可以为 1-2,147,483,647。对于引擎 MySQL、MariaDB 和 Aurora MySQL 兼容版，查找索引仅限为 1。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 ## 示例 以下示例计算当前和上一 `State` 的 `sum(Sales)` 之间的百分比差值（按 `Sales` 排序）。 ``` percentDifference ( sum(amount), [sum(amount) ASC], -1, [State] ) ``` 以下示例计算特定 `Billed Amount` 在另一个 `Billed Amount` 中所占的百分比（按 `[{Customer Region} ASC]` 排序）。表计算中的字段位于视觉对象的字段井中。 ``` percentDifference ( sum( {Billed Amount} ), [{Customer Region} ASC], 1 ) ``` 以下屏幕截图显示了示例的结果。红色字母显示 `Customer Region` **APAC** 的总额 `Billed Amount` 比 **EMEA** 区域的金额低 24%。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/percentDifference.png) # avgOver `avgOver` 函数计算按维度列表划分的度量的平均值。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` avgOver ( measure ,[ partition_field, ... ] ,calculation level ) ``` 以下示例显示 `Customer Region` 中的平均 `Billed Amount`。表计算中的字段位于视觉对象的字段井中。 ``` avgOver ( sum({Billed Amount}), [{Customer Region}] ) ``` 以下屏幕截图显示了示例的结果。通过添加 `Service Line`，将显示每个类别的总计费金额，并在计算字段中显示这三个值的平均值。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/avgOver.png) ## 参数 *度量* 要进行计算的度量，例如 `sum({Sales Amt})`。如果计算级别设置为 `NULL` 或 `POST_AGG_FILTER`，则使用聚合。如果计算级别设置为 `PRE_FILTER` 或 `PRE_AGG`，请不要使用聚合。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *计算级别* （可选）指定要使用的计算级别： + **`PRE_FILTER`** – 在数据集筛选条件之前计算预筛选条件计算。 + **`PRE_AGG`** – 在将聚合以及前 *N* 个和后 N 个筛选条件应用于视觉对象之前计算预聚合计算。 + **`POST_AGG_FILTER`** –（默认）在显示视觉对象时计算表格计算。 留空时此值默认为 `POST_AGG_FILTER`。有关更多信息，请参阅在 Quick [中使用关卡感知计算。](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations.html) ## 示例 以下示例获取按 `City` 和 `State` 分区的平均 `sum(Sales)`。 ``` avgOver ( sum(Sales), [City, State] ) ``` # countOver `countOver` 函数计算按维度列表划分的维度或度量的计数。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` countOver ( measure or dimension field ,[ partition_field, ... ] ,calculation level ) ``` ## 参数 *度量或维度字段* 要进行计算的度量或维度，例如 `sum({Sales Amt})`。如果计算级别设置为 `NULL` 或 `POST_AGG_FILTER`，则使用聚合。如果计算级别设置为 `PRE_FILTER` 或 `PRE_AGG`，请不要使用聚合。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *计算级别* （可选）指定要使用的计算级别： + **`PRE_FILTER`** – 在数据集筛选条件之前计算预筛选条件计算。 + **`PRE_AGG`** – 在将聚合以及前 *N* 个和后 N 个筛选条件应用于视觉对象之前计算预聚合计算。 + **`POST_AGG_FILTER`** –（默认）在显示视觉对象时计算表格计算。 留空时此值默认为 `POST_AGG_FILTER`。有关更多信息，请参阅在 Quick [中使用关卡感知计算。](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations.html) ## 示例 以下示例获取按 `City` 和 `State` 分区的 `Sales` 的计数。 ``` countOver ( Sales, [City, State] ) ``` 以下示例获取按 `City` 和 `State` 分区的 `{County}` 的计数。 ``` countOver ( {County}, [City, State] ) ``` 以下示例显示 `Customer Region` 中的 `Billed Amount` 计数。表计算中的字段位于视觉对象的字段井中。 ``` countOver ( sum({Billed Amount}), [{Customer Region}] ) ``` 以下屏幕截图显示了示例的结果。由于不涉及其他字段，因此，计数为每个区域一个。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/countOver1.png) 如果添加其他字段，计数将发生变化。在以下屏幕截图中，我们添加 `Customer Segment` 和 `Service Line`。其中的每个字段包含三个唯一的值。由于具有 3 个类别、3 个服务行和 3 个区域，计算字段显示 9。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/countOver2.png) 如果在计算字段 `countOver( sum({Billed Amount}), [{Customer Region}, {Customer Segment}, {Service Line}]` 的分区字段中添加两个其他字段，则每一行的计数再次变为 1。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/countOver.png) # maxOver `maxOver` 函数计算按维度列表划分的度量或日期的最大值。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` maxOver ( measure ,[ partition_field, ... ] ,calculation level ) ``` ## 参数 *度量* 要进行计算的度量，例如 `sum({Sales Amt})`。如果计算级别设置为 `NULL` 或 `POST_AGG_FILTER`，则使用聚合。如果计算级别设置为 `PRE_FILTER` 或 `PRE_AGG`，请不要使用聚合。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *计算级别* （可选）指定要使用的计算级别： + **`PRE_FILTER`** – 在数据集筛选条件之前计算预筛选条件计算。 + **`PRE_AGG`** – 在将聚合以及前 *N* 个和后 N 个筛选条件应用于视觉对象之前计算预聚合计算。 + **`POST_AGG_FILTER`** –（默认）在显示视觉对象时计算表格计算。 留空时此值默认为 `POST_AGG_FILTER`。有关更多信息，请参阅在 Quick [中使用关卡感知计算。](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations.html) ## 示例 以下示例计算按 `City` 和 `State` 分区的最大 `sum(Sales)`。 ``` maxOver ( sum(Sales), [City, State] ) ``` 以下示例显示 `Customer Region` 中的最大 `Billed Amount`。表计算中的字段位于视觉对象的字段井中。 ``` maxOver ( sum({Billed Amount}), [{Customer Region}] ) ``` 以下屏幕截图显示了示例的结果。通过添加 `Service Line`，将显示每个类别的总计费金额，并在计算字段中显示这三个值的最大值。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/maxOver.png) # minOver `minOver` 函数计算按维度列表划分的度量或日期的最小值。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` minOver ( measure ,[ partition_field, ... ] ,calculation level ) ``` ## 参数 *度量* 要进行计算的度量，例如 `sum({Sales Amt})`。如果计算级别设置为 `NULL` 或 `POST_AGG_FILTER`，则使用聚合。如果计算级别设置为 `PRE_FILTER` 或 `PRE_AGG`，请不要使用聚合。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *计算级别* （可选）指定要使用的计算级别： + **`PRE_FILTER`** – 在数据集筛选条件之前计算预筛选条件计算。 + **`PRE_AGG`** – 在将聚合以及前 *N* 个和后 N 个筛选条件应用于视觉对象之前计算预聚合计算。 + **`POST_AGG_FILTER`** –（默认）在显示视觉对象时计算表格计算。 留空时此值默认为 `POST_AGG_FILTER`。有关更多信息，请参阅在 Quick [中使用关卡感知计算。](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations.html) ## 示例 以下示例计算按 `City` 和 `State` 分区的最小 `sum(Sales)`。 ``` minOver ( sum(Sales), [City, State] ) ``` 以下示例显示 `Customer Region` 中的最小 `Billed Amount`。表计算中的字段位于视觉对象的字段井中。 ``` minOver ( sum({Billed Amount}), [{Customer Region}] ) ``` 以下屏幕截图显示了示例的结果。通过添加 `Service Line`，将显示每个类别的总计费金额，并在计算字段中显示这三个值的最小值。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/minOver.png) # percentileOver `percentileOver` 函数计算按维度列表划分的度量的第 *n* 个百分位数。Quick 中有两种`percentileOver`计算方式可供选择： + [https://docs.amazonaws.cn/quicksight/latest/user/percentileContOver-function.html](https://docs.amazonaws.cn/quicksight/latest/user/percentileContOver-function.html) 使用线性内插来确定结果。 + [https://docs.amazonaws.cn/quicksight/latest/user/percentileDiscOver-function.html](https://docs.amazonaws.cn/quicksight/latest/user/percentileDiscOver-function.html) 使用实际值来确定结果。 `percentileOver` 函数是 `percentileDiscOver` 的别名。 # percentileContOver `percentileContOver` 函数根据 `measure` 中的实际数字计算百分位数。其使用字段井中应用的分组和排序。结果按指定计算等级的指定维度划分。 使用此函数回答以下问题：此百分位数中存在哪些实际数据点？ 要返回数据集中存在的最接近的百分位数值，请使用 `percentileDiscOver`。要返回数据集中可能不存在的精确的百分位数值，请改用 `percentileContOver`。 ## 语法 ``` percentileContOver ( measure , percentile-n , [partition-by, …] , calculation-level ) ``` ## Arguments *度量* 指定用于计算百分位数的数值。参数必须是一个度量或指标。计算中将忽略 Null。 *percentile-n* 百分位数值可以是任何介于 0-100 的数字常数。百分比值 50 计算度量的中值。 *分区依据* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。如果包含多个单词，则将列表中的每个字段括在 \$1 \$1（大括号）内。整个列表括在 []（方括号）内。 *计算等级* 指定在哪里执行与计算顺序相关的计算。支持三种计算等级： + PRE\$1FILTER + PRE\$1AGG + POST\$1AGG\$1FILTER（默认）– 要使用此计算等级，请在 `measure` 上指定聚合，例如 `sum(measure)`。 在可视化中进行聚合之前应用 PRE\$1FILTER 和 PRE\$1AGG。对于这两个计算等级，您无法在计算字段表达式中的 `measure` 上指定聚合。要了解有关计算级别及其适用时间的更多信息，请参阅 [Amazon Quick 中的评估顺序和 Quick](https://docs.amazonaws.cn/quicksight/latest/user/order-of-evaluation-quicksight.html) [中的使用级别感知计算](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations.html)。 ## 返回值 函数的结果为数字。 ## percentileContOver 的示例 示例 以下示例有助于解释 percentileContOver 工作原理。 **Example 比较中值的计算等级** 以下示例使用不同的计算等级和 `percentileContOver` 函数显示维度（类别）的中值。百分位数为 50。数据集按区域字段进行筛选。每个计算字段的代码如下所示： + `example = left( category, 1 )`（一个简化示例。） + `pre_agg = percentileContOver ( {Revenue} , 50 , [ example ] , PRE_AGG)` + `pre_filter = percentileContOver ( {Revenue} , 50 , [ example ] , PRE_FILTER) ` + `post_agg_filter = percentileContOver ( sum ( {Revenue} ) , 50 , [ example ], POST_AGG_FILTER )` ``` example pre_filter pre_agg post_agg_filter ------------------------------------------------------ 0 106,728 119,667 4,117,579 1 102,898 95,946 2,307,547 2 97,807 93,963 554,570 3 101,043 112,585 2,709,057 4 96,533 99,214 3,598,358 5 106,293 97,296 1,875,648 6 97,118 69,159 1,320,672 7 100,201 90,557 969,807 ``` # percentileDiscOver `percentileDiscOver` 函数根据 `measure` 中的实际数字计算百分位数。其使用字段井中应用的分组和排序。结果按指定计算等级的指定维度划分。`percentileOver` 函数是 `percentileDiscOver` 的别名。 使用此函数回答以下问题：此百分位数中存在哪些实际数据点？ 要返回数据集中存在的最接近的百分位数值，请使用 `percentileDiscOver`。要返回数据集中可能不存在的精确的百分位数值，请改用 `percentileContOver`。 ## 语法 ``` percentileDiscOver ( measure , percentile-n , [partition-by, …] , calculation-level ) ``` ## Arguments *度量* 指定用于计算百分位数的数值。参数必须是一个度量或指标。计算中将忽略 Null。 *percentile-n* 百分位数值可以是任何介于 0-100 的数字常数。百分比值 50 计算度量的中值。 *分区依据* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。如果包含多个单词，则将列表中的每个字段括在 \$1 \$1（大括号）内。整个列表括在 []（方括号）内。 *计算等级* 指定在哪里执行与计算顺序相关的计算。支持三种计算等级： + PRE\$1FILTER + PRE\$1AGG + POST\$1AGG\$1FILTER（默认）– 要使用此计算等级，需要在 `measure` 上指定聚合，例如 `sum(measure)`。 在可视化中进行聚合之前应用 PRE\$1FILTER 和 PRE\$1AGG。对于这两个计算等级，您无法在计算字段表达式中的 `measure` 上指定聚合。要了解有关计算级别及其适用时间的更多信息，请参阅 [Amazon Quick 中的评估顺序和 Quick](https://docs.amazonaws.cn/quicksight/latest/user/order-of-evaluation-quicksight.html) [中的使用级别感知计算](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations.html)。 ## 返回值 函数的结果为数字。 ## percentileDiscOver 的示例 示例 以下示例有助于解释 percentileDiscOver 工作原理。 **Example 比较中值的计算等级** 以下示例使用不同的计算等级和 `percentileDiscOver` 函数显示维度（类别）的中值。百分位数为 50。数据集按区域字段进行筛选。每个计算字段的代码如下所示： + `example = left( category, 1 )`（一个简化示例。） + `pre_agg = percentileDiscOver ( {Revenue} , 50 , [ example ] , PRE_AGG)` + `pre_filter = percentileDiscOver ( {Revenue} , 50 , [ example ] , PRE_FILTER) ` + `post_agg_filter = percentileDiscOver ( sum ( {Revenue} ) , 50 , [ example ], POST_AGG_FILTER )` ``` example pre_filter pre_agg post_agg_filter ------------------------------------------------------ 0 106,728 119,667 4,117,579 1 102,898 95,946 2,307,547 2 97,629 92,046 554,570 3 100,867 112,585 2,709,057 4 96,416 96,649 3,598,358 5 106,293 97,296 1,875,648 6 97,118 64,395 1,320,672 7 99,915 90,557 969,807 ``` **Example 中值** 以下示例计算按 `City` 和 `State` 分区的 `Sales` 的中值（第 50 个百分位数）。 ``` percentileDiscOver ( Sales, 50, [City, State] ) ``` 以下示例计算按 `Customer Region` 分区的 `sum({Billed Amount})` 的第 98 个百分位数。表计算中的字段位于视觉对象的字段井中。 ``` percentileDiscOver ( sum({Billed Amount}), 98, [{Customer Region}] ) ``` 以下屏幕截图显示这两个示例在图表上的样子。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/percentilOver-50-98.png) # percentOfTotal `percentOfTotal` 函数根据指定的维度计算度量在总数中所占的百分比。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` percentOfTotal ( measure ,[ partition_field, ... ] ) ``` ## 参数 *度量* 要查看总数百分比的聚合度量。目前，`percentOfTotal` 不支持 `distinct count` 聚合。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 ## 示例 以下示例创建一个计算以计算每个 `State` 在总数 `Sales` 中所占的百分比。 ``` percentOfTotal ( sum(Sales), [State] ) ``` 以下示例计算特定 `Billed Amount` 在总数 `Billed Amount` 中所占的百分比（按 `[{Service Line} ASC]` 分区）。表计算中的字段位于视觉对象的字段井中。 ``` percentOfTotal ( sum( {Billed Amount} ), [{Service Line}] ) ``` 以下屏幕截图显示了示例的结果。红色突出显示部分显示值为“`Billing`”的分区字段具有三个条目，每个区域一个条目。此服务行的总账单金额拆分为三个百分比，合计为 100%。这些百分比进行四舍五入，它们之和可能并不总是恰好为 100%。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/percentOfTotal.png) # periodOverPeriodDifference `periodOverPeriodDifference` 函数计算按期间粒度和偏移量指定的两个不同时间段内的度量差异。与差异计算不同，此函数使用基于日期的偏移量而不是固定大小的偏移量。这样可以确保仅比较正确日期，即使数据集中缺少数据点也是如此。 ## 语法 ``` periodOverPeriodDifference( measure, date, period, offset) ``` ## Arguments *度量* 要对其执行 periodOverPeriod计算的聚合度量。 *dateTime* 我们计算 Period-Over-Period计算所依据的日期维度。 *时段* （可选）您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 默认值为视觉对象日期维度粒度。 *offset* （可选）偏移量可以是正整数或负整数，表示要与之比较的前一时段（按周期指定）。例如，偏移量为 1 的季度周期表示与上一季度进行比较。 默认值是 1。 ## 示例 以下示例使用计算字段 `PeriodOverPeriod` 来显示昨天的销售额差异 ``` periodOverPeriodDifference(sum(Sales), {Order Date}) ``` ![\[这是示例计算的收益图像。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/MonthOverMonthDifference.png) 以下示例使用计算字段 `PeriodOverPeriod` 来显示前两个月的销售额差异。以下示例比较 `Mar2020` 和 `Jan2020` 的销售额。 ``` periodOverPeriodDifference(sum(Sales),{Order Date}, MONTH, 1) ``` ![\[这是示例计算的收益图像。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/MonthOverMonthDifference2.png) # periodOverPeriodLastValue `periodOverPeriodLastValue` 函数计算按期间粒度和偏移量指定的上一个时间段中度量的最后一个（上一个）值。此函数使用基于日期的偏移量而不是固定大小的偏移量。这样可以确保仅比较正确日期，即使数据集中缺少数据点也是如此。 ## 语法 ``` periodOverPeriodLastValue( measure, date, period, offset) ``` ## Arguments *度量* 要查看差值的聚合度量。 *date* 计算 periodOverPeriod计算所依据的日期维度。 *时段* （可选）您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 此参数默认为视觉对象聚合的粒度 *offset* （可选）偏移量可以是正整数或负整数，表示要与之比较的前一时段（按周期指定）。例如，偏移量为 1 的季度周期表示与上一季度进行比较。 此参数默认值为 1。 ## 示例 以下示例使用视觉对象维度粒度和默认偏移量 1 计算销售额的逐月值。 ``` periodOverPeriodLastValue(sum(Sales), {Order Date}) ``` 以下示例使用 `MONTH` 的固定粒度和固定偏移量 1 计算销售额的逐月值。 ``` periodOverPeriodLastValue(sum(Sales), {Order Date},MONTH, 1) ``` ![\[这是示例计算的收益图像。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/MonthOverMonthLastValue.png) # periodOverPeriodPercentDifference `periodOverPeriodPercentDifference` 函数计算按期间粒度和偏移量指定的两个不同时间段内的百分比差异。与 percentDifference 不同，此函数使用基于日期的偏移量而不是固定大小的偏移量。这样可以确保仅比较正确日期，即使数据集中缺少数据点也是如此。 ## 语法 ``` periodOverPeriodPercentDifference( measure, date, period, offset) ``` ## Arguments *度量* 要查看差值的聚合度量。 *date* 计算 periodOverPeriod计算所依据的日期维度。 *时段* （可选）您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 此参数默认为视觉对象聚合的粒度 *offset* （可选）偏移量可以是正整数或负整数，表示要与之比较的前一时段（按周期指定）。例如，偏移量为 1 的季度周期表示与上一季度进行比较。 此参数默认值为 1。 ## 示例 以下示例使用视觉对象维度粒度和默认偏移量 1 计算销售额的逐月百分比差异。 ``` periodOverPeriodPercentDifference(sum(Sales),{Order Date}) ``` 以下示例使用 `MONTH` 的固定粒度和固定偏移量 1 计算销售额的逐月百分比差异。 ``` periodOverPeriodPercentDifference(sum(Sales), {Order Date}, MONTH, 1) ``` ![\[这是示例计算的收益图像。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/MonthOverMonthPercentDifference.png) # periodToDateAvgOverTime `periodToDateAvgOverTime` 函数计算给定时间粒度（例如一个季度）到某个时间点的平均值。 ## 语法 ``` periodToDateAvgOverTime( measure, dateTime, period) ``` ## Arguments *度量* 要对其执行计算的聚合度量 *dateTime* 计算 PeriodOverTime计算所依据的日期维度。 *时段* （可选）您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 默认值为视觉对象日期维度粒度。 ## 示例 以下函数计算逐月平均付款金额。 ``` periodToDateAvgOverTime(sum({fare_amount}), pickupDatetime, MONTH) ``` ![\[这是示例计算的结果图像（附插图）。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/PTDAvgOverTimeResults.png) # periodToDateCountOverTime `periodToDateCountOverTime` 函数计算给定时间粒度（例如一个季度）到某个时间点的维度或度量的计数。 ## 语法 ``` periodToDateCountOverTime( measure, dateTime, period) ``` ## Arguments *度量* 要对其执行计算的聚合度量 *dateTime* 计算 PeriodOverTime计算所依据的日期维度。 *时段* （可选）您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 默认值为视觉对象日期维度粒度。 ## 示例 以下示例计算逐月供应商数量。 ``` periodToDateCountOverTime(count(vendorid), pickupDatetime, MONTH) ``` ![\[这是示例计算的结果图像（附插图）。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/PTDCountOverTimeResults.png) # periodToDateMaxOverTime `periodToDateMaxOverTime` 函数计算给定时间粒度（例如一个季度）到某个时间点的度量的最大值。 ## 语法 ``` periodToDateMaxOverTime( measure, dateTime, period) ``` ## Arguments *度量* 要对其执行计算的聚合度量 *dateTime* 计算 PeriodOverTime计算所依据的日期维度。 *时段* （可选）您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 默认值为视觉对象日期维度粒度。 ## 示例 以下示例计算逐月最高付款金额。 ``` periodToDatemaxOverTime(max({fare_amount}), pickupDatetime, MONTH) ``` ![\[这是示例计算的结果图像（附插图）。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/PTDMaxOverTimeResults.png) # periodToDateMinOverTime `periodToDateMinOverTime` 函数计算给定时间粒度（例如一个季度）到某个时间点的度量的最小值。 ## 语法 ``` periodToDateMinOverTime( measure, dateTime, period) ``` ## Arguments *度量* 要对其执行计算的聚合度量 *dateTime* 计算 PeriodOverTime计算所依据的日期维度。 *时段* （可选）您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 默认值为视觉对象日期维度粒度。 ## 示例 以下示例计算逐月最低付款金额。 ``` periodToDateMinOverTime(min({fare_amount}), pickupDatetime, MONTH) ``` ![\[这是示例计算的结果图像（附插图）。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/PTDMinOverTimeResults.png) # periodToDateSumOverTime `periodToDateSumOverTime` 函数计算给定时间粒度（例如一个季度）到某个时间点的度量的总和。 ## 语法 ``` periodToDateSumOverTime( measure, dateTime, period) ``` ## Arguments *度量* 要对其执行计算的聚合度量 *dateTime* 计算 PeriodOverTime计算所依据的日期维度。 *时段* （可选）您进行计算的时间段。`YEAR` 的粒度表示 `YearToDate` 计算，`Quarter` 表示 `QuarterToDate` 等等。有效的粒度包括 `YEAR`、`QUARTER`、`MONTH`、`WEEK`、`DAY`、`HOUR`、`MINUTE` 和 `SECONDS`。 默认值为视觉对象日期维度粒度。 ## 示例 以下函数返回逐月付款总金额。 ``` periodToDateSumOverTime(sum({fare_amount}), pickupDatetime, MONTH) ``` ![\[这是示例计算的结果图像（附插图）。\]](http://docs.amazonaws.cn/quick/latest/userguide/images/PTDSumOverTime-example-results.png) # stdevOver `stdevOver` 函数根据样本计算按选定的一个属性或多个属性划分的指定度量的标准偏差。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` stdevOver ( measure ,[ partition_field, ... ] ,calculation level ) ``` ## 参数 *度量* 要进行计算的度量，例如 `sum({Sales Amt})`。如果计算级别设置为 `NULL` 或 `POST_AGG_FILTER`，则使用聚合。如果计算级别设置为 `PRE_FILTER` 或 `PRE_AGG`，请不要使用聚合。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *计算级别* （可选）指定要使用的计算级别： + **`PRE_FILTER`** – 在数据集筛选条件之前计算预筛选条件计算。 + **`PRE_AGG`** – 在将聚合以及前 *N* 个和后 N 个筛选条件应用于视觉对象之前计算预聚合计算。 + **`POST_AGG_FILTER`** –（默认）在显示视觉对象时计算表格计算。 留空时此值默认为 `POST_AGG_FILTER`。有关更多信息，请参阅在 Quick [中使用关卡感知计算。](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations.html) ## 示例 以下示例根据样本计算按 `City` 和 `State` 划分的 `sum(Sales)` 的标准差。 ``` stdevOver ( sum(Sales), [City, State] ) ``` 以下示例根据样本计算 `Customer Region` 的 `Billed Amount` 的标准差。表计算中的字段位于视觉对象的字段井中。 ``` stdevOver ( sum({Billed Amount}), [{Customer Region}] ) ``` # stdevpOver `stdevpOver` 函数根据总体偏差计算按选定的一个属性或多个属性划分的指定度量的标准偏差。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` stdevpOver ( measure ,[ partition_field, ... ] ,calculation level ) ``` ## 参数 *度量* 要进行计算的度量，例如 `sum({Sales Amt})`。如果计算级别设置为 `NULL` 或 `POST_AGG_FILTER`，则使用聚合。如果计算级别设置为 `PRE_FILTER` 或 `PRE_AGG`，请不要使用聚合。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *计算级别* （可选）指定要使用的计算级别： + **`PRE_FILTER`** – 在数据集筛选条件之前计算预筛选条件计算。 + **`PRE_AGG`** – 在将聚合以及前 *N* 个和后 N 个筛选条件应用于视觉对象之前计算预聚合计算。 + **`POST_AGG_FILTER`** –（默认）在显示视觉对象时计算表格计算。 留空时此值默认为 `POST_AGG_FILTER`。有关更多信息，请参阅在 Quick [中使用关卡感知计算。](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations.html) ## 示例 以下示例根据总体偏差计算按 `City` 和 `State` 划分的 `sum(Sales)` 的标准差。 ``` stdevpOver ( sum(Sales), [City, State] ) ``` 以下示例根据总体偏差计算 `Customer Region` 的 `Billed Amount` 的标准差。表计算中的字段位于视觉对象的字段井中。 ``` stdevpOver ( sum({Billed Amount}), [{Customer Region}] ) ``` # varOver `varOver` 函数根据样本计算按选定的一个属性或多个属性划分的指定度量的方差。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` varOver ( measure ,[ partition_field, ... ] ,calculation level ) ``` ## 参数 *度量* 要进行计算的度量，例如 `sum({Sales Amt})`。如果计算级别设置为 `NULL` 或 `POST_AGG_FILTER`，则使用聚合。如果计算级别设置为 `PRE_FILTER` 或 `PRE_AGG`，请不要使用聚合。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *计算级别* （可选）指定要使用的计算级别： + **`PRE_FILTER`** – 在数据集筛选条件之前计算预筛选条件计算。 + **`PRE_AGG`** – 在将聚合以及前 *N* 个和后 N 个筛选条件应用于视觉对象之前计算预聚合计算。 + **`POST_AGG_FILTER`** –（默认）在显示视觉对象时计算表格计算。 留空时此值默认为 `POST_AGG_FILTER`。有关更多信息，请参阅在 Quick [中使用关卡感知计算。](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations.html) ## 示例 以下示例根据样本计算按 `City` 和 `State` 划分的 `sum(Sales)` 的方差。 ``` varOver ( sum(Sales), [City, State] ) ``` 以下示例根据样本计算 `Customer Region` 的 `Billed Amount` 的方差。表计算中的字段位于视觉对象的字段井中。 ``` varOver ( sum({Billed Amount}), [{Customer Region}] ) ``` # varpOver `varpOver` 函数根据总体偏差计算按选定的一个属性或多个属性划分的指定度量的方差。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` varpOver ( measure ,[ partition_field, ... ] ,calculation level ) ``` ## 参数 *度量* 要进行计算的度量，例如 `sum({Sales Amt})`。如果计算级别设置为 `NULL` 或 `POST_AGG_FILTER`，则使用聚合。如果计算级别设置为 `PRE_FILTER` 或 `PRE_AGG`，请不要使用聚合。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *计算级别* （可选）指定要使用的计算级别： + **`PRE_FILTER`** – 在数据集筛选条件之前计算预筛选条件计算。 + **`PRE_AGG`** – 在将聚合以及前 *N* 个和后 N 个筛选条件应用于视觉对象之前计算预聚合计算。 + **`POST_AGG_FILTER`** –（默认）在显示视觉对象时计算表格计算。 留空时此值默认为 `POST_AGG_FILTER`。有关更多信息，请参阅在 Quick [中使用关卡感知计算。](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations.html) ## 示例 以下示例根据总体偏差计算按 `City` 和 `State` 划分的 `sum(Sales)` 的方差。 ``` varpOver ( sum(Sales), [City, State] ) ``` 以下示例根据总体偏差计算 `Customer Region` 的 `Billed Amount` 的方差。表计算中的字段位于视觉对象的字段井中。 ``` varpOver ( sum({Billed Amount}), [{Customer Region}] ) ``` # sumOver `sumOver` 函数计算按维度列表划分的度量的总和。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` sumOver ( measure ,[ partition_field, ... ] ,calculation level ) ``` ## 参数 *度量* 要进行计算的度量，例如 `sum({Sales Amt})`。如果计算级别设置为 `NULL` 或 `POST_AGG_FILTER`，则使用聚合。如果计算级别设置为 `PRE_FILTER` 或 `PRE_AGG`，请不要使用聚合。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *计算级别* （可选）指定要使用的计算级别： + **`PRE_FILTER`** – 在数据集筛选条件之前计算预筛选条件计算。 + **`PRE_AGG`** – 在将聚合以及前 *N* 个和后 N 个筛选条件应用于视觉对象之前计算预聚合计算。 + **`POST_AGG_FILTER`** –（默认）在显示视觉对象时计算表格计算。 留空时此值默认为 `POST_AGG_FILTER`。有关更多信息，请参阅在 Quick [中使用关卡感知计算。](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations.html) ## 示例 以下示例计算 `sum(Sales)` 的总和（按 `City` 和 `State` 分区）。 ``` sumOver ( sum(Sales), [City, State] ) ``` 以下示例计算 `Customer Region` 中的 `Billed Amount` 的总和。表计算中的字段位于视觉对象的字段井中。 ``` sumOver ( sum({Billed Amount}), [{Customer Region}] ) ``` 以下屏幕截图显示了示例的结果。通过添加 `Customer Segment`，将为 `Customer Region` 计算每个类别的计费金额总和，并显示在计算字段中。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/sumOver.png) # denseRank `denseRank` 函数计算某个度量或维度相对于指定分区的排名。它仅对每个项目计数一次（忽略重复的值），并分配“无孔的”排名，以使重复的值具有相同的排名。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` denseRank ( [ sort_order_field ASC_or_DESC, ... ] ,[ partition_field, ... ] ) ``` ## 参数 *排序顺序字段* 要在对数据排序时使用的一个或多个聚合字段（度量和/或维度），以逗号分隔。您可以指定升序 (**ASC**) 或降序 (**DESC**) 排序顺序。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *计算级别* （可选）指定要使用的计算级别： + **`PRE_FILTER`** – 在数据集筛选条件之前计算预筛选条件计算。 + **`PRE_AGG`** – 在将聚合以及前 *N* 个和后 N 个筛选条件应用于视觉对象之前计算预聚合计算。 + **`POST_AGG_FILTER`** –（默认）在显示视觉对象时计算表格计算。 留空时此值默认为 `POST_AGG_FILTER`。有关更多信息，请参阅在 Quick [中使用关卡感知计算。](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations.html) ## 示例 以下示例根据降序排序顺序按 `State` 和 `City` 对 `max(Sales)` 进行密集排名。将为具有相同 `max(Sales)` 的任何城市分配相同的排名，并且下一个城市紧靠这些城市进行连续排名。例如，如果三个城市具有相同的排名，则第四个城市排名第二。 ``` denseRank ( [max(Sales) DESC], [State, City] ) ``` 以下示例根据降序排序顺序按 `State` 对 `max(Sales)` 进行密集排名。将为具有相同 `max(Sales)` 的任何州/省分配相同的排名，并且下一个州/省紧靠这些州/省进行连续排名。例如，如果三个州/省具有相同的排名，则第四个州/省排名第二。 ``` denseRank ( [max(Sales) DESC], [State] ) ``` # rank `rank` 函数计算某个度量或维度相对于指定分区的排名。它计算一次每个项目（即使是重复的），并分配一个“带孔的”排名以考虑到重复的值。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` rank ( [ sort_order_field ASC_or_DESC, ... ] ,[ partition_field, ... ] ) ``` ## 参数 *排序顺序字段* 要在对数据排序时使用的一个或多个聚合度量和维度（以逗号分隔）。您可以指定升序 (**ASC**) 或降序 (**DESC**) 排序顺序。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *计算级别* （可选）指定要使用的计算级别： + **`PRE_FILTER`** – 在数据集筛选条件之前计算预筛选条件计算。 + **`PRE_AGG`** – 在将聚合以及前 *N* 个和后 N 个筛选条件应用于视觉对象之前计算预聚合计算。 + **`POST_AGG_FILTER`** –（默认）在显示视觉对象时计算表格计算。 留空时此值默认为 `POST_AGG_FILTER`。有关更多信息，请参阅在 Quick [中使用关卡感知计算。](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations.html) ## 示例 以下示例根据降序排序顺序按 `State` 和 `City` 在 `State` **WA** 中对 `max(Sales)` 进行排名。将为具有相同 `max(Sales)` 的任何城市分配相同的排名，但下一个排名包括所有以前存在的排名计数。例如，如果三个城市具有相同的排名，则第四个城市排名第四。 ``` rank ( [max(Sales) DESC], [State, City] ) ``` 以下示例根据升序排序顺序按 `State` 对 `max(Sales)` 进行排名。将为具有相同 `max(Sales)` 的任何州/省分配相同的排名，但下一个排名包括所有以前存在的排名计数。例如，如果三个州/省具有相同的排名，则第四个州/省排名第四。 ``` rank ( [max(Sales) ASC], [State] ) ``` 以下示例按总数 `Billed Amount` 对 `Customer Region` 进行排名。表计算中的字段位于视觉对象的字段井中。 ``` rank( [sum({Billed Amount}) DESC] ) ``` 在以下屏幕截图中显示了示例的结果以及总数 `Billed Amount`，因此，您可以了解每个区域是如何进行排名的。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/rankCalc.png) # percentileRank `percentileRank` 函数计算某个度量或维度相对于指定分区的百分位数排名。百分位数排名值 (*x*) 表示当前项目高于指定分区中值的*x*百分比。百分位数排名值范围从 0（包含）到 100（不包含）。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` percentileRank ( [ sort_order_field ASC_or_DESC, ... ] ,[ {partition_field}, ... ] ) ``` ## 参数 *排序顺序字段* 要在对数据排序时使用的一个或多个聚合度量和维度（以逗号分隔）。您可以指定升序 (**ASC**) 或降序 (**DESC**) 排序顺序。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *计算级别* （可选）指定要使用的计算级别： + **`PRE_FILTER`** – 在数据集筛选条件之前计算预筛选条件计算。 + **`PRE_AGG`** – 在将聚合以及前 *N* 个和后 N 个筛选条件应用于视觉对象之前计算预聚合计算。 + **`POST_AGG_FILTER`** –（默认）在显示视觉对象时计算表格计算。 留空时此值默认为 `POST_AGG_FILTER`。有关更多信息，请参阅在 Quick [中使用关卡感知计算。](https://docs.amazonaws.cn/quicksight/latest/user/level-aware-calculations.html) ## 示例 以下示例按 `State` 的降序顺序执行 `max(Sales)` 的百分位数排名。 ``` percentileRank ( [max(Sales) DESC], [State] ) ``` 以下示例按总和 `Billed Amount` 执行 `Customer Region` 的百分位数排名。表计算中的字段位于视觉对象的字段井中。 ``` percentileRank( [sum({Billed Amount}) DESC], [{Customer Region}] ) ``` 在以下屏幕截图中显示了示例的结果以及总数 `Billed Amount`，因此，您可以了解每个区域是如何进行比较的。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/percentileRank.png) # runningAvg `runningAvg` 函数计算基于指定维度和排序顺序的度量的运行平均值。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` runningAvg ( measure ,[ sortorder_field ASC_or_DESC, ... ] ,[ partition_field, ... ] ) ``` ## 参数 *度量* 要查看其运行平均值的聚合度量。 *排序顺序字段* 要在对数据排序时使用的一个或多个度量和维度（以逗号分隔）。您可以指定升序 (**ASC**) 或降序 (**DESC**) 排序顺序。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 ## 示例 以下示例计算 `sum(Sales)` 的运行平均值（按 `Sales` 排序，并按 `City` 和 `State` 分区）。 ``` runningAvg ( sum(Sales), [Sales ASC], [City, State] ) ``` 以下示例计算 `Billed Amount` 的运行平均值（按月排序 (`[truncDate("MM",Date) ASC]`)）。表计算中的字段位于视觉对象的字段井中。 ``` runningAvg ( sum({Billed Amount}), [truncDate("MM",Date) ASC] ) ``` # runningCount `runningCount` 函数计算基于指定维度和排序顺序的度量或维度的运行计数。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` runningCount ( measure_or_dimension ,[ sortorder_field ASC_or_DESC, ... ] ,[ partition_field, ... ] ) ``` ## 参数 *measure or dimension* 要查看其运行计数的聚合度量或维度。 *排序顺序字段* 要在对数据排序时使用的一个或多个度量和维度（以逗号分隔）。您可以指定升序 (**ASC**) 或降序 (**DESC**) 排序顺序。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 ## 示例 以下示例计算 `sum(Sales)` 的运行计数（按 `Sales` 排序，并按 `City` 和 `State` 分区）。 ``` runningCount ( sum(Sales), [Sales ASC], [City, State] ) ``` 以下示例计算 `Billed Amount` 的运行计数（按月排序 (`[truncDate("MM",Date) ASC]`)）。表计算中的字段位于视觉对象的字段井中。 ``` runningCount ( sum({Billed Amount}), [truncDate("MM",Date) ASC] ) ``` # runningMax `runningMax` 函数计算基于指定维度和排序顺序的度量的运行最大值。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` runningMax ( measure ,[ sortorder_field ASC_or_DESC, ... ] ,[ partition_field, ... ] ) ``` ## 参数 *度量* 要查看其运行最大值的聚合度量。 *排序顺序字段* 要在对数据排序时使用的一个或多个度量和维度（以逗号分隔）。您可以指定升序 (**ASC**) 或降序 (**DESC**) 排序顺序。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 ## 示例 以下示例计算 `sum(Sales)` 的运行最大值（按 `Sales` 排序，并按 `City` 和 `State` 分区）。 ``` runningMax ( sum(Sales), [Sales ASC], [City, State] ) ``` 以下示例计算 `Billed Amount` 的运行最大值（按月排序 (`[truncDate("MM",Date) ASC]`)）。表计算中的字段位于视觉对象的字段井中。 ``` runningMax ( sum({Billed Amount}), [truncDate("MM",Date) ASC] ) ``` # runningMin `runningMin` 函数计算基于指定维度和排序顺序的度量的运行最小值。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` runningMin ( measure ,[ sortorder_field ASC_or_DESC, ... ] ,[ partition_field, ... ] ) ``` ## 参数 *度量* 要查看其运行最小值的聚合度量。 *排序顺序字段* 要在对数据排序时使用的一个或多个度量和维度（以逗号分隔）。您可以指定升序 (**ASC**) 或降序 (**DESC**) 排序顺序。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 ## 示例 以下示例计算 `sum(Sales)` 的运行最小值（按 `Sales` 排序，并按 `City` 和 `State` 分区）。 ``` runningMin ( sum(Sales), [Sales ASC], [City, State] ) ``` 以下示例计算 `Billed Amount` 的运行最小值（按月排序 (`[truncDate("MM",Date) ASC]`)）。表计算中的字段位于视觉对象的字段井中。 ``` runningMin ( sum({Billed Amount}), [truncDate("MM",Date) ASC] ) ``` # runningSum `runningSum` 函数计算基于指定维度和排序顺序的度量的运行总和。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` runningSum ( measure ,[ sortorder_field ASC_or_DESC, ... ] ,[ partition_field, ... ] ) ``` ## 参数 *度量* 要查看运行总和的聚合度量。 *排序顺序字段* 要在对数据排序时使用的一个或多个度量和维度（以逗号分隔）。您可以指定升序 (**ASC**) 或降序 (**DESC**) 排序顺序。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 ## 示例 以下示例计算 `sum(Sales)` 的运行总和（按 `Sales` 排序，并按 `City` 和 `State` 分区）。 ``` runningSum ( sum(Sales), [Sales ASC], [City, State] ) ``` 以下示例计算 `Billed Amount` 的运行总和（按月排序 (`[truncDate("MM",Date) ASC]`)）。表计算中的字段位于视觉对象的字段井中。 ``` runningSum ( sum({Billed Amount}), [truncDate("MM",Date) ASC] ) ``` 以下屏幕截图显示了示例的结果。红色标签显示每个金额如何与下一金额相加 (`a + b = c`)，从而得出新的总额。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/runningSum.png) # firstValue `firstValue` 函数计算按指定属性划分和排序的聚合度量或维度的第一个值。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` firstValue ( aggregated measure or dimension, [ sort_attribute ASC_or_DESC, ... ], [ partition_by_attribute, ... ] ) ``` ## 参数 *聚合度量或维度* 要查看其第一个值的聚合度量或维度。 *sort attribute* 要在对数据排序时使用的一个或多个聚合字段（度量和/或维度），以逗号分隔。您可以指定升序 (**ASC**) 或降序 (**DESC**) 排序顺序。 如果列表中的某个字段不止包含一个单词，则用 \$1 \$1 （大括号）将该字段括起来。整个列表括在 []（方括号）内。 *按属性划分* （可选）要在划分时使用的一个或多个度量或维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 ## 示例 以下示例计算第一个 `Destination Airport`，按 `Flight Date` 排序，按 `Flight Date` 的升序顺序和 `Origin Airport` 划分。 ``` firstValue( {Destination Airport} [{Flight Date} ASC], [ {Origin Airport}, {Flight Date} ] ) ``` # lastValue `lastValue` 函数计算按指定属性划分和排序的聚合度量或维度的最后一个值。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` lastValue ( aggregated measure or dimension, [ sort_attribute ASC_or_DESC, ... ], [ partition_by_attribute, ... ] ) ``` ## 参数 *聚合度量或维度* 要查看其最后一个值的聚合度量或维度。 *sort attribute* 要在对数据排序时使用的一个或多个聚合字段（度量和/或维度），以逗号分隔。您可以指定升序 (`ASC`) 或降序 (`DESC`) 排序顺序。 如果列表中的某个字段不止包含一个单词，则用 \$1 \$1 （大括号）将该字段括起来。整个列表括在 []（方括号）内。 *按属性划分* （可选）要在划分时使用的一个或多个度量或维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 ## 示例 以下示例计算 `Destination Airport` 的最后一个值。该计算按 `Flight Date` 值排序，并按 `Flight Date` 值的升序排序和 `Origin Airport` 值划分。 ``` lastValue( [{Destination Airport}], [{Flight Date} ASC], [ {Origin Airport}, truncDate('DAY', {Flight Date}) ] ) ``` # windowAvg `windowAvg` 函数计算按指定属性划分和排序的自定义窗口中聚合度量的平均值。通常，在视觉对象显示指标和日期字段的时间序列上使用自定义窗口函数。例如，您可以使用 `windowAvg` 来计算移动平均值，这通常用于消除折线图中的噪声。 MySQL 8 之前和 MariaDB 10.2 之前的版本不支持窗口函数。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` windowAvg ( measure , [sort_order_field ASC/DESC, ...] , start_index , end_index ,[ partition_field, ... ] ) ``` ## 参数 *度量* 要获取其平均值的聚合度量，例如，`sum({Revenue})`。 *sort attribute* 要在对数据排序时使用的一个或多个聚合字段（度量和/或维度），以逗号分隔。您可以指定升序 (**ASC**) 或降序 (**DESC**) 排序顺序。 如果列表中的某个字段不止包含一个单词，则用 \$1 \$1 （大括号）将该字段括起来。整个列表括在 []（方括号）内。 *start index* 起始索引 (start index) 是一个正整数，指示当前行之上的 *n* 行。起始索引 计算当前行上方的可用数据点，而不是计算实际时间段。如果数据稀疏（例如，缺少几个月或几年），请相应地调整索引。 *end index* 结束索引 (end index) 是一个正整数，指示当前行之下的 *n* 行。结束索引 计算当前行下方的可用数据点，而不是计算实际时间段。如果数据稀疏（例如，缺少几个月或几年），请相应地调整索引。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果列表中的某个字段不止包含一个单词，则用 \$1 \$1 （大括号）将该字段括起来。整个列表括在 []（方括号）内。 ## 示例 以下示例计算 `sum(Revenue)` 的移动平均值（按 `SaleDate` 分区）。计算包括当前行上方的 3 行和下面的 2 行。 ``` windowAvg ( sum(Revenue), [SaleDate ASC], 3, 2 ) ``` 下面的屏幕截图显示了此移动平均值示例的结果。sum(Revenue) 字段添加到图表中，以显示该收入与收入移动平均值之间的差异。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/windowAvg.png) # windowCount `windowCount` 函数计算按指定属性划分和排序的自定义窗口中聚合度量或维度的计数。通常，在视觉对象显示指标和日期字段的时间序列上使用自定义窗口函数。 MySQL 8 之前和 MariaDB 10.2 之前的版本不支持窗口函数。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` windowCount ( measure_or_dimension , [sort_order_field ASC/DESC, ...] , start_index , end_index ,[ partition_field, ... ] ) ``` ## 参数 *measure or dimension* 要获取其平均值的聚合度量，例如，`sum({Revenue})`。 *sort attribute* 要在对数据排序时使用的一个或多个聚合字段（度量和/或维度），以逗号分隔。您可以指定升序 (**ASC**) 或降序 (**DESC**) 排序顺序。 如果列表中的某个字段不止包含一个单词，则用 \$1 \$1 （大括号）将该字段括起来。整个列表括在 []（方括号）内。 *start index* 起始索引 (start index) 是一个正整数，指示当前行之上的 *n* 行。起始索引 计算当前行上方的可用数据点，而不是计算实际时间段。如果数据稀疏（例如，缺少几个月或几年），请相应地调整索引。 *end index* 结束索引 (end index) 是一个正整数，指示当前行之下的 *n* 行。结束索引 计算当前行下方的可用数据点，而不是计算实际时间段。如果数据稀疏（例如，缺少几个月或几年），请相应地调整索引。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果列表中的某个字段不止包含一个单词，则用 \$1 \$1 （大括号）将该字段括起来。整个列表括在 []（方括号）内。 ## 示例 以下示例计算 `sum(Revenue)` 的移动计数（按 `SaleDate` 分区）。计算包括当前行上方的 3 行和下面的 2 行。 ``` windowCount ( sum(Revenue), [SaleDate ASC], 3, 2 ) ``` # windowMax `windowMax` 函数计算按指定属性划分和排序的自定义窗口中聚合度量的最大值。通常，在视觉对象显示指标和日期字段的时间序列上使用自定义窗口函数。您可以使用 `windowMax` 来帮助确定指标在一段时间内的最大值。 MySQL 8 之前和 MariaDB 10.2 之前的版本不支持窗口函数。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` windowMax ( measure , [sort_order_field ASC/DESC, ...] , start_index , end_index ,[ partition_field, ... ] ) ``` ## 参数 *度量* 要获取其平均值的聚合度量，例如，`sum({Revenue})`。 *sort attribute* 要在对数据排序时使用的一个或多个聚合字段（度量和/或维度），以逗号分隔。您可以指定升序 (**ASC**) 或降序 (**DESC**) 排序顺序。 如果列表中的某个字段不止包含一个单词，则用 \$1 \$1 （大括号）将该字段括起来。整个列表括在 []（方括号）内。 *start index* 起始索引 (start index) 是一个正整数，指示当前行之上的 *n* 行。起始索引 计算当前行上方的可用数据点，而不是计算实际时间段。如果数据稀疏（例如，缺少几个月或几年），请相应地调整索引。 *end index* 结束索引 (end index) 是一个正整数，指示当前行之下的 *n* 行。结束索引 计算当前行下方的可用数据点，而不是计算实际时间段。如果数据稀疏（例如，缺少几个月或几年），请相应地调整索引。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果包含多个单词，则将列表中的每个字段括在 \$1\$1（大括号）内。整个列表括在 []（方括号）内。 ## 示例 以下示例计算按 `SaleDate` 分区的 `sum(Revenue)` 的随后 12 个月最大值。计算包括当前行上方的 12 行和下面的 0 行。 ``` windowMax ( sum(Revenue), [SaleDate ASC], 12, 0 ) ``` 以下屏幕截图显示了此随后 12 个月示例的结果。sum(Revenue) 字段添加到了图表中，以显示该收入与随后 12 个月最大收入之间的差异。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/windowMax.png) # windowMin `windowMin` 函数计算按指定属性划分和排序的自定义窗口中聚合度量的最小值。通常，在视觉对象显示指标和日期字段的时间序列上使用自定义窗口函数。您可以使用 `windowMin` 来帮助确定指标在一段时间内的最小值。 MySQL 8 之前和 MariaDB 10.2 之前的版本不支持窗口函数。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` windowMin ( measure , [sort_order_field ASC/DESC, ...] , start_index , end_index ,[ partition_field, ... ] ) ``` ## 参数 *度量* 要获取其平均值的聚合度量，例如，`sum({Revenue})`。 *sort attribute* 要在对数据排序时使用的一个或多个聚合字段（度量和/或维度），以逗号分隔。您可以指定升序 (**ASC**) 或降序 (**DESC**) 排序顺序。 如果列表中的某个字段不止包含一个单词，则用 \$1 \$1 （大括号）将该字段括起来。整个列表括在 []（方括号）内。 *start index* 起始索引 (start index) 是一个正整数，指示当前行之上的 *n* 行。起始索引 计算当前行上方的可用数据点，而不是计算实际时间段。如果数据稀疏（例如，缺少几个月或几年），请相应地调整索引。 *end index* 结束索引 (end index) 是一个正整数，指示当前行之下的 *n* 行。结束索引 计算当前行下方的可用数据点，而不是计算实际时间段。如果数据稀疏（例如，缺少几个月或几年），请相应地调整索引。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果列表中的某个字段不止包含一个单词，则用 \$1 \$1 （大括号）将该字段括起来。整个列表括在 []（方括号）内。 ## 示例 以下示例计算按 `SaleDate` 分区的 `sum(Revenue)` 的随后 12 个月最小值。计算包括当前行上方的 12 行和下面的 0 行。 ``` windowMin ( sum(Revenue), [SaleDate ASC], 12, 0 ) ``` 以下屏幕截图显示了此随后 12 个月示例的结果。sum(Revenue) 字段添加到了图表中，以显示该收入与随后 12 个月最小收入之间的差异。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/windowMin.png) # windowSum `windowSum` 函数计算按指定属性划分和排序的自定义窗口中聚合度量的总和。通常，在视觉对象显示指标和日期字段的时间序列上使用自定义窗口函数。 MySQL 8 之前和 MariaDB 10.2 之前的版本不支持窗口函数。 ## 语法 括号是必需的。要查看哪些参数是可选的，请参阅以下说明。 ``` windowSum ( measure , [sort_order_field ASC/DESC, ...] , start_index , end_index ,[ partition_field, ... ] ) ``` ## 参数 *度量* 要获取其总和的聚合度量，例如，`sum({Revenue})`。 对于引擎 MySQL、MariaDB 和兼容 MySQL 的 Amazon Aurora，查找索引仅限为 1。MySQL 8 之前和 MariaDB 10.2 之前的版本不支持窗口函数。 *sort attribute* 要在对数据排序时使用的一个或多个聚合字段（度量和/或维度），以逗号分隔。您可以指定升序 (**ASC**) 或降序 (**DESC**) 排序顺序。 如果列表中的某个字段不止包含一个单词，则用 \$1 \$1 （大括号）将该字段括起来。整个列表括在 []（方括号）内。 *start index* 起始索引 (start index) 是一个正整数，指示当前行之上的 *n* 行。起始索引 计算当前行上方的可用数据点，而不是计算实际时间段。如果数据稀疏（例如，缺少几个月或几年），请相应地调整索引。 *end index* 结束索引 (end index) 是一个正整数，指示当前行之下的 *n* 行。结束索引 计算当前行下方的可用数据点，而不是计算实际时间段。如果数据稀疏（例如，缺少几个月或几年），请相应地调整索引。 *分区字段* （可选）要在分区时使用的一个或多个维度（以逗号分隔）。 如果列表中的某个字段不止包含一个单词，则用 \$1 \$1 （大括号）将该字段括起来。整个列表括在 []（方括号）内。 ## 示例 以下示例计算 `sum(Revenue)` 的移动总和（按 `SaleDate` 排序）。计算包括当前行上方的 2 行和前面的 1 行。 ``` windowSum ( sum(Revenue), [SaleDate ASC], 2, 1 ) ``` 以下示例显示随后 12 个月的总和。 ``` windowSum(sum(Revenue),[SaleDate ASC],12,0) ``` 下面的屏幕截图显示了此随后 12 个月总和示例的结果。`sum(Revenue)` 字段添加到图表中，以显示该收入与随后 12 个月总和收入之间的差异。 ![\[alt text not found\]](http://docs.amazonaws.cn/quick/latest/userguide/images/windowSum.png)