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

# 列结构配方步骤
<a name="recipe-actions.column-structure"></a>

使用这些列结构配方步骤可修改数据的列结构。

**Topics**
+ [BOOLEAN\$1OPERATION](recipe-actions.BOOLEAN_OPERATION.md)
+ [CASE\$1OPERATION](recipe-actions.CASE_OPERATION.md)
+ [FLAG\$1COLUMN\$1FROM\$1NULL](recipe-actions.FLAG_COLUMN_FROM_NULL.md)
+ [FLAG\$1COLUMN\$1FROM\$1PATTERN](recipe-actions.FLAG_COLUMN_FROM_PATTERN.md)
+ [MERGE](recipe-actions.MERGE.md)
+ [SPLIT\$1COLUMN\$1BETWEEN\$1DELIMITER](recipe-actions.SPLIT_COLUMN_BETWEEN_DELIMITER.md)
+ [SPLIT\$1COLUMN\$1BETWEEN\$1POSITIONS](recipe-actions.SPLIT_COLUMN_BETWEEN_POSITIONS.md)
+ [SPLIT\$1COLUMN\$1FROM\$1END](recipe-actions.SPLIT_COLUMN_FROM_END.md)
+ [SPLIT\$1COLUMN\$1FROM\$1START](recipe-actions.SPLIT_COLUMN_FROM_START.md)
+ [SPLIT\$1COLUMN\$1MULTIPLE\$1DELIMITER](recipe-actions.SPLIT_COLUMN_MULTIPLE_DELIMITER.md)
+ [SPLIT\$1COLUMN\$1SINGLE\$1DELIMITER](recipe-actions.SPLIT_COLUMN_SINGLE_DELIMITER.md)
+ [SPLIT\$1COLUMN\$1WITH\$1INTERVALS](recipe-actions.SPLIT_COLUMN_WITH_INTERVALS.md)

# BOOLEAN\$1OPERATION
<a name="recipe-actions.BOOLEAN_OPERATION"></a>

根据逻辑条件 IF 的结果创建新列。如果布尔表达式为 true，则返回 true 值；如果布尔表达式为 false，则返回 false 值，或者返回自定义值。

**参数**
+ `trueValueExpression`：满足条件时的结果。
+ `falseValueExpression`：未满足条件时的结果。
+ `valueExpression`：布尔值条件。
+ `withExpressions`：聚合结果的配置。
+ `targetColumn`：新创建的列的名称。

您可以在、和 ValueExpression 中使用常量值 trueValueExpression、列引用 falseValueExpression 和聚合结果。

**Example 示例：常量值**  
保持不变的值，例如数字或句子。  
  

```
{
  "RecipeStep": {
    "Action": {
      "Operation": "BOOLEAN_OPERATION",
      "Parameters": {
        "trueValueExpression": "It is true.",
        "falseValueExpression": "It is false.",
        "valueExpression": "`column.1` < 2000",
        "targetColumn": "result.column"
      }
    }
  }
}
```

**Example 示例：列引用**  
数据集中列的值。  
  

```
{
  "RecipeStep": {
    "Action": {
      "Operation": "BOOLEAN_OPERATION",
      "Parameters": {
        "trueValueExpression": "`column.2`",
        "falseValueExpression": "`column.3`",
        "valueExpression": "`column.1` < `column.4`",
        "targetColumn": "result.column"
      }
    }
  }
}
```

**Example 示例：聚合结果**  
聚合函数计算的值。聚合函数对列执行计算，并返回单个值。  
  

```
{
  "RecipeStep": {
    "Action": {
      "Operation": "BOOLEAN_OPERATION",
      "Parameters": {
        "trueValueExpression": "`:mincolumn.2`",
        "falseValueExpression": "`:maxcolumn.3`",
        "valueExpression": "`column.1` < `:avgcolumn.4`",
        "withExpressions": "[{\"name\":\"mincolumn.2\",\"value\":\"min(`column.2`)\",\"type\":\"aggregate\"},{\"name\":\"maxcolumn.3\",\"value\":\"max(`column.3`)\",\"type\":\"aggregate\"},{\"name\":\"avgcolumn.4\",\"value\":\"avg(`column.4`)\",\"type\":\"aggregate\"}]",
        "targetColumn": "result.column"
      }
    }
  }
}
```
用户需要通过转义将 JSON 转换为字符串。  
请注意，、和 ValueExpressi trueValueExpression on falseValueExpression 中的参数名称必须与 withExpressions 中的名称匹配。要使用某些列的聚合结果，您需要为它们创建参数并提供聚合函数。

**Example 示例：**  

```
{
  "RecipeStep": {
    "Action": {
      "Operation": "BOOLEAN_OPERATION",
      "Parameters": {
        "trueValueExpression": "It is true.",
        "falseValueExpression": "It is false.",
        "valueExpression": "`column.1` < 2000",
        "targetColumn": "result.column"
      }
    }
  }
}
```

