本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 函数


在本节中，您可以找到 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( )` 函数中以获得最终版本。以下示例省略了原始版本中的东南区域的州。您可以重新添加这些州来代替 *`<insert more regions here>`* 标签。

   如果要添加更多区域，则可以构造这两行的更多副本，并根据自己的目的更改州列表。您可以将区域名称更改为适合自己的名称，也可以将字段名称从 `State` 更改为所需的任何名称。

   ```
   ifelse 
   (
   /*The if expression:*/     locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0,
   /*The then expression:*/   'Northeast',
   
   /*<insert more regions here>*/
   
   /*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
```