**Example 示例：and/or**  
您可以使用 and 和 or 组合多个条件。  
  

```
{
  "RecipeStep": {
    "Action": {
      "Operation": "BOOLEAN_OPERATION",
      "Parameters": {
        "trueValueExpression": "It is true.",
        "falseValueExpression": "It is false.",
        "valueExpression": "`column.1` < 2000 and `column.2` >= `column.3",
        "targetColumn": "result.column"
      }
    }
  }
}
{
  "RecipeStep": {
    "Action": {
      "Operation": "BOOLEAN_OPERATION",
      "Parameters": {
        "trueValueExpression": "`column.4`",
        "falseValueExpression": "`column.5`",
        "valueExpression": "startsWith(`column1`, 'value1') or endsWith(`column2`, 'value2')",
        "targetColumn": "result.column"
      }
    }
  }
}
```

## 有效聚合函数
<a name="valid-aggregate-functions"></a>

下表显示了可以在布尔运算中使用的所有有效聚合函数。

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/databrew/latest/dg/recipe-actions.BOOLEAN_OPERATION.html)

## valueExpression 中的有效条件
<a name="valid-conditions-table"></a>

下表显示了支持的条件和您可以使用的值表达式。

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/databrew/latest/dg/recipe-actions.BOOLEAN_OPERATION.html)

# CASE\$1OPERATION
<a name="recipe-actions.CASE_OPERATION"></a>

根据逻辑条件 CASE 的结果创建新列。CASE 操作遍历 CASE 条件并在满足第一个条件时返回值。条件为 true 后，该操作将停止读取并返回结果。如果没有条件为 true，则返回默认值。

**参数**
+ `valueExpression`：条件。
+ `withExpressions`：聚合结果的配置。
+ `targetColumn`：新创建的列的名称。

**Example 示例**  
  

```
{
  "RecipeStep": {
    "Action": {
      "Operation": "CASE_OPERATION",
      "Parameters": {
        "valueExpression": "case when `column11` < `column.2` then 'result1' when `column2` < 'value2' then 'result2' else 'high' end",
        "targetColumn": "result.column"
      }
    }
  }
}
```

## 有效聚合函数
<a name="valid-aggregate-functions"></a>

下表显示了可以在 CASE 运算中使用的所有有效聚合函数。

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/databrew/latest/dg/recipe-actions.CASE_OPERATION.html)

## valueExpression 中的有效条件
<a name="valid-conditions-table"></a>

下表显示了支持的条件和您可以使用的值表达式。

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/databrew/latest/dg/recipe-actions.CASE_OPERATION.html)

# FLAG\$1COLUMN\$1FROM\$1NULL
<a name="recipe-actions.FLAG_COLUMN_FROM_NULL"></a>

根据现有列中是否存在 null 值来创建新列。

**参数**
+ `sourceColumn`：现有列的名称。
+ `targetColumn`：要创建的新列的名称。
+ `flagType`：值必须设置为 `Null values`。
+ `trueString`：在源中找到 null 值时新列的值。如果未指定值，则默认值为 `True`。
+ `falseString`：在源中找到非 null 值时新列的值。如果未指定值，则默认值为 `False`。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "FLAG_COLUMN_FROM_NULL",
        "Parameters": {
            "flagType": "Null values",
            "sourceColumn": "weight_kg",
            "targetColumn": "is_weight_kg_missing"
        }
    }
}
```

# FLAG\$1COLUMN\$1FROM\$1PATTERN
<a name="recipe-actions.FLAG_COLUMN_FROM_PATTERN"></a>

根据现有列中是否存在用户指定的模式来创建新列。

**参数**
+ `sourceColumn`：现有列的名称。
+ `targetColumn`：要创建的新列的名称。
+ `flagType`：值必须设置为 `Pattern`。
+ `pattern`：正则表达式，指示要评估的模式。
+ `trueString`：在源中找到 null 值时新列的值。如果未指定值，则默认值为 `True`。
+ `falseString`：在源中找到非 null 值时新列的值。如果未指定值，则默认值为 `False`。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "FLAG_COLUMN_FROM_PATTERN",
        "Parameters": {
            "falseString": "No",
            "flagType": "Pattern",
            "pattern": "N.*",
            "sourceColumn": "wind_direction",
            "targetColumn": "northerly",
            "trueString": "yes"
        }
    }
}
```

# MERGE
<a name="recipe-actions.MERGE"></a>

将两列或多列合并为一个新列。

**参数**
+ `sourceColumns`：JSON 编码字符串，表示要合并的一列或多列的列表。
+ `delimiter`：要在目标列中显示的值之间的可选分隔符。
+ `targetColumn`：要创建的合并列的名称。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "MERGE",
        "Parameters": {
            "delimiter": " ",
            "sourceColumns": "[\"first_name\",\"last_name\"]",
            "targetColumn": "Merged Column 1"
        }
    }
}
```

# SPLIT\$1COLUMN\$1BETWEEN\$1DELIMITER
<a name="recipe-actions.SPLIT_COLUMN_BETWEEN_DELIMITER"></a>

根据开头和结尾分隔符将一列拆分为三个新列。

**参数**
+ `sourceColumn`：现有列的名称。
+ `patternOption1`：JSON 编码字符串，表示一个或多个指示第一个分隔符的字符。
+ `patternOption2`：JSON 编码字符串，表示一个或多个指示第二个分隔符的字符。
+ `pattern`：拆分数据时用作分隔符的一个或多个字符。
+ `includeInSplit`：如果为 true，则在新列中包含该模式；否则，丢弃该模式。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "SPLIT_COLUMN_BETWEEN_DELIMITER",
        "Parameters": {
            "patternOption1": "{\"pattern\":\"H\",\"includeInSplit\":true}",
            "patternOption2": "{\"pattern\":\"M\",\"includeInSplit\":true}",
            "sourceColumn": "last_name"
        }
    }
}
```

# SPLIT\$1COLUMN\$1BETWEEN\$1POSITIONS
<a name="recipe-actions.SPLIT_COLUMN_BETWEEN_POSITIONS"></a>

根据您指定的偏移将一列拆分为三个新列。

**参数**
+ `sourceColumn`：现有列的名称。
+ `startPosition`：拆分开始的字符位置。
+ `endPosition`：拆分结束的角色位置。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "SPLIT_COLUMN_BETWEEN_POSITIONS",
        "Parameters": {
            "endPosition": "12",
            "sourceColumn": "last_name",
            "startPosition": "2"
        }
    }
}
```

# SPLIT\$1COLUMN\$1FROM\$1END
<a name="recipe-actions.SPLIT_COLUMN_FROM_END"></a>

按照与字符串末尾的偏移，将一列拆分为两个新列。

**参数**
+ `sourceColumn`：现有列的名称。
+ `position`：从字符串右端开始的字符位置，即要进行拆分的位置。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "SPLIT_COLUMN_FROM_END",
        "Parameters": {
            "position": "1",
            "sourceColumn": "nationality"
        }
    }
}
```

# SPLIT\$1COLUMN\$1FROM\$1START
<a name="recipe-actions.SPLIT_COLUMN_FROM_START"></a>

按照与字符串开头的偏移，将一列拆分为两个新列。

**参数**
+ `sourceColumn`：现有列的名称。
+ `position`：从字符串左端开始的字符位置，即要进行拆分的位置。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "SPLIT_COLUMN_FROM_START",
        "Parameters": {
            "position": "1",
            "sourceColumn": "first_name"
        }
    }
}
```

# SPLIT\$1COLUMN\$1MULTIPLE\$1DELIMITER
<a name="recipe-actions.SPLIT_COLUMN_MULTIPLE_DELIMITER"></a>

根据多个分隔符拆分一列。

**参数**
+ `sourceColumn`：现有列的名称。
+ `patternOptions`：JSON 编码字符串，表示确定拆分标准的一个或多个模式。
+ `pattern`：拆分数据时用作分隔符的一个或多个字符。
+ `limit`：要执行多少次拆分。最小值为 1，最大值为 20。
+ `includeInSplit`：如果为 true，则在新列中包含该模式；否则，丢弃该模式。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "SPLIT_COLUMN_MULTIPLE_DELIMITER",
        "Parameters": {
            "limit": "1",
            "patternOptions": "[{\"pattern\":\",\",\"includeInSplit\":true},{\"pattern\":\" \",\"includeInSplit\":true}]",
            "sourceColumn": "description"
        }
    }
}
```

# SPLIT\$1COLUMN\$1SINGLE\$1DELIMITER
<a name="recipe-actions.SPLIT_COLUMN_SINGLE_DELIMITER"></a>

根据特定分隔符将一列拆分为一个或多个新列。

**参数**
+ `sourceColumn`：现有列的名称。
+ `pattern`：拆分数据时用作分隔符的一个或多个字符。
+ `limit`：要执行多少次拆分。最小值为 1，最大值为 20。
+ `includeInSplit`：如果为 true，则在新列中包含该模式；否则，丢弃该模式。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "SPLIT_COLUMN_SINGLE_DELIMITER",
        "Parameters": {
            "includeInSplit": "true",
            "limit": "1",
            "pattern": "/",
            "sourceColumn": "info_url"
        }
    }
}
```

# SPLIT\$1COLUMN\$1WITH\$1INTERVALS
<a name="recipe-actions.SPLIT_COLUMN_WITH_INTERVALS"></a>

按照 *n* 个字符的间隔拆分一列，由您指定 *n*。

**参数**
+ `sourceColumn`：现有列的名称。
+ `startPosition`：拆分开始的字符位置。
+ `interval`：下次拆分之前要跳过的字符数。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "SPLIT_COLUMN_WITH_INTERVALS",
        "Parameters": {
            "interval": "4",
            "sourceColumn": "nationality",
            "startPosition": "1"
        }
    }
}
```