# 在 PySpark 中编写 AWS Glue ETL 脚本您可以在 GitHub 网站上的 [AWS Glue 示例存储库](https://github.com/awslabs/aws-glue-samples)中找到 AWS Glue 的 Python 代码示例和实用程序。 ## 将 Python 和 AWS Glue 一起使用 AWS Glue 支持使用 PySpark Python 方言的扩展来编写提取、转换和加载（ETL）任务脚本。本部分介绍如何在 ETL 脚本中以及如何通过 AWS Glue API 使用 Python。 + [进行设置以便将 Python 与 AWS Glue 一起使用](aws-glue-programming-python-setup.md) + [在 Python 中调用 AWS Glue API](aws-glue-programming-python-calling.md) + [将 Python 库与 AWS Glue 结合使用](aws-glue-programming-python-libraries.md) + [AWS Glue Python 代码示例](aws-glue-programming-python-samples.md) ## AWS Glue PySpark 扩展 AWS Glue 为 PySpark Python 方言创建了以下扩展。 + [使用 `getResolvedOptions` 访问参数](aws-glue-api-crawler-pyspark-extensions-get-resolved-options.md) + [PySpark 扩展类型](aws-glue-api-crawler-pyspark-extensions-types.md) + [DynamicFrame 类](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md) + [DynamicFrameCollection 类](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-collection.md) + [DynamicFrameWriter 类](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-writer.md) + [DynamicFrameReader 类](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader.md) + [GlueContext 类](aws-glue-api-crawler-pyspark-extensions-glue-context.md) ## AWS Glue PySpark 转换 AWS Glue 创建了以下转换类以在 PySpark ETL 操作中使用。 + [GlueTransform 基类](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md) + [ApplyMapping 类](aws-glue-api-crawler-pyspark-transforms-ApplyMapping.md) + [DropFields 类](aws-glue-api-crawler-pyspark-transforms-DropFields.md) + [DropNullFields 类](aws-glue-api-crawler-pyspark-transforms-DropNullFields.md) + [ErrorsAsDynamicFrame 类](aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame.md) + [FillMissingValues 类](aws-glue-api-crawler-pyspark-transforms-fillmissingvalues.md) + [Filter 类](aws-glue-api-crawler-pyspark-transforms-filter.md) + [FindIncrementalMatches 类](aws-glue-api-crawler-pyspark-transforms-findincrementalmatches.md) + [FindMatches 类](aws-glue-api-crawler-pyspark-transforms-findmatches.md) + [FlatMap 类](aws-glue-api-crawler-pyspark-transforms-flat-map.md) + [Join 类](aws-glue-api-crawler-pyspark-transforms-join.md) + [Map 类](aws-glue-api-crawler-pyspark-transforms-map.md) + [MapToCollection 类](aws-glue-api-crawler-pyspark-transforms-MapToCollection.md) + [mergeDynamicFrame](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-merge) + [Relationalize 类](aws-glue-api-crawler-pyspark-transforms-Relationalize.md) + [RenameField 类](aws-glue-api-crawler-pyspark-transforms-RenameField.md) + [ResolveChoice 类](aws-glue-api-crawler-pyspark-transforms-ResolveChoice.md) + [SelectFields 类](aws-glue-api-crawler-pyspark-transforms-SelectFields.md) + [SelectFromCollection 类](aws-glue-api-crawler-pyspark-transforms-SelectFromCollection.md) + [Spigot 类](aws-glue-api-crawler-pyspark-transforms-spigot.md) + [SplitFields 类](aws-glue-api-crawler-pyspark-transforms-SplitFields.md) + [SplitRows 类](aws-glue-api-crawler-pyspark-transforms-SplitRows.md) + [Unbox 类](aws-glue-api-crawler-pyspark-transforms-Unbox.md) + [UnnestFrame 类](aws-glue-api-crawler-pyspark-transforms-UnnestFrame.md) # 进行设置以便将 Python 与 AWS Glue 一起使用使用 Python 为 Spark 作业开发 ETL 脚本。ETL 任务支持的 Python 版本取决于任务的 AWS Glue 版本。有关 AWS Glue 版本的更多信息，请参阅 [Glue version job property](add-job.md#glue-version-table)。 **设置您的系统以便将 Python 与 AWS Glue 一起使用** 按照以下步骤安装 Python 并能够调用 AWS Glue API。 1. 如果您还没有安装 Python，请从 [Python.org 下载页面](https://www.python.org/downloads/)进行下载和安装。 1. 按照 [AWS CLI 文档](https://docs.aws.amazon.com/cli/latest/userguide/installing.html)中所述安装 AWS Command Line Interface（AWS CLI）。 AWS CLI 不是使用 Python 所直接必需的。但是，安装和配置它是使用账户凭证设置 AWS 并验证它们是否工作的方便方法。 1. 按照 [Boto3 快速入门](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html)所述安装 AWS SDK for Python（Boto 3）。 Boto 3 资源 API 尚不可用于 AWS Glue。目前，只有 Boto 3 客户端 API 可用。有关 Boto 3 的更多信息，请参阅 [AWS SDK for Python（Boto3）入门](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)。您可以在 GitHub 网站上的 [AWS Glue 示例存储库](https://github.com/awslabs/aws-glue-samples)中找到 AWS Glue 的 Python 代码示例和实用程序。 # 在 Python 中调用 AWS Glue API 请注意，Boto 3 资源 API 尚不可用于 AWS Glue。目前，只有 Boto 3 客户端 API 可用。 ## Python 中的 AWS Glue API 名称 Java 和其他编程语言中的 AWS Glue API 名称通常是 CamelCased。但是，当从 Python 调用时，这些通用名称将更改为小写，部分的某些名称用下划线字符隔开，使它们更“Pythonic”。在 [AWS Glue API](aws-glue-api.md) 参考文档中，这些 Pythonic 名称在通用 CamelCased 名称之后列在括号中。但是，尽管 AWS Glue API 名称自身转换为小写，其参数名称仍保持大写。请务必记住这一点，因为在调用 AWS Glue API 时会按名称传递参数，如下一节中所述。 ## 在 AWS Glue 中传递和访问 Python 参数在 Python 对 AWS Glue API 的调用中，最好按名称显式传递参数。例如： ``` job = glue.create_job(Name='sample', Role='Glue_DefaultRole', Command={'Name': 'glueetl', 'ScriptLocation': 's3://my_script_bucket/scripts/my_etl_script.py'}) ``` 了解 Python 创建您可以在 [作业结构](aws-glue-api-jobs-job.md#aws-glue-api-jobs-job-Job) 或 [JobRun 结构](aws-glue-api-jobs-runs.md#aws-glue-api-jobs-runs-JobRun) 中指定为 ETL 脚本参数的名称/值元组的字典是很有帮助的。然后，Boto 3 通过 REST API 调用，以 JSON 格式将其传递给 AWS Glue。这意味着，当您在脚本中访问这些参数时，不能依赖它们的顺序。例如，假设您在 Python Lambda 处理程序函数中启动 `JobRun`，并且您希望指定多个参数。您的代码看起来可能类似于： ``` from datetime import datetime, timedelta client = boto3.client('glue') def lambda_handler(event, context): last_hour_date_time = datetime.now() - timedelta(hours = 1) day_partition_value = last_hour_date_time.strftime("%Y-%m-%d") hour_partition_value = last_hour_date_time.strftime("%-H") response = client.start_job_run( JobName = 'my_test_Job', Arguments = { '--day_partition_key': 'partition_0', '--hour_partition_key': 'partition_1', '--day_partition_value': day_partition_value, '--hour_partition_value': hour_partition_value } ) ``` 要在 ETL 脚本中可靠地访问这些参数，请使用 AWS Glue 的 `getResolvedOptions` 函数，然后从生成的字典访问它们： ``` import sys from awsglue.utils import getResolvedOptions args = getResolvedOptions(sys.argv, ['JOB_NAME', 'day_partition_key', 'hour_partition_key', 'day_partition_value', 'hour_partition_value']) print "The day partition key is: ", args['day_partition_key'] print "and the day partition value is: ", args['day_partition_value'] ``` 如果您想传递属于嵌套 JSON 字符串的参数，以便在它传递给您的 AWS Glue ETL 任务时保存参数值，您必须在开始任务运行之前对参数字符串进行编码，然后在引用任务脚本之前对参数字符串进行解码。例如，考虑以下参数字符串： ``` glue_client.start_job_run(JobName = "gluejobname", Arguments={ "--my_curly_braces_string": '{"a": {"b": {"c": [{"d": {"e": 42}}]}}}' }) ``` 要正确传递此参数，您应将参数编码为 Base64 编码的字符串。 ``` import base64 ... sample_string='{"a": {"b": {"c": [{"d": {"e": 42}}]}}}' sample_string_bytes = sample_string.encode("ascii") base64_bytes = base64.b64encode(sample_string_bytes) base64_string = base64_bytes.decode("ascii") ... glue_client.start_job_run(JobName = "gluejobname", Arguments={ "--my_curly_braces_string": base64_bytes}) ... sample_string_bytes = base64.b64decode(base64_bytes) sample_string = sample_string_bytes.decode("ascii") print(f"Decoded string: {sample_string}") ... ``` ## 示例：创建并运行作业下面的示例显示如何使用 Python 调用 AWS Glue API 来创建和运行 ETL 作业。 **创建并运行作业** 1. 创建 AWS Glue 客户端的实例。 ``` import boto3 glue = boto3.client(service_name='glue', region_name='us-east-1', endpoint_url='https://glue.us-east-1.amazonaws.com') ``` 1. 创建作业。您必须使用 `glueetl` 作为名称的 ETL 命令，如以下代码所示： ``` myJob = glue.create_job(Name='sample', Role='Glue_DefaultRole', Command={'Name': 'glueetl', 'ScriptLocation': 's3://my_script_bucket/scripts/my_etl_script.py'}) ``` 1. 启动您在上一步中创建的作业的新运行： ``` myNewJobRun = glue.start_job_run(JobName=myJob['Name']) ``` 1. 获取作业状态： ``` status = glue.get_job_run(JobName=myJob['Name'], RunId=myNewJobRun['JobRunId']) ``` 1. 打印作业运行的当前状态： ``` print(status['JobRun']['JobRunState']) ``` # 将 Python 库与 AWS Glue 结合使用您可以安装其他 Python 模块和库，以便与 AWS Glue ETL 一起使用。对于 AWS Glue 2.0 及更高版本，AWS Glue 使用 Python Package Installer（pip3）安装 AWS Glue ETL 使用的其他模块。AWSGlue 提供了多种选项，来将其他 Python 模块引入 AWS Glue 作业环境。您可以使用 `--additional-python-modules` 参数，通过以下方式引入新模块：使用包含捆绑 Python wheels 的 zip 文件（也称为“zip of wheels”，适用于 AWS Glue 5.0 及更高版本）、单个 Python wheel 文件、需求文件（requirements.txt，适用于 AWS Glue 5.0 及更高版本）或以逗号分隔的 Python 模块列表。该参数也可用于更改 AWS Glue 环境中提供的 Python 模块的版本（更多详情请参阅 [AWS Glue 中已提供的 Python 模块](#glue-modules-provided)）。 **Topics** + [使用 pip 在 AWS Glue 2.0 或更高版本中安装其他 Python 模块](#addl-python-modules-support) + [包含具有 PySpark 原生功能的 Python 文件](#extra-py-files-support) + [使用视觉对象转换的编程脚本](#aws-glue-programming-with-cvt) + [压缩库以用于包含](#aws-glue-programming-python-libraries-zipping) + [加载 AWS Glue Studio 笔记本中的 Python 库](#aws-glue-programming-python-libraries-notebooks) + [通过 AWS Glue 0.9/1.0 在开发端点中加载 Python 库](#aws-glue-programming-python-libraries-dev-endpoint) + [在作业或作业运行中使用 Python 库](#aws-glue-programming-python-libraries-job) + [主动分析 Python 依赖项](#aws-glue-programming-analyzing-python-dependencies) + [AWS Glue 中已提供的 Python 模块](#glue-modules-provided) + [附录 A：创建 Zip of Wheels 构件](#glue-python-library-zip-of-wheels-appendix) + [附录 B：AWS Glue 环境详细信息](#glue-python-libraries-environment-details) ## 使用 pip 在 AWS Glue 2.0 或更高版本中安装其他 Python 模块 AWS Glue 使用 Python Package Installer（pip3）安装 AWS Glue ETL 使用的其他模块。您可以将 `--additional-python-modules` 参数与逗号分隔的 Python 模块列表结合使用，以添加新模块或更改现有模块的版本。您可以通过 zip of wheels 或独立的 wheel 构件安装构建的 wheel 构件:方法是将文件上传到 Amazon S3，然后在模块列表中包含 Amazon S3 对象的路径。有关设置作业参数的更多信息，请参阅[在 AWS Glue 作业中使用作业参数](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html)。您可以使用 `--python-modules-installer-option` 参数将其他选项传递给 pip3。例如，您可以传递 `--only-binary` 参数，强制 pip 仅安装由 `--additional-python-modules` 指定的包的预构建构件。有关更多示例，请参阅 [Building Python modules from a wheel for Spark ETL workloads using AWS Glue 2.0](https://aws.amazon.com/blogs/big-data/building-python-modules-from-a-wheel-for-spark-etl-workloads-using-aws-glue-2-0/)。 ### Python 依赖项管理的最佳实践对于生产工作负载，AWS Glue 建议将所有 Python 依赖项打包成一个 zip 构件中的 wheel 文件。此方法可提供： + **确定性执行**：精确控制安装哪些包版本 + **可靠性**：作业执行期间无需依赖任何外部包存储库 + **性能**：只需一次下载操作，无需多次网络调用 + **离线安装**：可在无法访问互联网的私有 VPC 环境中运行 #### 重要注意事项根据 [AWS 责任共担模式](https://aws.amazon.com/compliance/shared-responsibility-model/)，您负责管理其他 Python 模块、库及其依赖项。这包括： + **安全更新**：定期更新包以解决安全漏洞 + **版本兼容性**：确保包与您的 AWS Glue 版本兼容 + **测试**：验证打包的依赖项可在 Glue 环境中正常运行如果依赖项较少，则可以考虑改用单独的 wheel 文件。 ### （推荐）使用 Zip of Wheels 在 AWS Glue 5.0 或更高版本中安装其他 Python 库 AWS Glue 5.0 及更高版本支持将多个 wheel 文件打包成一个包含捆绑 Python wheels 的 zip 构件，以实现更可靠和更具确定性的依赖项管理。要使用此方法，请创建一个包含所有 wheel 依赖项及其传递依赖项的 zip 文件（采用 `.gluewheels.zip` 后缀），将其上传到 Amazon S3，然后使用 `--additional-python-modules` 参数引用该文件。确保将 `--no-index` 添加到 `--python-modules-installer-option` 作业参数。通过此配置，zip of wheels 文件本质上充当 pip 的本地索引，用于在运行时解析依赖项。这可消除在作业执行期间对 PyPI 等外部包存储库的依赖，从而为生产工作负载提供更高的稳定性和一致性。例如： ``` --additional-python-modules s3://amzn-s3-demo-bucket/path/to/zip-of-wheels-1.0.0.gluewheels.zip --python-modules-installer-option --no-index ``` 有关如何创建 zip of wheels 文件的说明，请参阅 [附录 A：创建 Zip of Wheels 构件](#glue-python-library-zip-of-wheels-appendix)。 ### 使用 Wheel 安装其他 Python 库 AWS Glue 支持使用存储在 Amazon S3 中的 wheel (.whl) 文件安装自定义 Python 包。要在 AWS Glue 作业中包含 wheel 文件，请在 `--additional-python-modules` 作业参数中提供以逗号分隔的 wheel 文件（存储在 s3 中）列表。例如： ``` --additional-python-modules s3://amzn-s3-demo-bucket/path/to/package-1.0.0-py3-none-any.whl,s3://your-bucket/path/to/another-package-2.1.0-cp311-cp311-linux_x86_64.whl ``` 当您需要使用自定义发行版，或具有针对相关操作系统预编译的原生依赖项的软件包时，也可以使用此方法。有关更多示例，请参阅 [Building Python modules from a wheel for Spark ETL workloads using AWS Glue 2.0](https://aws.amazon.com/blogs/big-data/building-python-modules-from-a-wheel-for-spark-etl-workloads-using-aws-glue-2-0/)。 ### 使用 requirements.txt 在 AWS Glue 5.0 或更高版本中安装其他 Python 库在 AWS Glue 5.0\$1 中，您可以提供事实标准 `requirements.txt` 来管理 Python 库依赖项。为此，请提供下面的两个作业参数： + 键：`--python-modules-installer-option` 值：`-r` + 键：`--additional-python-modules` 值：`s3://path_to_requirements.txt` AWS Glue 5.0 节点最初加载 `requirements.txt` 中指定的 python 库。下面是示例 requirements.txt： ``` awswrangler==3.9.1 elasticsearch==8.15.1 PyAthena==3.9.0 PyMySQL==1.1.1 PyYAML==6.0.2 pyodbc==5.2.0 pyorc==0.9.0 redshift-connector==2.1.3 scipy==1.14.1 scikit-learn==1.5.2 SQLAlchemy==2.0.36 ``` **重要** 请谨慎使用此选项，尤其是在生产工作负载中。在运行时从 PyPI 中拉取依赖项风险很大，因为您无法确定 pip 解析到哪个构件。使用未固定的库版本尤其危险，因为其会拉取最新版本的 Python 模块，从而引入重大更改或不兼容的 Python 模块。这可能由于 AWS Glue 作业环境中的 Python 安装失败而导致作业失败。虽然固定库版本可以提高稳定性，但 pip 解析仍不完全确定，因此可能会引发类似的问题。作为最佳实践，AWS Glue 建议使用冻结的构件，例如 zip of wheels 或单个 wheel 文件（更多详情请参阅[（推荐）使用 Zip of Wheels 在 AWS Glue 5.0 或更高版本中安装其他 Python 库](#glue-python-library-installing-zip-of-wheels)）。 **重要** 如果您没有固定传递依赖项的版本，则主依赖项可能会拉取不兼容的传递依赖项版本。作为最佳实践，应固定所有库版本以提高 AWS Glue 作业的一致性。更好的办法是，AWS Glue 建议将依赖项打包成 zip of wheels 文件，从而确保生产工作负载的最大一致性和可靠性。 ### 安装直接配置为逗号分隔列表的其他 Python 库 AWS Glue 允许通过传递 `--additional-python-modules` 参数，将以逗号分隔的 Python 模块列表作为值，从而更新或添加新的 Python 模块。例如，可使用以下键/值来更新/添加 scikit-learn 模块：`"--additional-python-modules", "scikit-learn==0.21.3"`。您可以通过两种方式直接配置 python 模块。 + **固定 Python 模块** `"--additional-python-modules", "scikit-learn==0.21.3,ephem==4.1.6"` + **未固定的 Python 模块：（不建议用于生产工作负载）** `"--additional-python-modules", "scikit-learn>==0.20.0,ephem>=4.0.0"` 或 `"--additional-python-modules", "scikit-learn,ephem"` **重要** 请谨慎使用此选项，尤其是在生产工作负载中。在运行时从 PyPI 中拉取依赖项风险很大，因为您无法确定 pip 解析到哪个构件。使用未固定的库版本尤其危险，因为其会拉取最新版本的 Python 模块，从而引入重大更改或不兼容的 Python 模块。这可能由于 AWS Glue 作业环境中的 Python 安装失败而导致作业失败。虽然固定库版本可以提高稳定性，但 pip 解析仍不完全确定，因此可能会引发类似的问题。作为最佳实践，AWS Glue 建议使用冻结的构件，例如 zip of wheels 或单个 wheel 文件（更多详情请参阅[（推荐）使用 Zip of Wheels 在 AWS Glue 5.0 或更高版本中安装其他 Python 库](#glue-python-library-installing-zip-of-wheels)）。 **重要** 如果您没有固定传递依赖项的版本，则主依赖项可能会拉取不兼容的传递依赖项版本。作为最佳实践，应固定所有库版本以提高 AWS Glue 作业的一致性。更好的办法是，AWS Glue 建议将依赖项打包成 zip of wheels 文件，从而确保生产工作负载的最大一致性和可靠性。 ## 包含具有 PySpark 原生功能的 Python 文件 AWS Glue 使用 PySpark 在 AWS Glue ETL 作业中包含 Python 文件。如果可用，您希望使用 `--additional-python-modules` 管理依赖项。您可以使用 `--extra-py-files` 作业参数以包含 Python 文件。依赖关系必须托管在 Amazon S3 中，参数值应为逗号分隔的 Amazon S3 路径列表，且不含空格。此功能的行为类似于您将在 Spark 中使用的 Python 依赖项管理。有关 Spark 中 Python 依赖项管理的更多信息，请参阅 Apache Spark 文档中的 [Using PySpark Native Features](https://spark.apache.org/docs/latest/api/python/tutorial/python_packaging.html#using-pyspark-native-features)（使用 PySpark 原生功能）页面。如果其他代码未打包，或您使用现有工具链迁移 Spark 程序以管理依赖项时，`--extra-py-files` 非常有用。为使依赖项工具可维护，您必须在提交之前捆绑依赖项。 ## 使用视觉对象转换的编程脚本使用 AWS Glue Studio 可视化界面创建 AWS Glue 作业时，您可以使用托管式的数据转换节点和自定义视觉对象转换来转换数据。有关托管式数据转换节点的更多信息，请参阅 [使用 AWS Glue 托管转换转换数据](edit-jobs-transforms.md)。有关自定义视觉对象转换的更多信息，请参阅 [使用自定义视觉转换来转换数据](custom-visual-transform.md)。只有当作业的**语言**设置为使用 Python 时，才能生成使用视觉对象转换的脚本。生成使用视觉对象转换的 AWS Glue 作业时，AWS Glue Studio 将使用作业配置中的 `--extra-py-files` 参数将这些转换包含在运行时环境中。有关任务参数的更多信息，请参阅 [在 AWS Glue 作业中使用作业参数](aws-glue-programming-etl-glue-arguments.md)。对生成的脚本或运行时环境进行更改时，需要保留此作业配置以确保脚本的成功运行。 ## 压缩库以用于包含除非库包含在单个 `.py` 文件中，否则它应打包到 `.zip` 存档中。包目录应该位于存档文件的根部，并且必须包含一个针对该包的 `__init__.py` 文件。然后，Python 将能够以正常方式导入包。如果您的库仅在一个 `.py` 文件中包含单个 Python 模块，您无需将其放入 `.zip` 文件。 ## 加载 AWS Glue Studio 笔记本中的 Python 库要在 AWS Glue Studio Notebook 中指定 Python 库，请参阅[安装其他 Python 模块](https://docs.aws.amazon.com/glue/latest/dg/manage-notebook-sessions.html#specify-default-modules)。 ## 通过 AWS Glue 0.9/1.0 在开发端点中加载 Python 库如果对不同的 ETL 脚本使用不同的库集，则可以为每个集设置单独的开发终端节点，也可以覆盖每次您切换脚本时开发终端节点加载的库 `.zip` 文件。在创建开发终端节点时，您可以使用控制台为其指定一个或多个库 .zip 文件。在分配名称和 IAM 角色后，请选择 **Script Libraries and job parameters (optional) (脚本库和任务参数（可选）)**，然后在 **Python library path (脚本库路径)** 框中输入库 `.zip` 文件的完整 Amazon S3 路径。例如： ``` s3://bucket/prefix/site-packages.zip ``` 如果需要，您可以指定文件的多个完整路径并使用逗号分隔，但不能有空格，如下所示： ``` s3://bucket/prefix/lib_A.zip,s3://bucket_B/prefix/lib_X.zip ``` 如果您更新这些 `.zip` 文件，则可以使用控制台将其重新导入到您的开发终端节点。导航到所涉开发人员终端节点，选中它旁边的框，然后从 **Action** 菜单中选择 **Update ETL libraries**。类似地，您可以使用 AWS Glue API 指定库文件。当您通过调用 [CreateDevEndpoint 操作（Python：create\$1dev\$1endpoint）](aws-glue-api-dev-endpoint.md#aws-glue-api-dev-endpoint-CreateDevEndpoint) 创建开发终端节点时，可以通过如下所示的调用在 `ExtraPythonLibsS3Path` 参数中指定库的一个或多个完整路径： ``` dep = glue.create_dev_endpoint( EndpointName="testDevEndpoint", RoleArn="arn:aws:iam::123456789012", SecurityGroupIds="sg-7f5ad1ff", SubnetId="subnet-c12fdba4", PublicKey="ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCtp04H/y...", NumberOfNodes=3, ExtraPythonLibsS3Path="s3://bucket/prefix/lib_A.zip,s3://bucket_B/prefix/lib_X.zip") ``` 当您更新一个开发终端节点时，还可以通过在调用 [UpdateDevEndpoint (update\$1dev\$1endpoint)](aws-glue-api-dev-endpoint.md#aws-glue-api-dev-endpoint-UpdateDevEndpoint) 时使用 [DevEndpointCustomLibraries](aws-glue-api-dev-endpoint.md#aws-glue-api-dev-endpoint-DevEndpointCustomLibraries) 对象并将 `UpdateEtlLibraries ` 参数设置为 `True` 来更新它所加载的库。 ## 在作业或作业运行中使用 Python 库当您在控制台上创建新任务时，可以通过选择 **Script Libraries and job parameters (optional) (脚本库和任务参数 (可选))** 并输入完整的 Amazon S3 库路径来指定一个或多个库 .zip 格式文件（方法与创建开发终端节点时相同）： ``` s3://bucket/prefix/lib_A.zip,s3://bucket_B/prefix/lib_X.zip ``` 如果您正在调用 [CreateJob (create\$1job)](aws-glue-api-jobs-job.md#aws-glue-api-jobs-job-CreateJob)，则可以使用 `--extra-py-files` 默认参数指定默认库的一个或多个完整路径，如下所示： ``` job = glue.create_job(Name='sampleJob', Role='Glue_DefaultRole', Command={'Name': 'glueetl', 'ScriptLocation': 's3://my_script_bucket/scripts/my_etl_script.py'}, DefaultArguments={'--extra-py-files': 's3://bucket/prefix/lib_A.zip,s3://bucket_B/prefix/lib_X.zip'}) ``` 然后，当您启动作业运行时，可以使用其他设置覆盖默认库设置： ``` runId = glue.start_job_run(JobName='sampleJob', Arguments={'--extra-py-files': 's3://bucket/prefix/lib_B.zip'}) ``` ## 主动分析 Python 依赖项要在部署到 AWS Glue 之前主动识别潜在的依赖项问题，您可以使用依赖项分析工具，根据目标 AWS Glue 环境验证您的 Python 包。 AWS 提供了专为 AWS Glue 环境设计的开源 Python 依赖项分析器工具。该工具可从 AWS Glue 示例存储库中获取并在本地使用，从而在部署之前验证依赖项。此分析有助于确保依赖项遵循推荐的做法，即固定所有库版本以确保生产部署的一致性。有关更多详细信息，请参阅该工具的 [README](https://github.com/aws-samples/aws-glue-samples/tree/master/utilities/glue_python_dependency_analyzer) 文件。 ### 使用 AWS Glue 依赖项分析器 AWS Glue Python 依赖项分析器通过使用与目标 AWS Glue 环境匹配的特定平台约束来模拟 pip 安装，从而帮助识别未固定的依赖项和版本冲突。 ``` # Analyze a single Glue job python glue_dependency_analyzer.py -j my-glue-job # Analyze multiple jobs with specific AWS configuration python glue_dependency_analyzer.py -j job1 -j job2 --aws-profile production --aws-region us-west-2 ``` 该工具将标记以下问题： + 未固定的依赖项，这可能会导致在作业运行中安装不同的版本 + 软件包之间的版本冲突 + 不支持目标 AWS Glue 环境的依赖项 ## 使用 Amazon Q 开发者版分析和修复因 Python 依赖项导致的作业失败问题 Amazon Q 开发者版是一款由生成式人工智能（AI）提供支持的对话式助手，可为您理解、构建、扩展和操作 AWS 应用程序提供帮助。您可以按照 Amazon Q 入门指南中的说明进行下载该工具。 Amazon Q 开发者版可用于分析和修复因 Python 依赖项导致的作业失败问题。我们建议使用以下提示，并将作业的占位符替换为 Glue 作业的名称。 ``` I have an AWS Glue job named that has failed due to Python module installation conflicts. Please assist in diagnosing and resolving this issue using the following systematic approach. Proceed once sufficient information is available. Objective: Implement a fix that addresses the root cause module while minimizing disruption to the existing working environment. Step 1: Root Cause Analysis • Retrieve the most recent failed job run ID for the specified Glue job • Extract error logs from CloudWatch Logs using the job run ID as a log stream prefix • Analyze the logs to identify: • The recently added or modified Python module that triggered the dependency conflict • The specific dependency chain causing the installation failure • Version compatibility conflicts between required and existing modules Step 2: Baseline Configuration Identification • Locate the last successful job run ID prior to the dependency failure • Document the Python module versions that were functioning correctly in that baseline run • Establish the compatible version constraints for conflicting dependencies Step 3: Targeted Resolution Implementation • Apply pinning by updating the job's additional_python_modules parameter • Pin only the root cause module and its directly conflicting dependencies to compatible versions, and do not remove python modules unless necessary • Preserve flexibility for non-conflicting modules by avoiding unnecessary version constraints • Deploy the configuration changes with minimal changes to the existing configuration and execute a validation test run. Do not change the Glue versions. Implementation Example: Scenario: Recently added pandas==2.0.0 to additional_python_modules Error: numpy version conflict (pandas 2.0.0 requires numpy>=1.21, but existing job code requires numpy<1.20) Resolution: Update additional_python_modules to "pandas==1.5.3,numpy==1.19.5" Rationale: Use pandas 1.5.3 (compatible with numpy 1.19.5) and pin numpy to last known working version Expected Outcome: Restore job functionality with minimal configuration changes while maintaining system stability. ``` 该提示符将指示 Q 执行以下操作： 1. 获取最新的失败作业运行 ID 1. 查找关联的日志和详细信息 1. 查找成功的作业运行以检测任何发生更改的 Python 软件包 1. 执行配置修复并启动新的测试运行 ## AWS Glue 中已提供的 Python 模块要更改这些已提供模块的版本，请使用 `--additional-python-modules` 作业参数提供新版本。 ------ #### [ AWS Glue version 5.1 ] AWS Glue 5.1 版包括以下开箱即用的 Python 模块： + aiobotocore==2.25.1 + aiohappyeyeballs==2.6.1 + aiohttp==3.13.2 + aioitertools==0.12.0 + aiosignal==1.4.0 + appdirs==1.4.4 + attrs==25.4.0 + boto3==1.40.61 + botocore==1.40.61 + certifi==2025.10.5 + charset-normalizer==3.4.4 + choreographer==1.2.0 + contourpy==1.3.3 + cycler==0.12.1 + distlib==0.4.0 + filelock==3.20.0 + fonttools==4.60.1 + frozenlist==1.8.0 + fsspec==2025.10.0 + idna==3.11 + iniconfig==2.3.0 + jmespath==1.0.1 + kaleido==1.2.0 + kiwisolver==1.4.9 + logistro==2.0.1 + matplotlib==3.10.7 + multidict==6.7.0 + narwhals==2.10.2 + numpy==2.3.4 + orjson==3.11.4 + packaging==25.0 + pandas==2.3.3 + pillow==12.0.0 + pip==24.0 + platformdirs==4.5.0 + plotly==6.4.0 + pluggy==1.6.0 + propcache==0.4.1 + pyarrow==22.0.0 + Pygments==2.19.2 + pyparsing==3.2.5 + pytest-timeout==2.4.0 + pytest==8.4.2 + python-dateutil==2.9.0.post0 + pytz==2025.2 + requests==2.32.5 + s3fs==2025.10.0 + s3transfer==0.14.0 + seaborn==0.13.2 + setuptools==79.0.1 + simplejson==3.20.2 + six==1.17.0 + tenacity==9.1.2 + typing\$1extensions==4.15.0 + tzdata==2025.2 + urllib3==2.5.0 + uv==0.9.7 + virtualenv==20.35.4 + wrapt==1.17.3 + yarl==1.22.0 ------ #### [ AWS Glue version 5.0 ] AWS Glue 5.0 版包括以下开箱即用的 Python 模块： + aiobotocore==2.13.1 + aiohappyeyeballs==2.3.5 + aiohttp==3.10.1 + aioitertools==0.11.0 + aiosignal==1.3.1 + appdirs==1.4.4 + attrs==24.2.0 + boto3==1.34.131 + botocore==1.34.131 + certifi==2024.7.4 + charset-normalizer==3.3.2 + contourpy==1.2.1 + cycler==0.12.1 + fonttools==4.53.1 + frozenlist==1.4.1 + fsspec==2024.6.1 + idna==2.10 + jmespath==0.10.0 + kaleido==0.2.1 + kiwisolver==1.4.5 + matplotlib==3.9.0 + multidict==6.0.5 + numpy==1.26.4 + packaging==24.1 + pandas==2.2.2 + pillow==10.4.0 + pip==23.0.1 + plotly==5.23.0 + pyarrow==17.0.0 + pyparsing==3.1.2 + python-dateutil==2.9.0.post0 + pytz==2024.1 + requests==2.32.2 + s3fs==2024.6.1 + s3transfer==0.10.2 + seaborn==0.13.2 + setuptools==59.6.0 + six==1.16.0 + tenacity==9.0.0 + tzdata==2024.1 + urllib3==1.25.10 + virtualenv==20.4.0 + wrapt==1.16.0 + yarl==1.9.4 ------ #### [ AWS Glue version 4.0 ] AWS Glue 4.0 版包括以下开箱即用的 Python 模块： + aiobotocore==2.4.1 + aiohttp==3.8.3 + aioitertools==0.11.0 + aiosignal==1.3.1 + async-timeout==4.0.2 + asynctest==0.13.0 + attrs==22.2.0 + avro-python3==1.10.2 + boto3==1.24.70 + botocore==1.27.59 + certifi==2021.5.30 + chardet==3.0.4 + charset-normalizer==2.1.1 + click==8.1.3 + cycler==0.10.0 + Cython==0.29.32 + fsspec==2021.8.1 + idna==2.10 + importlib-metadata==5.0.0 + jmespath==0.10.0 + joblib==1.0.1 + kaleido==0.2.1 + kiwisolver==1.4.4 + matplotlib==3.4.3 + mpmath==1.2.1 + multidict==6.0.4 + nltk==3.7 + numpy==1.23.5 + packaging==23.0 + pandas==1.5.1 + patsy==0.5.1 + pillow==9.4.0 + pip==23.0.1 + plotly==5.16.0 + pmdarima==2.0.1 + ptvsd==4.3.2 + pyarrow==10.0.0 + pydevd==2.5.0 + pyhocon==0.3.58 + pymysql==1.0.2 + pyparsing==2.4.7 + python-dateutil==2.8.2 + pytz==2021.1 + PyYAML==6.0.1 + regex==2022.10.31 + requests==2.23.0 + s3fs==2022.11.0 + s3transfer==0.6.0 + scikit-learn==1.1.3 + scipy==1.9.3 + setuptools==49.1.3 + six==1.16.0 + statsmodels==0.13.5 + subprocess32==3.5.4 + sympy==1.8 + tbats==1.1.0 + threadpoolctl==3.1.0 + tqdm==4.64.1 + typing\$1extensions==4.4.0 + urllib3==1.25.11 + wheel==0.37.0 + wrapt==1.14.1 + yarl==1.8.2 + zipp==3.10.0 ------ #### [ AWS Glue version 3.0 ] AWS Glue 3.0 版包括以下开箱即用的 Python 模块： + aiobotocore==1.4.2 + aiohttp==3.8.3 + aioitertools==0.11.0 + aiosignal==1.3.1 + async-timeout==4.0.2 + asynctest==0.13.0 + attrs==22.2.0 + avro-python3==1.10.2 + boto3==1.18.50 + botocore==1.21.50 + certifi==2021.5.30 + chardet==3.0.4 + charset-normalizer==2.1.1 + click==8.1.3 + cycler==0.10.0 + Cython==0.29.4 + docutils==0.17.1 + enum34==1.1.10 + frozenlist==1.3.3 + fsspec==2021.8.1 + idna==2.10 + importlib-metadata==6.0.0 + jmespath==0.10.0 + joblib==1.0.1 + kiwisolver==1.3.2 + matplotlib==3.4.3 + mpmath==1.2.1 + multidict==6.0.4 + nltk==3.6.3 + numpy==1.19.5 + packaging==23.0 + pandas==1.3.2 + patsy==0.5.1 + pillow==9.4.0 + pip==23.0 + pmdarima==1.8.2 + ptvsd==4.3.2 + pyarrow==5.0.0 + pydevd==2.5.0 + pyhocon==0.3.58 + pymysql==1.0.2 + pyparsing==2.4.7 + python-dateutil==2.8.2 + pytz==2021.1 + PyYAML==5.4.1 + regex==2022.10.31 + requests==2.23.0 + s3fs==2021.8.1 + s3transfer==0.5.0 + scikit-learn==0.24.2 + scipy==1.7.1 + six==1.16.0 + spark==1.0 + statsmodels==0.12.2 + subprocess32==3.5.4 + sympy==1.8 + tbats==1.1.0 + threadpoolctl==3.1.0 + tqdm==4.64.1 + typing\$1extensions==4.4.0 + urllib3==1.25.11 + wheel==0.37.0 + wrapt==1.14.1 + yarl==1.8.2 + zipp==3.12.0 ------ #### [ AWS Glue version 2.0 ] AWS Glue 2.0 版包括以下开箱即用的 Python 模块： + avro-python3==1.10.0 + awscli==1.27.60 + boto3==1.12.4 + botocore==1.15.4 + certifi==2019.11.28 + chardet==3.0.4 + click==8.1.3 + colorama==0.4.4 + cycler==0.10.0 + Cython==0.29.15 + docutils==0.15.2 + enum34==1.1.9 + fsspec==0.6.2 + idna==2.9 + importlib-metadata==6.0.0 + jmespath==0.9.4 + joblib==0.14.1 + kiwisolver==1.1.0 + matplotlib==3.1.3 + mpmath==1.1.0 + nltk==3.5 + numpy==1.18.1 + pandas==1.0.1 + patsy==0.5.1 + pmdarima==1.5.3 + ptvsd==4.3.2 + pyarrow==0.16.0 + pyasn1==0.4.8 + pydevd==1.9.0 + pyhocon==0.3.54 + PyMySQL==0.9.3 + pyparsing==2.4.6 + python-dateutil==2.8.1 + pytz==2019.3 + PyYAML==5.3.1 + regex==2022.10.31 + requests==2.23.0 + rsa==4.7.2 + s3fs==0.4.0 + s3transfer==0.3.3 + scikit-learn==0.22.1 + scipy==1.4.1 + setuptools==45.2.0 + six==1.14.0 + spark==1.0 + statsmodels==0.11.1 + subprocess32==3.5.4 + sympy==1.5.1 + tbats==1.0.9 + tqdm==4.64.1 + typing-extensions==4.4.0 + urllib3==1.25.8 + wheel==0.35.1 + zipp==3.12.0 ------ ## 附录 A：创建 Zip of Wheels 构件我们通过示例演示如何创建 zip of wheels 构件。所示的示例将 `cryptography` 和 `scipy` 包下载到 zip of wheels 构件中，然后将 zip of wheels 复制到 Amazon S3 位置。 1. 您必须在与 Glue 环境类似的 Amazon Linux 环境中运行命令才能创建 zip of wheels。请参阅[附录 B：AWS Glue 环境详细信息](#glue-python-libraries-environment-details)。Glue 5.1 使用 AL2023 及 Python 版本 3.11。创建将构建此环境的 Dockerfile： ``` FROM --platform=linux/amd64 public.ecr.aws/amazonlinux/amazonlinux:2023-minimal # Install Python 3.11, pip, and zip utility RUN dnf install -y python3.11 pip zip && \ dnf clean all WORKDIR /build ``` 1. 创建 requirements.txt 文件 ``` cryptography scipy ``` 1. 构建并启动 Docker 容器 ``` # Build docker image docker build --platform linux/amd64 -t glue-wheel-builder . # Spin up container docker run --platform linux/amd64 -v $(pwd)/requirements.txt:/input/requirements.txt:ro -v $(pwd):/output -it glue-wheel-builder bash ``` 1. 在 Docker 映像中运行以下命令 ``` # Create a directory for the wheels mkdir wheels # Copy requirements.txt into wheels directory cp /input/requirements.txt wheels/ # Download the wheels with the correct platform and Python version pip3 download \ -r wheels/requirements.txt \ --dest wheels/ \ --platform manylinux2014_x86_64 \ --python-version 311 \ --only-binary=:all: # Package the wheels into a zip archive with the .gluewheels.zip suffix zip -r mylibraries-1.0.0.gluewheels.zip wheels/ # Copy zip to output cp mylibraries-1.0.0.gluewheels.zip /output/ # Exit the container exit ``` 1. 将 zip of wheels 上传到 Amazon S3 位置 ``` aws s3 cp mylibraries-1.0.0.gluewheels.zip s3://amzn-s3-demo-bucket/example-prefix/ ``` 1. 可选的清理 ``` rm mylibraries-1.0.0.gluewheels.zip rm Dockerfile rm requirements.txt ``` 1. 使用以下作业参数运行 Glue 作业： ``` --additional-python-modules s3://amzn-s3-demo-bucket/example-prefix/mylibraries-1.0.0.gluewheels.zip --python-modules-installer-option --no-index ``` ## 附录 B：AWS Glue 环境详细信息 **Glue 版本兼容性和安装方法** | AWS Glue 版本 | Python 版本 | 基础映像 | glibc 版本 | 兼容的平台标签 | | --- | --- | --- | --- | --- | | 5.1 | 3.11 | [Amazon Linux 2023 (AL2023)](https://aws.amazon.com/linux/amazon-linux-2023/) | 2.34 | manylinux\$12\$134\$1x86\$164 manylinux\$12\$128\$1x86\$164 manylinux2014\$1x86\$164 | | 5.0 | 3.11 | [Amazon Linux 2023 (AL2023)](https://aws.amazon.com/linux/amazon-linux-2023/) | 2.34 | manylinux\$12\$134\$1x86\$164 manylinux\$12\$128\$1x86\$164 manylinux2014\$1x86\$164 | | 4.0 | 3.10 | [Amazon Linux 2 (AL2)](https://aws.amazon.com/amazon-linux-2/) | 2.26 | manylinux2014\$1x86\$164 | | 3.0 | 3.7 | [Amazon Linux 2 (AL2)](https://aws.amazon.com/amazon-linux-2/) | 2.26 | manylinux2014\$1x86\$164 | | 2.0 | 3.7 | [Amazon Linux AMI (AL1)](https://aws.amazon.com/amazon-linux-ami/) | 2.17 | manylinux2014\$1x86\$164 | 根据 [AWS 责任共担模式](https://aws.amazon.com/compliance/shared-responsibility-model/)，您负责管理您在 AWS Glue ETL 作业中使用的其他 Python 模块、库及其依赖项。这包括应用更新和安全补丁。 AWS Glue 不支持在作业环境中编译原生代码。但是，AWS Glue 作业会在 Amazon 托管的 Linux 环境中运行。您可通过 Python wheel 文件，以编译后的形式提供原生依赖项。有关 AWS Glue 版本兼容性的详细信息，请参阅上表。 **重要** 使用不兼容的依赖项可能会导致运行时问题，尤其是对于具有原生扩展的库，因为这些库必须与目标环境的架构和系统库相匹配。每个 AWS Glue 版本都在特定的 Python 版本上运行，其中包含预装的库和系统配置。 # AWS Glue Python 代码示例 + [代码示例：对数据进行联接和关系化](aws-glue-programming-python-samples-legislators.md) + [代码示例：使用 ResolveChoice、Lambda 和 ApplyMapping 进行数据准备](aws-glue-programming-python-samples-medicaid.md) # 代码示例：对数据进行联接和关系化本示例使用从 [http://everypolitician.org/](http://everypolitician.org/) 下载到 Amazon Simple Storage Service（Amazon S3）中的 `sample-dataset` 存储桶的数据集：`s3://awsglue-datasets/examples/us-legislators/all`。该数据集包含有关美国议员及其在美国众议院和参议院中占有的席位的数据（JSON 格式），并且已针对本教程进行了轻微修改且在公共 Amazon S3 存储桶中提供。您可以在 GitHub 网站上 [AWS Glue 示例存储库](https://github.com/awslabs/aws-glue-samples)的 `join_and_relationalize.py` 文件中找到本示例的源代码。利用此数据，本教程将介绍如何执行以下操作： + 使用 AWS Glue 爬网程序对存储在公有 Amazon S3 存储桶中的对象进行分类并将其架构保存到 AWS Glue Data Catalog。 + 检查生成自爬网的表元数据和架构。 + 编写 Python 提取、转移和加载（ETL）脚本，该脚本使用数据目录中的元数据执行以下操作： + 将不同源文件中的数据加入到单个数据表中 (即，使数据非规范化)。 + 按议员类型筛选已加入到单独的表中的表。 + 将生成的数据写入单独的 Apache Parquet 文件以供日后分析。在 AWS 上运行时，调试 Python 或 PySpark 脚本的首选方法是[在 AWS Glue Studio 上使用笔记本](https://docs.aws.amazon.com/glue/latest/ug/notebooks-chapter.html)。 ## 步骤 1：爬取 Amazon S3 存储桶中的数据 1. 登录 AWS 管理控制台并打开位于 [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/) 的 AWS Glue 控制台。 1. 按照 [配置爬网程序](define-crawler.md) 中的步骤操作，创建可将 `s3://awsglue-datasets/examples/us-legislators/all` 数据集网络爬取到 AWS Glue Data Catalog 中名为 `legislators` 的数据库的新爬网程序。示例数据已位于此公共 Amazon S3 存储桶中。 1. 运行新爬网程序，然后检查 `legislators` 数据库。该爬网程序将创建以下元数据表： + `persons_json` + `memberships_json` + `organizations_json` + `events_json` + `areas_json` + `countries_r_json` 这是一个包含议员及其历史记录的半规范化表集合。 ## 步骤 2：向开发终端节点笔记本中添加样板文件脚本将以下样板文件脚本粘贴到开发终端节点笔记本中以导入所需的 AWS Glue 库，然后设置单个 `GlueContext`： ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job glueContext = GlueContext(SparkContext.getOrCreate()) ``` ## 步骤 3：检查数据目录中数据的架构接下来，您可以轻松地从 AWS Glue Data Catalog 检查 DynamicFrame，并检查数据的架构。例如，要查看 `persons_json` 表的架构，请在您的笔记本中添加以下内容： ``` persons = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="persons_json") print "Count: ", persons.count() persons.printSchema() ``` 下面是来自打印调用的输出： ``` Count: 1961 root |-- family_name: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- gender: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- note: string | | |-- name: string | | |-- lang: string |-- sort_name: string |-- images: array | |-- element: struct | | |-- url: string |-- given_name: string |-- birth_date: string |-- id: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- death_date: string ``` 表中的每个人都是某个美国国会机构的成员。要查看 `memberships_json` 表的架构，请键入以下内容： ``` memberships = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="memberships_json") print "Count: ", memberships.count() memberships.printSchema() ``` 您可以在一个 (扩展) 代码行中执行所有这些操作： ``` Count: 10439 root |-- area_id: string |-- on_behalf_of_id: string |-- organization_id: string |-- role: string |-- person_id: string |-- legislative_period_id: string |-- start_date: string |-- end_date: string ``` `organizations` 是美国国会的党派和两大议院，即参议院和众议院。要查看 `organizations_json` 表的架构，请键入以下内容： ``` orgs = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="organizations_json") print "Count: ", orgs.count() orgs.printSchema() ``` 您可以在一个 (扩展) 代码行中执行所有这些操作： ``` Count: 13 root |-- classification: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- id: string |-- name: string |-- seats: int |-- type: string ``` ## 步骤 4：筛选数据接下来，仅保留您需要的字段，然后将 `id` 重命名为 `org_id`。该数据集足够小，方便您完整查看。 `toDF()` 将 `DynamicFrame` 转换为 Apache Spark `DataFrame`，因此您可以应用已存在于 Apache Spark SQL 中的转换： ``` orgs = orgs.drop_fields(['other_names', 'identifiers']).rename_field( 'id', 'org_id').rename_field( 'name', 'org_name') orgs.toDF().show() ``` 下面显示了输出： ``` +--------------+--------------------+--------------------+--------------------+-----+-----------+--------------------+ |classification| org_id| org_name| links|seats| type| image| +--------------+--------------------+--------------------+--------------------+-----+-----------+--------------------+ | party| party/al| AL| null| null| null| null| | party| party/democrat| Democrat|[[website,http://...| null| null|https://upload.wi...| | party|party/democrat-li...| Democrat-Liberal|[[website,http://...| null| null| null| | legislature|d56acebe-8fdc-47b...|House of Represen...| null| 435|lower house| null| | party| party/independent| Independent| null| null| null| null| | party|party/new_progres...| New Progressive|[[website,http://...| null| null|https://upload.wi...| | party|party/popular_dem...| Popular Democrat|[[website,http://...| null| null| null| | party| party/republican| Republican|[[website,http://...| null| null|https://upload.wi...| | party|party/republican-...|Republican-Conser...|[[website,http://...| null| null| null| | party| party/democrat| Democrat|[[website,http://...| null| null|https://upload.wi...| | party| party/independent| Independent| null| null| null| null| | party| party/republican| Republican|[[website,http://...| null| null|https://upload.wi...| | legislature|8fa6c3d2-71dc-478...| Senate| null| 100|upper house| null| +--------------+--------------------+--------------------+--------------------+-----+-----------+--------------------+ ``` 键入以下内容以查看显示在 `memberships` 中的 `organizations`： ``` memberships.select_fields(['organization_id']).toDF().distinct().show() ``` 下面显示了输出： ``` +--------------------+ | organization_id| +--------------------+ |d56acebe-8fdc-47b...| |8fa6c3d2-71dc-478...| +--------------------+ ``` ## 步骤 5：整合内容现在，使用 AWS Glue 联接这些关系表并创建一个包含议员 `memberships` 及其对应的 `organizations` 的完整历史记录表。 1. 首先，联接 `id` 和 `person_id` 上的 `persons` 和 `memberships`。 1. 接下来，将结果与 `org_id` 和 `organization_id` 上的 `orgs` 联接。 1. 然后，删除多余的字段 `person_id` 和 `org_id`。您可以在一个 (扩展) 代码行中执行所有这些操作： ``` l_history = Join.apply(orgs, Join.apply(persons, memberships, 'id', 'person_id'), 'org_id', 'organization_id').drop_fields(['person_id', 'org_id']) print "Count: ", l_history.count() l_history.printSchema() ``` 您可以在一个 (扩展) 代码行中执行所有这些操作： ``` Count: 10439 root |-- role: string |-- seats: int |-- org_name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- type: string |-- sort_name: string |-- area_id: string |-- images: array | |-- element: struct | | |-- url: string |-- on_behalf_of_id: string |-- other_names: array | |-- element: struct | | |-- note: string | | |-- name: string | | |-- lang: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- name: string |-- birth_date: string |-- organization_id: string |-- gender: string |-- classification: string |-- death_date: string |-- legislative_period_id: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- image: string |-- given_name: string |-- family_name: string |-- id: string |-- start_date: string |-- end_date: string ``` 您现在有了可用于分析的最终表。您可以采用紧凑且高效的格式写入该表以供分析（即 Parquet），该格式可让您在 AWS Glue、Amazon Athena 或 Amazon Redshift Spectrum 中运行 SQL。以下调用将跨多个文件写入该表以在日后执行分析时支持快速并行读取： ``` glueContext.write_dynamic_frame.from_options(frame = l_history, connection_type = "s3", connection_options = {"path": "s3://glue-sample-target/output-dir/legislator_history"}, format = "parquet") ``` 要将所有历史记录数据放入单个文件，您必须将其转换为数据帧，为其重新分区然后写入它： ``` s_history = l_history.toDF().repartition(1) s_history.write.parquet('s3://glue-sample-target/output-dir/legislator_single') ``` 或者，如果您希望按参议院和众议院分隔该数据： ``` l_history.toDF().write.parquet('s3://glue-sample-target/output-dir/legislator_part', partitionBy=['org_name']) ``` ## 步骤 6：转换关系数据库的数据利用 AWS Glue，您可以轻松将数据写入到关系数据库（如 Amazon Redshift），甚至对半结构化数据也是如此。它提供了一种转换 `relationalize`，这将展平 `DynamicFrames`，无论帧中的对象的复杂度可能如何。使用本示例中的 `l_history` `DynamicFrame`，传入根表的名称 (`hist_root`) 和 `relationalize` 的临时工作路径。这将返回 `DynamicFrameCollection`。您随后可以列出该集合中 `DynamicFrames` 的名称： ``` dfc = l_history.relationalize("hist_root", "s3://glue-sample-target/temp-dir/") dfc.keys() ``` 以下是 `keys` 调用的输出： ``` [u'hist_root', u'hist_root_contact_details', u'hist_root_links', u'hist_root_other_names', u'hist_root_images', u'hist_root_identifiers'] ``` `Relationalize` 将该历史记录表拆分为 6 个新表：1 个包含 `DynamicFrame` 中每个对象的记录的根表以及 5 个用于数组的辅助表。关系数据库中的数组处理通常不够理想，尤其是在这些数组变大时。将这些数组分成不同的表会使查询进展得快得多。接下来，通过检查 `contact_details` 来查看分隔： ``` l_history.select_fields('contact_details').printSchema() dfc.select('hist_root_contact_details').toDF().where("id = 10 or id = 75").orderBy(['id','index']).show() ``` 以下是 `show` 调用的输出： ``` root |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 10| 0| fax| | | 10| 1| | 202-225-1314| | 10| 2| phone| | | 10| 3| | 202-225-3772| | 10| 4| twitter| | | 10| 5| | MikeRossUpdates| | 75| 0| fax| | | 75| 1| | 202-225-7856| | 75| 2| phone| | | 75| 3| | 202-225-2711| | 75| 4| twitter| | | 75| 5| | SenCapito| +---+-----+------------------------+-------------------------+ ``` `contact_details` 字段是原始 `DynamicFrame` 中的一个结构数组。这些数组中的每个元素都是辅助表中的单独的行，通过 `index` 编制索引。此处的 `id` 是具有键 `contact_details` 的 `hist_root` 表的外键： ``` dfc.select('hist_root').toDF().where( "contact_details = 10 or contact_details = 75").select( ['id', 'given_name', 'family_name', 'contact_details']).show() ``` 下面是输出： ``` +--------------------+----------+-----------+---------------+ | id|given_name|family_name|contact_details| +--------------------+----------+-----------+---------------+ |f4fc30ee-7b42-432...| Mike| Ross| 10| |e3c60f34-7d1b-4c0...| Shelley| Capito| 75| +--------------------+----------+-----------+---------------+ ``` 请注意，这些命令中先后使用了 `toDF()` 和 `where` 表示式来筛选您要查看的行。因此，将 `hist_root` 表与辅助表联接可让您执行以下操作： + 将数据加载到不支持数组的数据库中。 + 使用 SQL 查询数组中的每个单独的项目。使用 AWS Glue 连接安全地存储和访问您的 Amazon Redshift 凭证。有关如何创建您自己的连接的信息，请参阅 [连接到数据](glue-connections.md)。现在，您已准备就绪，可以通过一次遍历一个 `DynamicFrames` 来将数据写入到连接： ``` for df_name in dfc.keys(): m_df = dfc.select(df_name) print "Writing to table: ", df_name glueContext.write_dynamic_frame.from_jdbc_conf(frame = m_df, connection settings here) ``` 根据您的关系数据库类型，连接设置将有所不同： + 有关写入到 Amazon Redshift 的说明，请参阅 [Redshift 连接](aws-glue-programming-etl-connect-redshift-home.md)。 + 有关其他数据库，请参阅 [AWS Glue for Spark 中适用于 ETL 的连接类型和选项](aws-glue-programming-etl-connect.md)。 ## 结论总的来说，AWS Glue 非常灵活。它让您只需几行代码即可完成通常需要编写几天才能实现的功能。您可以在 GitHub 上 [`join_and_relationalize.py` 示例](https://github.com/awslabs/aws-glue-samples)的 Python 文件 AWS Glue 中找到完整的源到目标 ETL 脚本。 # 代码示例：使用 ResolveChoice、Lambda 和 ApplyMapping 进行数据准备此示例使用的数据集包括从两个 [Data.CMS.gov](https://data.cms.gov) 数据集下载的医疗保健提供商付款数据：“Inpatient Prospective Payment System Provider Summary for the Top 100 Diagnosis-Related Groups - FY2011”和“Inpatient Charge Data FY 2011”。下载该数据后，我们修改了数据集，以在文件末尾引入了几个错误的记录。这个修改过的文件位于 `s3://awsglue-datasets/examples/medicare/Medicare_Hospital_Provider.csv` 上的公有 Amazon S3 存储桶。您可以在 [AWS Glue 示例 GitHub](https://github.com/awslabs/aws-glue-samples) 存储库中的 `data_cleaning_and_lambda.py`文件中找到本示例的源代码。在 AWS 上运行时，调试 Python 或 PySpark 脚本的首选方法是[在 AWS Glue Studio 上使用笔记本](https://docs.aws.amazon.com/glue/latest/ug/notebooks-chapter.html)。 ## 步骤 1：爬取 Amazon S3 存储桶中的数据 1. 登录 AWS 管理控制台，然后打开 AWS Glue 控制台，网址为：[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)。 1. 按照 [配置爬网程序](define-crawler.md) 中描述的过程进行操作，创建新的爬网程序，它可以网络爬取 `s3://awsglue-datasets/examples/medicare/Medicare_Hospital_Provider.csv` 文件，而且可以将生成的元数据放入 AWS Glue 数据目录中一个名为 `payments` 的数据库。 1. 运行新爬网程序，然后检查 `payments` 数据库。在读取该文件的开头以确定其格式和分隔符之后，您应该发现爬网程序已经在数据库中创建了一个名为 `medicare` 的元数据表。新 `medicare` 表的架构如下所示： ``` Column name Data type ================================================== drg definition string provider id bigint provider name string provider street address string provider city string provider state string provider zip code bigint hospital referral region description string total discharges bigint average covered charges string average total payments string average medicare payments string ``` ## 步骤 2：向开发终端节点笔记本中添加样板文件脚本将以下样板文件脚本粘贴到开发终端节点笔记本中以导入所需的 AWS Glue 库，然后设置单个 `GlueContext`： ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job glueContext = GlueContext(SparkContext.getOrCreate()) ``` ## 步骤 3：比较不同的架构解析接下来，您可以查看由 Apache Spark `DataFrame` 识别的架构是否与您的 AWS Glue 爬网程序记录的架构相同。运行此代码： ``` medicare = spark.read.format( "com.databricks.spark.csv").option( "header", "true").option( "inferSchema", "true").load( 's3://awsglue-datasets/examples/medicare/Medicare_Hospital_Provider.csv') medicare.printSchema() ``` 下面是来自 `printSchema` 调用的输出： ``` root |-- DRG Definition: string (nullable = true) |-- Provider Id: string (nullable = true) |-- Provider Name: string (nullable = true) |-- Provider Street Address: string (nullable = true) |-- Provider City: string (nullable = true) |-- Provider State: string (nullable = true) |-- Provider Zip Code: integer (nullable = true) |-- Hospital Referral Region Description: string (nullable = true) |-- Total Discharges : integer (nullable = true) |-- Average Covered Charges : string (nullable = true) |-- Average Total Payments : string (nullable = true) |-- Average Medicare Payments: string (nullable = true) ``` 接下来，查看 AWS Glue `DynamicFrame` 生成的架构： ``` medicare_dynamicframe = glueContext.create_dynamic_frame.from_catalog( database = "payments", table_name = "medicare") medicare_dynamicframe.printSchema() ``` `printSchema` 中的输出如下所示： ``` root |-- drg definition: string |-- provider id: choice | |-- long | |-- string |-- provider name: string |-- provider street address: string |-- provider city: string |-- provider state: string |-- provider zip code: long |-- hospital referral region description: string |-- total discharges: long |-- average covered charges: string |-- average total payments: string |-- average medicare payments: string ``` `DynamicFrame` 生成一个架构，在其中 `provider id` 可以是 `long` 或 `string` 类型。`DataFrame` 架构将 `Provider Id` 列为 `string` 类型，数据目录将 `provider id` 列为 `bigint` 类型。哪一个是正确的？文件末尾有两条记录 (共计 16 万条记录)，该列中有 `string` 值。这些是为说明问题而引入的错误记录。为解决此类问题，AWS Glue `DynamicFrame` 引入了 *choice* 类型的概念。在这种情况下，`DynamicFrame` 显示 `long` 和 `string` 值都出现在该列中。AWS Glue 爬网程序错过了 `string` 值，因为它仅被视为数据的一个 2 MB 前缀。Apache Spark `DataFrame` 考虑了整个数据集，但它被迫将最一般的类型分配给该列，即 `string`。事实上，当存在复杂类型或不熟悉的变体时，Spark 通常会采用最一般的情况。要查询 `provider id` 列，请先解析选择类型。您可以在 `DynamicFrame` 中使用 `resolveChoice` 转换方法，通过 `cast:long` 选项将这些 `string` 值转换为 `long` 值： ``` medicare_res = medicare_dynamicframe.resolveChoice(specs = [('provider id','cast:long')]) medicare_res.printSchema() ``` `printSchema` 输出现在是： ``` root |-- drg definition: string |-- provider id: long |-- provider name: string |-- provider street address: string |-- provider city: string |-- provider state: string |-- provider zip code: long |-- hospital referral region description: string |-- total discharges: long |-- average covered charges: string |-- average total payments: string |-- average medicare payments: string ``` 其中，该值是无法强制转换的 `string`，AWS Glue 插入了一个 `null`。另一个选项是将选择类型转换为一个 `struct`，以保持两种类型的值。接下来，查看异常的行： ``` medicare_res.toDF().where("'provider id' is NULL").show() ``` 您看到以下内容： ``` +--------------------+-----------+---------------+-----------------------+-------------+--------------+-----------------+------------------------------------+----------------+-----------------------+----------------------+-------------------------+ | drg definition|provider id| provider name|provider street address|provider city|provider state|provider zip code|hospital referral region description|total discharges|average covered charges|average total payments|average medicare payments| +--------------------+-----------+---------------+-----------------------+-------------+--------------+-----------------+------------------------------------+----------------+-----------------------+----------------------+-------------------------+ |948 - SIGNS & SYM...| null| INC| 1050 DIVISION ST| MAUSTON| WI| 53948| WI - Madison| 12| $11961.41| $4619.00| $3775.33| |948 - SIGNS & SYM...| null| INC- ST JOSEPH| 5000 W CHAMBERS ST| MILWAUKEE| WI| 53210| WI - Milwaukee| 14| $10514.28| $5562.50| $4522.78| +--------------------+-----------+---------------+-----------------------+-------------+--------------+-----------------+------------------------------------+----------------+-----------------------+----------------------+-------------------------+ ``` 现在，删除两个格式错误的记录，如下所示： ``` medicare_dataframe = medicare_res.toDF() medicare_dataframe = medicare_dataframe.where("'provider id' is NOT NULL") ``` ## 步骤 4：映射数据和使用 Apache Spark Lambda 函数 AWS Glue 尚未直接支持 Lambda 函数，也称为用户定义函数。但是，您始终可以将 `DynamicFrame` 和 Apache Spark `DataFrame` 相互转换，以便除 `DynamicFrames` 的特殊功能外，还能利用 Spark 功能。接下来，将付款信息转化为数字，以便 Amazon Redshift 或 Amazon Athena 这样的分析引擎可以更快地进行数字处理： ``` from pyspark.sql.functions import udf from pyspark.sql.types import StringType chop_f = udf(lambda x: x[1:], StringType()) medicare_dataframe = medicare_dataframe.withColumn( "ACC", chop_f( medicare_dataframe["average covered charges"])).withColumn( "ATP", chop_f( medicare_dataframe["average total payments"])).withColumn( "AMP", chop_f( medicare_dataframe["average medicare payments"])) medicare_dataframe.select(['ACC', 'ATP', 'AMP']).show() ``` `show` 调用中的输出如下所示： ``` +--------+-------+-------+ | ACC| ATP| AMP| +--------+-------+-------+ |32963.07|5777.24|4763.73| |15131.85|5787.57|4976.71| |37560.37|5434.95|4453.79| |13998.28|5417.56|4129.16| |31633.27|5658.33|4851.44| |16920.79|6653.80|5374.14| |11977.13|5834.74|4761.41| |35841.09|8031.12|5858.50| |28523.39|6113.38|5228.40| |75233.38|5541.05|4386.94| |67327.92|5461.57|4493.57| |39607.28|5356.28|4408.20| |22862.23|5374.65|4186.02| |31110.85|5366.23|4376.23| |25411.33|5282.93|4383.73| | 9234.51|5676.55|4509.11| |15895.85|5930.11|3972.85| |19721.16|6192.54|5179.38| |10710.88|4968.00|3898.88| |51343.75|5996.00|4962.45| +--------+-------+-------+ only showing top 20 rows ``` 这些仍然是数据中的字符串。我们可以使用强大的 `apply_mapping` 转换方法来删除、重命名、转换和嵌套数据，以便其他数据编程语言和系统可以轻松地访问它： ``` from awsglue.dynamicframe import DynamicFrame medicare_tmp_dyf = DynamicFrame.fromDF(medicare_dataframe, glueContext, "nested") medicare_nest_dyf = medicare_tmp_dyf.apply_mapping([('drg definition', 'string', 'drg', 'string'), ('provider id', 'long', 'provider.id', 'long'), ('provider name', 'string', 'provider.name', 'string'), ('provider city', 'string', 'provider.city', 'string'), ('provider state', 'string', 'provider.state', 'string'), ('provider zip code', 'long', 'provider.zip', 'long'), ('hospital referral region description', 'string','rr', 'string'), ('ACC', 'string', 'charges.covered', 'double'), ('ATP', 'string', 'charges.total_pay', 'double'), ('AMP', 'string', 'charges.medicare_pay', 'double')]) medicare_nest_dyf.printSchema() ``` `printSchema` 输出如下所示： ``` root |-- drg: string |-- provider: struct | |-- id: long | |-- name: string | |-- city: string | |-- state: string | |-- zip: long |-- rr: string |-- charges: struct | |-- covered: double | |-- total_pay: double | |-- medicare_pay: double ``` 将数据重新变成 Spark `DataFrame` 后，您可以显示它现在的外观： ``` medicare_nest_dyf.toDF().show() ``` 您可以在一个 (扩展) 代码行中执行所有这些操作： ``` +--------------------+--------------------+---------------+--------------------+ | drg| provider| rr| charges| +--------------------+--------------------+---------------+--------------------+ |039 - EXTRACRANIA...|[10001,SOUTHEAST ...| AL - Dothan|[32963.07,5777.24...| |039 - EXTRACRANIA...|[10005,MARSHALL M...|AL - Birmingham|[15131.85,5787.57...| |039 - EXTRACRANIA...|[10006,ELIZA COFF...|AL - Birmingham|[37560.37,5434.95...| |039 - EXTRACRANIA...|[10011,ST VINCENT...|AL - Birmingham|[13998.28,5417.56...| |039 - EXTRACRANIA...|[10016,SHELBY BAP...|AL - Birmingham|[31633.27,5658.33...| |039 - EXTRACRANIA...|[10023,BAPTIST ME...|AL - Montgomery|[16920.79,6653.8,...| |039 - EXTRACRANIA...|[10029,EAST ALABA...|AL - Birmingham|[11977.13,5834.74...| |039 - EXTRACRANIA...|[10033,UNIVERSITY...|AL - Birmingham|[35841.09,8031.12...| |039 - EXTRACRANIA...|[10039,HUNTSVILLE...|AL - Huntsville|[28523.39,6113.38...| |039 - EXTRACRANIA...|[10040,GADSDEN RE...|AL - Birmingham|[75233.38,5541.05...| |039 - EXTRACRANIA...|[10046,RIVERVIEW ...|AL - Birmingham|[67327.92,5461.57...| |039 - EXTRACRANIA...|[10055,FLOWERS HO...| AL - Dothan|[39607.28,5356.28...| |039 - EXTRACRANIA...|[10056,ST VINCENT...|AL - Birmingham|[22862.23,5374.65...| |039 - EXTRACRANIA...|[10078,NORTHEAST ...|AL - Birmingham|[31110.85,5366.23...| |039 - EXTRACRANIA...|[10083,SOUTH BALD...| AL - Mobile|[25411.33,5282.93...| |039 - EXTRACRANIA...|[10085,DECATUR GE...|AL - Huntsville|[9234.51,5676.55,...| |039 - EXTRACRANIA...|[10090,PROVIDENCE...| AL - Mobile|[15895.85,5930.11...| |039 - EXTRACRANIA...|[10092,D C H REGI...|AL - Tuscaloosa|[19721.16,6192.54...| |039 - EXTRACRANIA...|[10100,THOMAS HOS...| AL - Mobile|[10710.88,4968.0,...| |039 - EXTRACRANIA...|[10103,BAPTIST ME...|AL - Birmingham|[51343.75,5996.0,...| +--------------------+--------------------+---------------+--------------------+ only showing top 20 rows ``` ## 步骤 5：将数据写入到 Apache Parquet 有了 AWS Glue，可以很容易地以诸如 Apache Parquet 这样的格式编写数据，以便关系数据库可以有效地使用它： ``` glueContext.write_dynamic_frame.from_options( frame = medicare_nest_dyf, connection_type = "s3", connection_options = {"path": "s3://glue-sample-target/output-dir/medicare_parquet"}, format = "parquet") ``` # AWS Glue PySpark 扩展参考 AWS Glue 为 PySpark Python 方言创建了以下扩展。 + [使用 `getResolvedOptions` 访问参数](aws-glue-api-crawler-pyspark-extensions-get-resolved-options.md) + [PySpark 扩展类型](aws-glue-api-crawler-pyspark-extensions-types.md) + [DynamicFrame 类](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md) + [DynamicFrameCollection 类](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-collection.md) + [DynamicFrameWriter 类](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-writer.md) + [DynamicFrameReader 类](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader.md) + [GlueContext 类](aws-glue-api-crawler-pyspark-extensions-glue-context.md) # 使用 `getResolvedOptions` 访问参数 AWS Glue `getResolvedOptions(args, options)` 实用程序函数为您提供了访问您在运行作业时传递到脚本的参数的权限。要使用此函数，请先将其从 AWS Glue `utils` 模块以及 `sys` 模块导入： ``` import sys from awsglue.utils import getResolvedOptions ``` **`getResolvedOptions(args, options)`** + `args` – `sys.argv` 中包含的参数的列表。 + `options` – 要检索的参数名称的 Python 数组。 **Example 检索传递到 JobRun 的参数** 假设您在某个脚本中（或许是在某个 Lambda 函数内）创建了 JobRun： ``` response = client.start_job_run( JobName = 'my_test_Job', Arguments = { '--day_partition_key': 'partition_0', '--hour_partition_key': 'partition_1', '--day_partition_value': day_partition_value, '--hour_partition_value': hour_partition_value } ) ``` 要检索传递的参数，您可以使用 `getResolvedOptions` 函数，如下所示： ``` import sys from awsglue.utils import getResolvedOptions args = getResolvedOptions(sys.argv, ['JOB_NAME', 'day_partition_key', 'hour_partition_key', 'day_partition_value', 'hour_partition_value']) print "The day-partition key is: ", args['day_partition_key'] print "and the day-partition value is: ", args['day_partition_value'] ``` 请注意，每个参数将定义为以两个连字符开头，则将在不带连字符的脚本中引用。参数只使用下划线，而不是连字符。您的参数需要遵循此规则才能得到解决。 # PySpark 扩展类型 AWS Glue PySpark 扩展所使用的类型。 ## DataType 其他 AWS Glue 类型的基类。 **`__init__(properties={})`** + `properties` – 数据类型的属性 (可选)。   **`typeName(cls)`** 返回 AWS Glue 类型类的类型（即，类名，其“Type”会从末尾删除）。 + `cls` – 一个派生自 AWS Glue 的 `DataType` 类实例。   `jsonValue( )` 返回一个包含类的数据类型和属性的 JSON 对象： ``` { "dataType": typeName, "properties": properties } ``` ## AtomicType 和简单衍生继承自并扩展 [DataType](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-datatype) 类，并且充当所有 AWS Glue 原子数据类型的基类。 **`fromJsonValue(cls, json_value)`** 使用 JSON 对象中的值初始化类实例。 + `cls` – 一个要初始化的 AWS Glue 类型类。 + `json_value` – 要从其中加载键-值对的 JSON 对象。   以下类型是 [AtomicType](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-atomictype) 类的简单衍生： + `BinaryType` – 二进制数据。 + `BooleanType` – 布尔值。 + `ByteType` – 一个字节值。 + `DateType` – 一个日期时间值。 + `DoubleType` – 一个双精度浮点值。 + `IntegerType` – 一个整数值。 + `LongType` – 一个长整数值。 + `NullType` – 一个空值。 + `ShortType` – 一个短整数值。 + `StringType` – 一个文本字符串。 + `TimestampType` – 一个时间戳值 (通常以秒为单位，从 1/1/1970 开始)。 + `UnknownType` – 一个未知类型的值。 ## DecimalType(AtomicType) 继承自并扩展 [AtomicType](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-atomictype) 类以表示十进制数字 (以十进制数字表示的数字，与二进制以 2 为底数的数字相对)。 **`__init__(precision=10, scale=2, properties={})`** + `precision` – 十进制数中的位数 (可选；默认值为 10)。 + `scale` – 小数点右侧的位数 (可选；默认值为 2)。 + `properties` – 十进制数字的属性 (可选)。 ## EnumType(AtomicType) 继承自并扩展 [AtomicType](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-atomictype) 类以表示有效选项的枚举。 **`__init__(options)`** + `options` – 正被枚举的选项的列表。 ## 集合类型 + [ArrayType(DataType)](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-arraytype) + [ChoiceType(DataType)](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-choicetype) + [MapType(DataType)](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-maptype) + [Field(Object)](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-field) + [StructType(DataType)](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-structtype) + [EntityType(DataType)](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-entitytype) ## ArrayType(DataType) **`__init__(elementType=UnknownType(), properties={})`** + `elementType` – 数组中的元素的类型 (可选；默认值为 UnknownType)。 + `properties` – 数组的属性 (可选)。 ## ChoiceType(DataType) **`__init__(choices=[], properties={})`** + `choices` – 可能选项的列表 (可选)。 + `properties` – 这些选项的属性 (可选)。   **`add(new_choice)`** 将新选项添加到可能的选项列表中。 + `new_choice` – 要添加到可能选项列表中的选项。   **`merge(new_choices)`** 将新选项列表与现有选项列表合并。 + `new_choices` – 要与现有选项列表合并的新选项列表。 ## MapType(DataType) **`__init__(valueType=UnknownType, properties={})`** + `valueType` – 映射中的值的类型 (可选；默认值为 UnknownType)。 + `properties` – 映射的属性 (可选)。 ## Field(Object) 根据从 [DataType](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-datatype) 派生的对象创建一个字段对象。 **`__init__(name, dataType, properties={})`** + `name` – 要为字段分配的名称。 + `dataType` – 要从中创建字段的对象。 + `properties` – 字段的属性 (可选)。 ## StructType(DataType) 定义数据结构 (`struct`)。 **`__init__(fields=[], properties={})`** + `fields` – 要在结构中包括的字段的列表 (类型为 `Field`) (可选)。 + `properties` – 结构的属性 (可选)。   **`add(field)`** + `field` – 要添加到结构中的类型 `Field` 的对象。   **`hasField(field)`** 如果此结构具有同名字段，则返回 `True`，否则返回 `False`。 + `field` – 一个字段名称，或其名称被使用的类型 `Field` 的对象。   **`getField(field)`** + `field` – 一个字段名称，或其名称被使用的类型 `Field` 的对象。如果此结构具有同名字段，则返回它。 ## EntityType(DataType) `__init__(entity, base_type, properties)` 此类尚未实现。 ## 其他类型 + [DataSource(object)](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-data-source) + [DataSink(object)](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-data-sink) ## DataSource(object) **`__init__(j_source, sql_ctx, name)`** + `j_source` – 数据源。 + `sql_ctx` – SQL 上下文。 + `name` – 数据源名称。   **`setFormat(format, **options)`** + `format` – 要为数据源设置的格式。 + `options`- 要为数据源设置的选项的集合。有关格式选项的更多信息，请参阅 [AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。   `getFrame()` 为数据源返回 `DynamicFrame`。 ## DataSink(object) **`__init__(j_sink, sql_ctx)`** + `j_sink` – 要创建的堆栈。 + `sql_ctx` – 数据接收器的 SQL 上下文。   **`setFormat(format, **options)`** + `format` – 要为数据接收器设置的格式。 + `options`- 要为数据接收器设置的选项的集合。有关格式选项的更多信息，请参阅 [AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。   **`setAccumulableSize(size)`** + `size` – 要设置的可累积大小 (以字节为单位)。   **`writeFrame(dynamic_frame, info="")`** + `dynamic_frame` – 要编写的 `DynamicFrame`。 + `info` – 有关 `DynamicFrame` 的信息 (可选)。   **`write(dynamic_frame_or_dfc, info="")`** 写入 `DynamicFrame` 或 `DynamicFrameCollection`。 + `dynamic_frame_or_dfc` – 将被写入的 `DynamicFrame` 对象或 `DynamicFrameCollection` 对象。 + `info` – 有关将被写入的 `DynamicFrame` 或 `DynamicFrames` 的信息 (可选)。 # DynamicFrame 类 Apache Spark 中的主要抽象之一是 SparkSQL `DataFrame`，它类似于在 R 和 Pandas 中找到的 `DataFrame` 构造。`DataFrame` 类似于表格，支持函数风格（map/reduce/filter/等）操作和 SQL 操作（select、project、aggregate）。尽管 `DataFrames` 功能强大且运用广泛，但在提取、转换和加载 (ETL) 操作方面存在局限性。最明显的是，它们需要指定了架构后才能加载任何数据。SparkSQL 通过对数据进行两次扫描解决了这一问题 – 第一次为了推断架构，第二次为了加载数据。然而，此推断仍有局限性，且不能解决数据混乱的实际问题。例如，同样的字段在不同记录中可能属于不同类型。对此，Apache Spark 通常没有好的办法，只能使用原始字段文本将类型报告为 `string`。这或许不正确，同时您可能希望更精细地控制解决架构差异的方式。对于大型数据集而言，每扫描一次源数据都会付出高昂代价。为了解决这些局限性，AWS Glue 推出了 `DynamicFrame`。`DynamicFrame` 类似于 `DataFrame`，不同之处在于每个记录都是自描述的，因此初始并不需要架构。相反，AWS Glue 会在需要时实时计算一个架构，并使用选择（或联合）类型显式编码架构不一致之处。您可以解决这些不一致之处，以使您的数据集兼容需要固定架构的数据存储。同样，一个 `DynamicRecord` 表示 `DynamicFrame` 中的一条逻辑记录。它类似于 Spark `DataFrame` 中的一行，只不过它是自描述的，可用于不符合固定架构的数据。将 AWS Glue 与 PySpark 一起使用时，通常不需要处理独立 `DynamicRecords`。相反，您需要通过 `DynamicFrame` 一起转换数据集。在解决任何架构不一致问题后，就可以在 `DynamicFrames` 和 `DataFrames` 之间来回转换。 ## – 构造 – + [\$1\$1init\$1\$1](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-__init__) + [fromDF](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-fromDF) + [toDF](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-toDF) ## \$1\$1init\$1\$1 **`__init__(jdf, glue_ctx, name)`** + `jdf` – 对 Java 虚拟机 (JVM) 中数据帧的引用。 + `glue_ctx` – 一个 [GlueContext 类](aws-glue-api-crawler-pyspark-extensions-glue-context.md) 对象。 + `name` – 可选的名称字符串，默认为空。 ## fromDF **`fromDF(dataframe, glue_ctx, name)`** 通过将 `DataFrame` 字段转换为 `DynamicRecord` 字段将 `DataFrame` 转换为 `DynamicFrame`。返回新的 `DynamicFrame`。一个 `DynamicRecord` 表示 `DynamicFrame` 中的一条逻辑记录。它类似于 Spark `DataFrame` 中的一行，只不过它是自描述的，可用于不符合固定架构的数据。此函数期望您 `DataFrame` 中名称重复的列已经被解析。 + `dataframe` – 要转换的 Apache Spark SQL `DataFrame` (必需)。 + `glue_ctx` – 为此转换指定上下文的 [GlueContext 类](aws-glue-api-crawler-pyspark-extensions-glue-context.md) 对象 (必需)。 + `name` – 生成的 `DynamicFrame` 的名称（从 AWS Glue 3.0 起是可选的）。 ## toDF **`toDF(options)`** 通过将 `DynamicRecords` 转换为 `DataFrame` 字段将 `DynamicFrame` 转换为 Apache Spark `DataFrame`。返回新的 `DataFrame`。一个 `DynamicRecord` 表示 `DynamicFrame` 中的一条逻辑记录。它类似于 Spark `DataFrame` 中的一行，只不过它是自描述的，可用于不符合固定架构的数据。 + `options` – 指定在转换过程中如何解析选择类型的 `ResolveOption` 对象列表。此参数用于处理架构不一致，不适用于像 CSV 解析这样的格式选项。对于 CSV 解析和其他格式选项，请在创建 DynamicFrame 时在 `from_options` 方法中指定这些选项，而不是在 `toDF` 方法中指定这些选项。以下是处理 CSV 格式选项的正确方法的示例： ``` from awsglue.context import GlueContext from awsglue.dynamicframe import DynamicFrame from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) # Correct: Specify format options in from_options csv_dyf = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={"paths": ["s3://my-bucket/path/to/csv/"]}, format="csv", format_options={ "withHeader": True, "separator": ",", "inferSchema": True } ) # Convert to DataFrame (no format options needed here) csv_df = csv_dyf.toDF() ``` `toDF` 中的 `options` 参数专门用于解析选择类型。如果您选择 `Project` 和 `Cast` 操作类型，则指定目标类型。示例包括以下内容。 ``` >>>toDF([ResolveOption("a.b.c", "KeepAsStruct")]) >>>toDF([ResolveOption("a.b.c", "Project", DoubleType())]) ``` ## – 信息 – + [count](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-count) + [架构](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-schema) + [printSchema](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-printSchema) + [show](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-show) + [repartition](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-repartition) + [coalesce](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-coalesce) ## count `count( )` – 返回底层 `DataFrame` 中的行数。 ## 架构 `schema( )` – 返回此 `DynamicFrame` 的架构，如果此架构不可用，则返回底层 `DataFrame` 的架构。有关构成此架构的 `DynamicFrame` 类型的更多信息，请参阅 [PySpark 扩展类型](aws-glue-api-crawler-pyspark-extensions-types.md)。 ## printSchema `printSchema( )` – 打印底层 `DataFrame` 的架构。 ## show `show(num_rows)` – 打印底层 `DataFrame` 中的行数。 ## repartition `repartition(numPartitions)` – 返回具有 `numPartitions` 个分区的新 `DynamicFrame`。 ## coalesce `coalesce(numPartitions)` – 返回具有 `numPartitions` 个分区的新 `DynamicFrame`。 ## – 转换 – + [apply\$1mapping](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-apply_mapping) + [drop\$1fields](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-drop_fields) + [筛选](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-filter) + [join](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-join) + [映射](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-map) + [mergeDynamicFrame](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-merge) + [relationalize](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-relationalize) + [rename\$1field](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-rename_field) + [resolveChoice](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-resolveChoice) + [select\$1fields](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-select_fields) + [spigot](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-spigot) + [split\$1fields](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-split_fields) + [split\$1rows](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-split_rows) + [unbox](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-unbox) + [联合](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-union) + [unnest](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-unnest) + [unnest\$1ddb\$1json](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-unnest_ddb_json) + [write](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-write) ## apply\$1mapping **`apply_mapping(mappings, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** 将声明映射应用于此 `DynamicFrame` 并返回已将那些映射应用于所指定字段的新 `DynamicFrame`。新 `DynamicFrame` 中省略了未指定的字段。 + `mappings` – 映射元组列表（必需）。每个元组包括：（源列，源类型，目标列，目标类型）。如果源列的名称有一个点“`.`”，则必须在名称外加上反引号“````”。例如，要将 `this.old.name`（字符串）映射到 `thisNewName`，可以使用以下元组： ``` ("`this.old.name`", "string", "thisNewName", "string") ``` + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与此转换的错误报告关联的字符串 (可选)。 + `stageThreshold` – 此转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 + `totalThreshold` – 此转换之前及转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 ### 示例：使用 apply\$1mapping 重命名字段并更改字段类型以下代码示例展示了如何使用 `apply_mapping` 方法重命名选定字段并更改字段类型。 **注意** 要访问本示例中使用的数据集，请参阅 [代码示例：对数据进行联接和关系化](aws-glue-programming-python-samples-legislators.md) 并按照 [步骤 1：爬取 Amazon S3 存储桶中的数据](aws-glue-programming-python-samples-legislators.md#aws-glue-programming-python-samples-legislators-crawling) 中的说明进行操作。 ``` # Example: Use apply_mapping to reshape source data into # the desired column names and types as a new DynamicFrame from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Create a DynamicFrame and view its schema persons = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="persons_json" ) print("Schema for the persons DynamicFrame:") persons.printSchema() # Select and rename fields, change field type print("Schema for the persons_mapped DynamicFrame, created with apply_mapping:") persons_mapped = persons.apply_mapping( [ ("family_name", "String", "last_name", "String"), ("name", "String", "first_name", "String"), ("birth_date", "String", "date_of_birth", "Date"), ] ) persons_mapped.printSchema() ``` #### Output ``` Schema for the persons DynamicFrame: root |-- family_name: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- gender: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- sort_name: string |-- images: array | |-- element: struct | | |-- url: string |-- given_name: string |-- birth_date: string |-- id: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- death_date: string Schema for the persons_mapped DynamicFrame, created with apply_mapping: root |-- last_name: string |-- first_name: string |-- date_of_birth: date ``` ## drop\$1fields **`drop_fields(paths, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** 调用 [FlatMap 类](aws-glue-api-crawler-pyspark-transforms-flat-map.md) 转换以从 `DynamicFrame` 中删除字段。返回指定字段已删除的新的 `DynamicFrame`。 + `paths` – 字符串列表。每个字符串都包含要删除的字段节点的完整路径。您可以使用点表示法来指定嵌套字段。例如，如果字段 `first` 在树结构中是字段 `name` 的子字段，则为路径指定 `"name.first"`。如果字段节点的名称有文字 `.`，则必须用反引号（```）将名称括起来。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与此转换的错误报告关联的字符串 (可选)。 + `stageThreshold` – 此转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 + `totalThreshold` – 此转换之前及转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 ### 示例：使用 drop\$1fields 从 `DynamicFrame` 中删除字段此代码示例使用 `drop_fields` 方法从 `DynamicFrame` 中移除选定的顶级字段和嵌套字段。 **示例数据集** 该示例使用以下数据集，其在代码中由 `EXAMPLE-FRIENDS-DATA` 表表示： ``` {"name": "Sally", "age": 23, "location": {"state": "WY", "county": "Fremont"}, "friends": []} {"name": "Varun", "age": 34, "location": {"state": "NE", "county": "Douglas"}, "friends": [{"name": "Arjun", "age": 3}]} {"name": "George", "age": 52, "location": {"state": "NY"}, "friends": [{"name": "Fred"}, {"name": "Amy", "age": 15}]} {"name": "Haruki", "age": 21, "location": {"state": "AK", "county": "Denali"}} {"name": "Sheila", "age": 63, "friends": [{"name": "Nancy", "age": 22}]} ``` **示例代码** ``` # Example: Use drop_fields to remove top-level and nested fields from a DynamicFrame. # Replace MY-EXAMPLE-DATABASE with your Glue Data Catalog database name. # Replace EXAMPLE-FRIENDS-DATA with your table name. from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Create a DynamicFrame from Glue Data Catalog glue_source_database = "MY-EXAMPLE-DATABASE" glue_source_table = "EXAMPLE-FRIENDS-DATA" friends = glueContext.create_dynamic_frame.from_catalog( database=glue_source_database, table_name=glue_source_table ) print("Schema for friends DynamicFrame before calling drop_fields:") friends.printSchema() # Remove location.county, remove friends.age, remove age friends = friends.drop_fields(paths=["age", "location.county", "friends.age"]) print("Schema for friends DynamicFrame after removing age, county, and friend age:") friends.printSchema() ``` #### Output ``` Schema for friends DynamicFrame before calling drop_fields: root |-- name: string |-- age: int |-- location: struct | |-- state: string | |-- county: string |-- friends: array | |-- element: struct | | |-- name: string | | |-- age: int Schema for friends DynamicFrame after removing age, county, and friend age: root |-- name: string |-- location: struct | |-- state: string |-- friends: array | |-- element: struct | | |-- name: string ``` ## 筛选 **`filter(f, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** 返回新 `DynamicFrame`，其中包含输入 `DynamicFrame` 中满足指定谓词函数 `f` 的所有 `DynamicRecords`。 + `f` – 应用到 `DynamicFrame` 的谓词函数。该函数必须采用 `DynamicRecord` 作为参数，如果 `DynamicRecord` 满足筛选要求，则返回 True，否则返回 False (必需)。一个 `DynamicRecord` 表示 `DynamicFrame` 中的一条逻辑记录。其类似于 Spark `DataFrame` 中的一行，但其具有自描述性，可用于不符合固定架构的数据。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与此转换的错误报告关联的字符串 (可选)。 + `stageThreshold` – 此转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 + `totalThreshold` – 此转换之前及转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 ### 示例：使用筛选条件获取筛选后的字段选择此示例用 `filter` 方法创建新 `DynamicFrame`，其中包括筛选后的其他 `DynamicFrame` 字段选择。类似于 `map` 方法，`filter` 采用一个函数作为实际参数，以将其应用于原 `DynamicFrame` 中的每个记录。该函数将记录作为输入并返回布尔值。如果返回值为 true，则该记录将包含在生成的 `DynamicFrame` 中。如果返回值为 false，则该记录将被排除在外。 **注意** 要访问本示例中使用的数据集，请参阅 [代码示例：使用 ResolveChoice、Lambda 和 ApplyMapping 进行数据准备](aws-glue-programming-python-samples-medicaid.md) 并按照 [步骤 1：爬取 Amazon S3 存储桶中的数据](aws-glue-programming-python-samples-medicaid.md#aws-glue-programming-python-samples-medicaid-crawling) 中的说明进行操作。 ``` # Example: Use filter to create a new DynamicFrame # with a filtered selection of records from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Create DynamicFrame from Glue Data Catalog medicare = glueContext.create_dynamic_frame.from_options( "s3", { "paths": [ "s3://awsglue-datasets/examples/medicare/Medicare_Hospital_Provider.csv" ] }, "csv", {"withHeader": True}, ) # Create filtered DynamicFrame with custom lambda # to filter records by Provider State and Provider City sac_or_mon = medicare.filter( f=lambda x: x["Provider State"] in ["CA", "AL"] and x["Provider City"] in ["SACRAMENTO", "MONTGOMERY"] ) # Compare record counts print("Unfiltered record count: ", medicare.count()) print("Filtered record count: ", sac_or_mon.count()) ``` #### Output ``` Unfiltered record count: 163065 Filtered record count: 564 ``` ## join **`join(paths1, paths2, frame2, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** 执行与另一个 `DynamicFrame` 的等式联接并返回生成的 `DynamicFrame`。 + `paths1` – 此帧中要联接的键列表。 + `paths2` – 另一帧中要联接的键列表。 + `frame2` – 要联接的另一个 `DynamicFrame`。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与此转换的错误报告关联的字符串 (可选)。 + `stageThreshold` – 此转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 + `totalThreshold` – 此转换之前及转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 ### 示例：使用联接来组合 `DynamicFrames` 此示例使用 `join` 方法对三个 `DynamicFrames` 执行联接。AWSGlue 根据您提供的字段键执行联接。由此生成的 `DynamicFrame` 包含来自指定密钥相匹配的两个原始帧中的行。请注意，`join` 转换会让所有字段保持不变。这意味着您指定要匹配的字段会出现在生成的 DynamicFrame 中，即使这些字段是多余的并且包含相同的密钥。在此示例中，我们在联接后使用 `drop_fields` 移除这些冗余密钥。 **注意** 要访问本示例中使用的数据集，请参阅 [代码示例：对数据进行联接和关系化](aws-glue-programming-python-samples-legislators.md) 并按照 [步骤 1：爬取 Amazon S3 存储桶中的数据](aws-glue-programming-python-samples-legislators.md#aws-glue-programming-python-samples-legislators-crawling) 中的说明进行操作。 ``` # Example: Use join to combine data from three DynamicFrames from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Load DynamicFrames from Glue Data Catalog persons = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="persons_json" ) memberships = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="memberships_json" ) orgs = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="organizations_json" ) print("Schema for the persons DynamicFrame:") persons.printSchema() print("Schema for the memberships DynamicFrame:") memberships.printSchema() print("Schema for the orgs DynamicFrame:") orgs.printSchema() # Join persons and memberships by ID persons_memberships = persons.join( paths1=["id"], paths2=["person_id"], frame2=memberships ) # Rename and drop fields from orgs # to prevent field name collisions with persons_memberships orgs = ( orgs.drop_fields(["other_names", "identifiers"]) .rename_field("id", "org_id") .rename_field("name", "org_name") ) # Create final join of all three DynamicFrames legislators_combined = orgs.join( paths1=["org_id"], paths2=["organization_id"], frame2=persons_memberships ).drop_fields(["person_id", "org_id"]) # Inspect the schema for the joined data print("Schema for the new legislators_combined DynamicFrame:") legislators_combined.printSchema() ``` #### Output ``` Schema for the persons DynamicFrame: root |-- family_name: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- gender: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- sort_name: string |-- images: array | |-- element: struct | | |-- url: string |-- given_name: string |-- birth_date: string |-- id: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- death_date: string Schema for the memberships DynamicFrame: root |-- area_id: string |-- on_behalf_of_id: string |-- organization_id: string |-- role: string |-- person_id: string |-- legislative_period_id: string |-- start_date: string |-- end_date: string Schema for the orgs DynamicFrame: root |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- id: string |-- classification: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- image: string |-- seats: int |-- type: string Schema for the new legislators_combined DynamicFrame: root |-- role: string |-- seats: int |-- org_name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- type: string |-- sort_name: string |-- area_id: string |-- images: array | |-- element: struct | | |-- url: string |-- on_behalf_of_id: string |-- other_names: array | |-- element: struct | | |-- note: string | | |-- name: string | | |-- lang: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- name: string |-- birth_date: string |-- organization_id: string |-- gender: string |-- classification: string |-- legislative_period_id: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- image: string |-- given_name: string |-- start_date: string |-- family_name: string |-- id: string |-- death_date: string |-- end_date: string ``` ## 映射 **`map(f, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** 返回由于将指定映射函数应用到原始 `DynamicFrame` 中的所有记录而产生的新的 `DynamicFrame`。 + `f` – 应用到 `DynamicFrame` 中所有记录的映射函数。该函数必须采用 `DynamicRecord` 作为参数并返回一个新的 `DynamicRecord` (必需)。一个 `DynamicRecord` 表示 `DynamicFrame` 中的一条逻辑记录。它类似于 Apache Spark `DataFrame` 中的一行，但其具有自描述性，可用于不符合固定架构的数据。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与转换中的错误关联的字符串（可选）。 + `stageThreshold` – 在转换出错之前可能在其中发生的最大错误数（可选）。默认值为 0。 + `totalThreshold` – 在处理出错之前可能全面发生的最大错误数（可选）。默认值为 0。 ### 示例：使用映射将函数应用于 `DynamicFrame` 中的每个记录此示例展示了如何使用 `map` 方法将函数应用于 `DynamicFrame` 的每个记录。具体而言，此示例将名为 `MergeAddress` 的函数应用于每个记录，以便将多个地址字段合并为一个 `struct` 类型。 **注意** 要访问本示例中使用的数据集，请参阅 [代码示例：使用 ResolveChoice、Lambda 和 ApplyMapping 进行数据准备](aws-glue-programming-python-samples-medicaid.md) 并按照 [步骤 1：爬取 Amazon S3 存储桶中的数据](aws-glue-programming-python-samples-medicaid.md#aws-glue-programming-python-samples-medicaid-crawling) 中的说明进行操作。 ``` # Example: Use map to combine fields in all records # of a DynamicFrame from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Create a DynamicFrame and view its schema medicare = glueContext.create_dynamic_frame.from_options( "s3", {"paths": ["s3://awsglue-datasets/examples/medicare/Medicare_Hospital_Provider.csv"]}, "csv", {"withHeader": True}) print("Schema for medicare DynamicFrame:") medicare.printSchema() # Define a function to supply to the map transform # that merges address fields into a single field def MergeAddress(rec): rec["Address"] = {} rec["Address"]["Street"] = rec["Provider Street Address"] rec["Address"]["City"] = rec["Provider City"] rec["Address"]["State"] = rec["Provider State"] rec["Address"]["Zip.Code"] = rec["Provider Zip Code"] rec["Address"]["Array"] = [rec["Provider Street Address"], rec["Provider City"], rec["Provider State"], rec["Provider Zip Code"]] del rec["Provider Street Address"] del rec["Provider City"] del rec["Provider State"] del rec["Provider Zip Code"] return rec # Use map to apply MergeAddress to every record mapped_medicare = medicare.map(f = MergeAddress) print("Schema for mapped_medicare DynamicFrame:") mapped_medicare.printSchema() ``` #### Output ``` Schema for medicare DynamicFrame: root |-- DRG Definition: string |-- Provider Id: string |-- Provider Name: string |-- Provider Street Address: string |-- Provider City: string |-- Provider State: string |-- Provider Zip Code: string |-- Hospital Referral Region Description: string |-- Total Discharges: string |-- Average Covered Charges: string |-- Average Total Payments: string |-- Average Medicare Payments: string Schema for mapped_medicare DynamicFrame: root |-- Average Total Payments: string |-- Average Covered Charges: string |-- DRG Definition: string |-- Average Medicare Payments: string |-- Hospital Referral Region Description: string |-- Address: struct | |-- Zip.Code: string | |-- City: string | |-- Array: array | | |-- element: string | |-- State: string | |-- Street: string |-- Provider Id: string |-- Total Discharges: string |-- Provider Name: string ``` ## mergeDynamicFrame **`mergeDynamicFrame(stage_dynamic_frame, primary_keys, transformation_ctx = "", options = {}, info = "", stageThreshold = 0, totalThreshold = 0)`** 基于指定主键的将此 `DynamicFrame` 与暂存 `DynamicFrame` 合并以标识记录。不会对重复记录（具有相同主键的记录）去除重复。如果暂存帧中没有匹配的记录，则从源中保留所有记录（包括重复记录）。如果暂存帧具有匹配的记录，则暂存帧中的记录将覆盖 AWS Glue 中的源中的记录。 + `stage_dynamic_frame` – 要合并的暂存 `DynamicFrame`。 + `primary_keys` – 要匹配源和暂存动态帧中的记录的主键字段列表。 + `transformation_ctx` – 用于检索有关当前转换的元数据的唯一字符串（可选）。 + `options` – 为此转换提供其他信息的 JSON 名称-值对的字符串。当前未使用此参数。 + `info` – 一个 `String`。要与此转换中的错误关联的任何字符串。 + `stageThreshold` – 一个 `Long`。给定转换中处理需要排除的错误的数目。 + `totalThreshold` – 一个 `Long`。此转换中处理需要排除的错误的总数。该方法将返回通过将此 `DynamicFrame` 与暂存 `DynamicFrame` 合并获取的新 `DynamicFrame`。在这些情况下，返回的 `DynamicFrame` 将包含记录 A： + 如果 `A` 在源帧和暂存帧中都存在，则返回暂存帧中的 `A`。 + 如果 `A` 在源表中，且 `A.primaryKeys` 不在 `stagingDynamicFrame` 中，这意味着未在暂存表中更新 `A`。源帧和暂存帧不需要具有相同的架构。 ### 示例：根据主键使用 mergeDynamicFrame 合并两个 `DynamicFrames` 以下代码示例显示了如何使用 `mergeDynamicFrame` 方法根据主键 `id` 将 `DynamicFrame` 与“staging”`DynamicFrame` 合并。 **示例数据集** 该示例使用了名为 `split_rows_collection` 的 `DynamicFrameCollection` 中的两个 `DynamicFrames`。以下是 `split_rows_collection` 中的键列表。 ``` dict_keys(['high', 'low']) ``` **示例代码** ``` # Example: Use mergeDynamicFrame to merge DynamicFrames # based on a set of specified primary keys from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.transforms import SelectFromCollection # Inspect the original DynamicFrames frame_low = SelectFromCollection.apply(dfc=split_rows_collection, key="low") print("Inspect the DynamicFrame that contains rows where ID < 10") frame_low.toDF().show() frame_high = SelectFromCollection.apply(dfc=split_rows_collection, key="high") print("Inspect the DynamicFrame that contains rows where ID > 10") frame_high.toDF().show() # Merge the DynamicFrames based on the "id" primary key merged_high_low = frame_high.mergeDynamicFrame( stage_dynamic_frame=frame_low, primary_keys=["id"] ) # View the results where the ID is 1 or 20 print("Inspect the merged DynamicFrame that contains the combined rows") merged_high_low.toDF().where("id = 1 or id= 20").orderBy("id").show() ``` #### Output ``` Inspect the DynamicFrame that contains rows where ID < 10 +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 1| 0| fax| 202-225-3307| | 1| 1| phone| 202-225-5731| | 2| 0| fax| 202-225-3307| | 2| 1| phone| 202-225-5731| | 3| 0| fax| 202-225-3307| | 3| 1| phone| 202-225-5731| | 4| 0| fax| 202-225-3307| | 4| 1| phone| 202-225-5731| | 5| 0| fax| 202-225-3307| | 5| 1| phone| 202-225-5731| | 6| 0| fax| 202-225-3307| | 6| 1| phone| 202-225-5731| | 7| 0| fax| 202-225-3307| | 7| 1| phone| 202-225-5731| | 8| 0| fax| 202-225-3307| | 8| 1| phone| 202-225-5731| | 9| 0| fax| 202-225-3307| | 9| 1| phone| 202-225-5731| | 10| 0| fax| 202-225-6328| | 10| 1| phone| 202-225-4576| +---+-----+------------------------+-------------------------+ only showing top 20 rows Inspect the DynamicFrame that contains rows where ID > 10 +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 11| 0| fax| 202-225-6328| | 11| 1| phone| 202-225-4576| | 11| 2| twitter| RepTrentFranks| | 12| 0| fax| 202-225-6328| | 12| 1| phone| 202-225-4576| | 12| 2| twitter| RepTrentFranks| | 13| 0| fax| 202-225-6328| | 13| 1| phone| 202-225-4576| | 13| 2| twitter| RepTrentFranks| | 14| 0| fax| 202-225-6328| | 14| 1| phone| 202-225-4576| | 14| 2| twitter| RepTrentFranks| | 15| 0| fax| 202-225-6328| | 15| 1| phone| 202-225-4576| | 15| 2| twitter| RepTrentFranks| | 16| 0| fax| 202-225-6328| | 16| 1| phone| 202-225-4576| | 16| 2| twitter| RepTrentFranks| | 17| 0| fax| 202-225-6328| | 17| 1| phone| 202-225-4576| +---+-----+------------------------+-------------------------+ only showing top 20 rows Inspect the merged DynamicFrame that contains the combined rows +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 1| 0| fax| 202-225-3307| | 1| 1| phone| 202-225-5731| | 20| 0| fax| 202-225-5604| | 20| 1| phone| 202-225-6536| | 20| 2| twitter| USRepLong| +---+-----+------------------------+-------------------------+ ``` ## relationalize **`relationalize(root_table_name, staging_path, options, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** 将 `DynamicFrame` 转换为适用于关系数据库的形式。将数据从 DynamoDB 等 NoSQL 环境移动到 MySQL 等关系数据库时，对 `DynamicFrame` 进行关系化尤其有用。该转换将通过取消嵌套列的嵌套并透视数组列来生成帧列表。可使用在取消嵌套阶段生成的联接键将透视数组列联接到根表。 + `root_table_name` – 根表的名称。 + `staging_path` – 要将 CSV 格式的透视表分区存储到的路径（可选）。从该路径读取透视表。 + `options` – 可选参数的词典。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与此转换的错误报告关联的字符串 (可选)。 + `stageThreshold` – 此转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 + `totalThreshold` – 此转换之前及转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 ### 示例：使用 relatialize 在 `DynamicFrame` 中展平嵌套架构此代码示例使用 `relationalize` 方法将嵌套架构展平为适用于关系数据库的形式。 **示例数据集** 该示例通过以下架构使用了名为 `legislators_combined` 的 `DynamicFrame`。`legislators_combined` 有多个嵌套字段，例如 `links`、`images` 和 `contact_details`，这些字段将通过 `relationalize` 转换进行展平。 ``` root |-- role: string |-- seats: int |-- org_name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- type: string |-- sort_name: string |-- area_id: string |-- images: array | |-- element: struct | | |-- url: string |-- on_behalf_of_id: string |-- other_names: array | |-- element: struct | | |-- note: string | | |-- name: string | | |-- lang: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- name: string |-- birth_date: string |-- organization_id: string |-- gender: string |-- classification: string |-- legislative_period_id: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- image: string |-- given_name: string |-- start_date: string |-- family_name: string |-- id: string |-- death_date: string |-- end_date: string ``` **示例代码** ``` # Example: Use relationalize to flatten # a nested schema into a format that fits # into a relational database. # Replace DOC-EXAMPLE-S3-BUCKET/tmpDir with your own location. from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Apply relationalize and inspect new tables legislators_relationalized = legislators_combined.relationalize( "l_root", "s3://DOC-EXAMPLE-BUCKET/tmpDir" ) legislators_relationalized.keys() # Compare the schema of the contact_details # nested field to the new relationalized table that # represents it legislators_combined.select_fields("contact_details").printSchema() legislators_relationalized.select("l_root_contact_details").toDF().where( "id = 10 or id = 75" ).orderBy(["id", "index"]).show() ``` #### Output 以下输出可让您将名为 `contact_details` 的嵌套字段的架构与 `relationalize` 转换创建的表进行比较。请注意，表记录可使用名为 `id` 的外键和表示数组位置的 `index` 列链接回主表。 ``` dict_keys(['l_root', 'l_root_images', 'l_root_links', 'l_root_other_names', 'l_root_contact_details', 'l_root_identifiers']) root |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 10| 0| fax| 202-225-4160| | 10| 1| phone| 202-225-3436| | 75| 0| fax| 202-225-6791| | 75| 1| phone| 202-225-2861| | 75| 2| twitter| RepSamFarr| +---+-----+------------------------+-------------------------+ ``` ## rename\$1field **`rename_field(oldName, newName, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** 重命名此 `DynamicFrame` 中的一个字段并返回包含该重命名字段的新的 `DynamicFrame`。 + `oldName` – 要重命名的节点的完整路径。如果旧名称中包含点，则 `RenameField` 将不起作用，除非使用反引号（```）将其引起来。例如，要将 `this.old.name` 替换为 `thisNewName`，应按如下方式调用 rename\$1field。 ``` newDyF = oldDyF.rename_field("`this.old.name`", "thisNewName") ``` + `newName` – 新名称，作为完整路径。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与此转换的错误报告关联的字符串 (可选)。 + `stageThreshold` – 此转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 + `totalThreshold` – 此转换之前及转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 ### 示例：使用 rename\$1field 重命名 `DynamicFrame` 中的字段此代码示例可使用 `rename_field` 方法重命名 `DynamicFrame` 中的字段。请注意，该示例可使用方法链同时重命名多个字段。 **注意** 要访问本示例中使用的数据集，请参阅 [代码示例：对数据进行联接和关系化](aws-glue-programming-python-samples-legislators.md) 并按照 [步骤 1：爬取 Amazon S3 存储桶中的数据](aws-glue-programming-python-samples-legislators.md#aws-glue-programming-python-samples-legislators-crawling) 中的说明进行操作。 **示例代码** ``` # Example: Use rename_field to rename fields # in a DynamicFrame from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Inspect the original orgs schema orgs = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="organizations_json" ) print("Original orgs schema: ") orgs.printSchema() # Rename fields and view the new schema orgs = orgs.rename_field("id", "org_id").rename_field("name", "org_name") print("New orgs schema with renamed fields: ") orgs.printSchema() ``` #### Output ``` Original orgs schema: root |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- id: string |-- classification: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- image: string |-- seats: int |-- type: string New orgs schema with renamed fields: root |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- classification: string |-- org_id: string |-- org_name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- image: string |-- seats: int |-- type: string ``` ## resolveChoice **`resolveChoice(specs = None, choice = "" , database = None , table_name = None , transformation_ctx="", info="", stageThreshold=0, totalThreshold=0, catalog_id = None)`** 解析此 `DynamicFrame` 内的一个选择类型并返回新的 `DynamicFrame`。 + `specs` – 要解析的特定歧义列表，每个歧义均采用元组形式：`(field_path, action)`。可通过两种方式使用 `resolveChoice`。第一种是使用 `specs` 参数指定一系列特定字段以及如何解析它们。`resolveChoice` 的另一种模式是使用 `choice` 参数为所有 `ChoiceTypes` 指定单个解析方法。 `specs` 的值被指定为由 `(field_path, action)` 对组成的元组。`field_path` 值标识特定歧义元素，`action` 值标识相应解析。可能的操作如下： + `cast:type` – 尝试将所有值转换为指定的类型。例如：`cast:int`。 + `make_cols` – 将每个不同的类型转换为名为 `columnName_type` 的列。通过展平数据来解析潜在的歧义。例如，如果 `columnA` 是 `int` 或 `string`，则解析就是在结果 `DynamicFrame` 中生成名为 `columnA_int` 和 `columnA_string` 的两个列。 + `make_struct` – 使用 `struct` 表示数据，解析潜在的歧义。例如，如果某个列中的数据是 `int` 或 `string`，则使用 `make_struct` 操作会在结果 `DynamicFrame` 中生成结构列。每个结构都包含 `int` 和 `string`。 + `project:type` – 将所有数据投影到可能的数据类型之一，解析潜在的歧义。例如，如果某个列中的数据是 `int` 或 `string`，则使用 `project:string` 操作会在结果 `DynamicFrame` 中生成一个列，其中所有 `int` 值都已转换为字符串。如果 `field_path` 识别到数组，则在数组名称后放置一个空的方括号可避免歧义。例如，假设您正在使用结构如下的数据： ``` "myList": [ { "price": 100.00 }, { "price": "$100.00" } ] ``` 可以通过将 `field_path` 设置为 `"myList[].price"`、将 `action` 设置为 `"cast:double"` 来选择价格的数字而非字符串版本。 **注意** 只能使用 `specs` 和 `choice` 参数之一。如果 `specs` 参数不为 `None`，则 `choice` 参数必须为空字符串。反过来，如果 `choice` 不为空字符串，则 `specs` 参数必须为 `None`。 + `choice` – 为所有 `ChoiceTypes` 指定单个解析方法。这可以在运行前不知道 `ChoiceTypes` 的完整列表的情况下使用。除了之前为 `specs` 列出的操作外，此参数还支持以下操作： + `match_catalog` – 尝试将每个 `ChoiceType` 转换为指定数据目录表中的对应类型。 + `database` – 与 `match_catalog` 操作一起使用的数据目录数据库。 + `table_name` – 与 `match_catalog` 操作一起使用的数据目录表。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与此转换的错误报告关联的字符串 (可选)。 + `stageThreshold` – 此转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 + `totalThreshold` – 此转换之前及转换过程中遇到的将导致过程出错的错误数（可选）。默认为零，表示此过程应该不会出错。 + `catalog_id` – 正在访问的数据目录的目录 ID（数据目录的账户 ID）。如果设置为 `None`（默认值），它使用调用账户的目录 ID。 ### 示例：使用 resolveChoice 处理包含多种类型的列此代码示例使用 `resolveChoice` 方法来指定如何处理包含多种类型值的 `DynamicFrame` 列。该示例演示了处理不同类型的列的两种常用方法： + 将该列转换为单一数据类型。 + 在单独的列中保留所有类型。 **示例数据集** **注意** 要访问本示例中使用的数据集，请参阅 [代码示例：使用 ResolveChoice、Lambda 和 ApplyMapping 进行数据准备](aws-glue-programming-python-samples-medicaid.md) 并按照 [步骤 1：爬取 Amazon S3 存储桶中的数据](aws-glue-programming-python-samples-medicaid.md#aws-glue-programming-python-samples-medicaid-crawling) 中的说明进行操作。该示例通过以下架构使用了名为 `medicare` 的 `DynamicFrame`： ``` root |-- drg definition: string |-- provider id: choice | |-- long | |-- string |-- provider name: string |-- provider street address: string |-- provider city: string |-- provider state: string |-- provider zip code: long |-- hospital referral region description: string |-- total discharges: long |-- average covered charges: string |-- average total payments: string |-- average medicare payments: string ``` **示例代码** ``` # Example: Use resolveChoice to handle # a column that contains multiple types from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Load the input data and inspect the "provider id" column medicare = glueContext.create_dynamic_frame.from_catalog( database="payments", table_name="medicare_hospital_provider_csv" ) print("Inspect the provider id column:") medicare.toDF().select("provider id").show() # Cast provider id to type long medicare_resolved_long = medicare.resolveChoice(specs=[("provider id", "cast:long")]) print("Schema after casting provider id to type long:") medicare_resolved_long.printSchema() medicare_resolved_long.toDF().select("provider id").show() # Create separate columns # for each provider id type medicare_resolved_cols = medicare.resolveChoice(choice="make_cols") print("Schema after creating separate columns for each type:") medicare_resolved_cols.printSchema() medicare_resolved_cols.toDF().select("provider id_long", "provider id_string").show() ``` #### Output ``` Inspect the 'provider id' column: +-----------+ |provider id| +-----------+ | [10001,]| | [10005,]| | [10006,]| | [10011,]| | [10016,]| | [10023,]| | [10029,]| | [10033,]| | [10039,]| | [10040,]| | [10046,]| | [10055,]| | [10056,]| | [10078,]| | [10083,]| | [10085,]| | [10090,]| | [10092,]| | [10100,]| | [10103,]| +-----------+ only showing top 20 rows Schema after casting 'provider id' to type long: root |-- drg definition: string |-- provider id: long |-- provider name: string |-- provider street address: string |-- provider city: string |-- provider state: string |-- provider zip code: long |-- hospital referral region description: string |-- total discharges: long |-- average covered charges: string |-- average total payments: string |-- average medicare payments: string +-----------+ |provider id| +-----------+ | 10001| | 10005| | 10006| | 10011| | 10016| | 10023| | 10029| | 10033| | 10039| | 10040| | 10046| | 10055| | 10056| | 10078| | 10083| | 10085| | 10090| | 10092| | 10100| | 10103| +-----------+ only showing top 20 rows Schema after creating separate columns for each type: root |-- drg definition: string |-- provider id_string: string |-- provider id_long: long |-- provider name: string |-- provider street address: string |-- provider city: string |-- provider state: string |-- provider zip code: long |-- hospital referral region description: string |-- total discharges: long |-- average covered charges: string |-- average total payments: string |-- average medicare payments: string +----------------+------------------+ |provider id_long|provider id_string| +----------------+------------------+ | 10001| null| | 10005| null| | 10006| null| | 10011| null| | 10016| null| | 10023| null| | 10029| null| | 10033| null| | 10039| null| | 10040| null| | 10046| null| | 10055| null| | 10056| null| | 10078| null| | 10083| null| | 10085| null| | 10090| null| | 10092| null| | 10100| null| | 10103| null| +----------------+------------------+ only showing top 20 rows ``` ## select\$1fields **`select_fields(paths, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** 返回包含选定字段的新 `DynamicFrame`。 + `paths` – 字符串列表。每个字符串就是一个指向您要选择的顶层节点的路径。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与此转换的错误报告关联的字符串 (可选)。 + `stageThreshold` – 此转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 + `totalThreshold` – 此转换之前及转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 ### 示例：使用 select\$1fields 以利用选定字段创建新 `DynamicFrame` 以下代码示例展示了如何使用 `select_fields` 方法以利用从现有 `DynamicFrame` 中选定的字段列表来创建新 `DynamicFrame`。 **注意** 要访问本示例中使用的数据集，请参阅 [代码示例：对数据进行联接和关系化](aws-glue-programming-python-samples-legislators.md) 并按照 [步骤 1：爬取 Amazon S3 存储桶中的数据](aws-glue-programming-python-samples-legislators.md#aws-glue-programming-python-samples-legislators-crawling) 中的说明进行操作。 ``` # Example: Use select_fields to select specific fields from a DynamicFrame from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Create a DynamicFrame and view its schema persons = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="persons_json" ) print("Schema for the persons DynamicFrame:") persons.printSchema() # Create a new DynamicFrame with chosen fields names = persons.select_fields(paths=["family_name", "given_name"]) print("Schema for the names DynamicFrame, created with select_fields:") names.printSchema() names.toDF().show() ``` #### Output ``` Schema for the persons DynamicFrame: root |-- family_name: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- gender: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- sort_name: string |-- images: array | |-- element: struct | | |-- url: string |-- given_name: string |-- birth_date: string |-- id: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- death_date: string Schema for the names DynamicFrame: root |-- family_name: string |-- given_name: string +-----------+----------+ |family_name|given_name| +-----------+----------+ | Collins| Michael| | Huizenga| Bill| | Clawson| Curtis| | Solomon| Gerald| | Rigell| Edward| | Crapo| Michael| | Hutto| Earl| | Ertel| Allen| | Minish| Joseph| | Andrews| Robert| | Walden| Greg| | Kazen| Abraham| | Turner| Michael| | Kolbe| James| | Lowenthal| Alan| | Capuano| Michael| | Schrader| Kurt| | Nadler| Jerrold| | Graves| Tom| | McMillan| John| +-----------+----------+ only showing top 20 rows ``` ## simplify\$1ddb\$1json **`simplify_ddb_json(): DynamicFrame`** 简化 `DynamicFrame` 中的嵌套列，其具体位于 DynamoDB JSON 结构中，并返回一个新的简化 `DynamicFrame`。如果 List 类型中有多种类型或 Map 类型，则不会简化 List 中的元素。请注意，这是一种特定类型的转换，其行为与常规 `unnest` 转换不同，并且要求数据已存在于 DynamoDB JSON 结构中。有关更多信息，请参阅 [DynamoDB JSON](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Output.html#DataExport.Output.Data)。例如，使用 DynamoDB JSON 结构读取导出的架构可能如下所示： ``` root |-- Item: struct | |-- parentMap: struct | | |-- M: struct | | | |-- childMap: struct | | | | |-- M: struct | | | | | |-- appName: struct | | | | | | |-- S: string | | | | | |-- packageName: struct | | | | | | |-- S: string | | | | | |-- updatedAt: struct | | | | | | |-- N: string | |-- strings: struct | | |-- SS: array | | | |-- element: string | |-- numbers: struct | | |-- NS: array | | | |-- element: string | |-- binaries: struct | | |-- BS: array | | | |-- element: string | |-- isDDBJson: struct | | |-- BOOL: boolean | |-- nullValue: struct | | |-- NULL: boolean ``` `simplify_ddb_json()` 转换会将此转换为： ``` root |-- parentMap: struct | |-- childMap: struct | | |-- appName: string | | |-- packageName: string | | |-- updatedAt: string |-- strings: array | |-- element: string |-- numbers: array | |-- element: string |-- binaries: array | |-- element: string |-- isDDBJson: boolean |-- nullValue: null ``` ### 示例：使用 simplify\$1ddb\$1json 调用 DynamoDB JSON simplify 命令以下代码示例使用 `simplify_ddb_json` 方法来使用 AWS Glue DynamoDB 导出连接器、调用 DynamoDB JSON simplify 命令，以及打印分区数量。 **示例代码** ``` from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext() glueContext = GlueContext(sc) dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type = "dynamodb", connection_options = { 'dynamodb.export': 'ddb', 'dynamodb.tableArn': '', 'dynamodb.s3.bucket': '', 'dynamodb.s3.prefix': '', 'dynamodb.s3.bucketOwner': '' } ) simplified = dynamicFrame.simplify_ddb_json() print(simplified.getNumPartitions()) ``` ## spigot **`spigot(path, options={})`** 将示例记录写入指定的目标，以帮助您验证作业执行的转换。 + `path` – 要写入的目标的路径（必需）。 + `options` – 指定选项的键值对（可选）。`"topk"` 选项指定应写入第一条 `k` 记录。`"prob"` 选项指定选择任何给定记录的可能性（以十进制数字形式表示）。您可以在选择要写入的记录时使用它。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 ### 示例：使用 spigot 将 `DynamicFrame` 中的示例字段写入 Amazon S3 此代码示例使用 `spigot` 方法在应用了 `select_fields` 转换后将示例记录写入 Amazon S3 存储桶。 **示例数据集** **注意** 要访问本示例中使用的数据集，请参阅 [代码示例：对数据进行联接和关系化](aws-glue-programming-python-samples-legislators.md) 并按照 [步骤 1：爬取 Amazon S3 存储桶中的数据](aws-glue-programming-python-samples-legislators.md#aws-glue-programming-python-samples-legislators-crawling) 中的说明进行操作。该示例通过以下架构使用了名为 `persons` 的 `DynamicFrame`： ``` root |-- family_name: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- gender: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- sort_name: string |-- images: array | |-- element: struct | | |-- url: string |-- given_name: string |-- birth_date: string |-- id: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- death_date: string ``` **示例代码** ``` # Example: Use spigot to write sample records # to a destination during a transformation # from pyspark.context import SparkContext. # Replace DOC-EXAMPLE-BUCKET with your own location. from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Load table data into a DynamicFrame persons = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="persons_json" ) # Perform the select_fields on the DynamicFrame persons = persons.select_fields(paths=["family_name", "given_name", "birth_date"]) # Use spigot to write a sample of the transformed data # (the first 10 records) spigot_output = persons.spigot( path="s3://DOC-EXAMPLE-BUCKET", options={"topk": 10} ) # Example: Use spigot to write sample records # to a destination during a transformation # from pyspark.context import SparkContext. # Replace DOC-EXAMPLE-BUCKET with your own location. from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Load table data into a DynamicFrame persons = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="persons_json" ) # Perform the select_fields on the DynamicFrame persons = persons.select_fields(paths=["family_name", "given_name", "birth_date"]) # Use spigot to write a sample of the transformed data # (the first 10 records) spigot_output = persons.spigot( path="s3://DOC-EXAMPLE-BUCKET", options={"topk": 10} ) ``` #### Output 以下是 `spigot` 写入 Amazon S3 的数据示例。由于指定了示例代码 `options={"topk": 10}`，因此示例数据包含前 10 条记录。 ``` {"family_name":"Collins","given_name":"Michael","birth_date":"1944-10-15"} {"family_name":"Huizenga","given_name":"Bill","birth_date":"1969-01-31"} {"family_name":"Clawson","given_name":"Curtis","birth_date":"1959-09-28"} {"family_name":"Solomon","given_name":"Gerald","birth_date":"1930-08-14"} {"family_name":"Rigell","given_name":"Edward","birth_date":"1960-05-28"} {"family_name":"Crapo","given_name":"Michael","birth_date":"1951-05-20"} {"family_name":"Hutto","given_name":"Earl","birth_date":"1926-05-12"} {"family_name":"Ertel","given_name":"Allen","birth_date":"1937-11-07"} {"family_name":"Minish","given_name":"Joseph","birth_date":"1916-09-01"} {"family_name":"Andrews","given_name":"Robert","birth_date":"1957-08-04"} ``` ## split\$1fields **`split_fields(paths, name1, name2, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** 返回一个新的 `DynamicFrameCollection`，其中包含两个 `DynamicFrames`。第一个 `DynamicFrame` 包含所有已拆分的节点，第二个包含其余节点。 + `paths` – 字符串列表，每个字符串是到一个您要拆分为新的 `DynamicFrame` 的节点的完整路径。 + `name1` – 拆分的 `DynamicFrame` 的名称字符串。 + `name2` – 指定节点拆分后留存的 `DynamicFrame` 的名称字符串。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与此转换的错误报告关联的字符串 (可选)。 + `stageThreshold` – 此转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 + `totalThreshold` – 此转换之前及转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 ### 示例：使用 split\$1fields 将选定字段拆分为单独的 `DynamicFrame` 此代码示例使用 `split_fields` 方法将指定字段列表拆分为单独的 `DynamicFrame`。 **示例数据集** 该示例使用了集合 `legislators_relationalized` 中名为 `l_root_contact_details` 的 `DynamicFrame`。 `l_root_contact_details` 有以下架构和条目。 ``` root |-- id: long |-- index: int |-- contact_details.val.type: string |-- contact_details.val.value: string +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 1| 0| phone| 202-225-5265| | 1| 1| twitter| kathyhochul| | 2| 0| phone| 202-225-3252| | 2| 1| twitter| repjackyrosen| | 3| 0| fax| 202-225-1314| | 3| 1| phone| 202-225-3772| ... ``` **示例代码** ``` # Example: Use split_fields to split selected # fields into a separate DynamicFrame from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Load the input DynamicFrame and inspect its schema frame_to_split = legislators_relationalized.select("l_root_contact_details") print("Inspect the input DynamicFrame schema:") frame_to_split.printSchema() # Split id and index fields into a separate DynamicFrame split_fields_collection = frame_to_split.split_fields(["id", "index"], "left", "right") # Inspect the resulting DynamicFrames print("Inspect the schemas of the DynamicFrames created with split_fields:") split_fields_collection.select("left").printSchema() split_fields_collection.select("right").printSchema() ``` #### Output ``` Inspect the input DynamicFrame's schema: root |-- id: long |-- index: int |-- contact_details.val.type: string |-- contact_details.val.value: string Inspect the schemas of the DynamicFrames created with split_fields: root |-- id: long |-- index: int root |-- contact_details.val.type: string |-- contact_details.val.value: string ``` ## split\$1rows **`split_rows(comparison_dict, name1, name2, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** 将 `DynamicFrame` 中的一个或多个行拆分到新的 `DynamicFrame` 中。该方法可返回一个新的 `DynamicFrameCollection`，其中包含两个 `DynamicFrames`。第一个 `DynamicFrame` 包含所有已拆分的行，第二个包含其余行。 + `comparison_dict` – 一个词典，其中的键是到一个列的路径，值是另一个词典，用于将比较器映射到与该列值所比较的值。例如，`{"age": {">": 10, "<": 20}}` 拆分其年龄列中的值大于 10 但小于 20 的行。 + `name1` – 拆分的 `DynamicFrame` 的名称字符串。 + `name2` – 指定节点拆分后留存的 `DynamicFrame` 的名称字符串。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与此转换的错误报告关联的字符串 (可选)。 + `stageThreshold` – 此转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 + `totalThreshold` – 此转换之前及转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 ### 示例：使用 split\$1rows 拆分 `DynamicFrame` 中的行此代码示例使用 `split_rows` 方法根据 `id` 字段值拆分 `DynamicFrame` 中的行。 **示例数据集** 该示例使用了从集合 `legislators_relationalized` 中选择的名为 `l_root_contact_details` 的 `DynamicFrame`。 `l_root_contact_details` 有以下架构和条目。 ``` root |-- id: long |-- index: int |-- contact_details.val.type: string |-- contact_details.val.value: string +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 1| 0| phone| 202-225-5265| | 1| 1| twitter| kathyhochul| | 2| 0| phone| 202-225-3252| | 2| 1| twitter| repjackyrosen| | 3| 0| fax| 202-225-1314| | 3| 1| phone| 202-225-3772| | 3| 2| twitter| MikeRossUpdates| | 4| 0| fax| 202-225-1314| | 4| 1| phone| 202-225-3772| | 4| 2| twitter| MikeRossUpdates| | 5| 0| fax| 202-225-1314| | 5| 1| phone| 202-225-3772| | 5| 2| twitter| MikeRossUpdates| | 6| 0| fax| 202-225-1314| | 6| 1| phone| 202-225-3772| | 6| 2| twitter| MikeRossUpdates| | 7| 0| fax| 202-225-1314| | 7| 1| phone| 202-225-3772| | 7| 2| twitter| MikeRossUpdates| | 8| 0| fax| 202-225-1314| +---+-----+------------------------+-------------------------+ ``` **示例代码** ``` # Example: Use split_rows to split up # rows in a DynamicFrame based on value from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Retrieve the DynamicFrame to split frame_to_split = legislators_relationalized.select("l_root_contact_details") # Split up rows by ID split_rows_collection = frame_to_split.split_rows({"id": {">": 10}}, "high", "low") # Inspect the resulting DynamicFrames print("Inspect the DynamicFrame that contains IDs < 10") split_rows_collection.select("low").toDF().show() print("Inspect the DynamicFrame that contains IDs > 10") split_rows_collection.select("high").toDF().show() ``` #### Output ``` Inspect the DynamicFrame that contains IDs < 10 +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 1| 0| phone| 202-225-5265| | 1| 1| twitter| kathyhochul| | 2| 0| phone| 202-225-3252| | 2| 1| twitter| repjackyrosen| | 3| 0| fax| 202-225-1314| | 3| 1| phone| 202-225-3772| | 3| 2| twitter| MikeRossUpdates| | 4| 0| fax| 202-225-1314| | 4| 1| phone| 202-225-3772| | 4| 2| twitter| MikeRossUpdates| | 5| 0| fax| 202-225-1314| | 5| 1| phone| 202-225-3772| | 5| 2| twitter| MikeRossUpdates| | 6| 0| fax| 202-225-1314| | 6| 1| phone| 202-225-3772| | 6| 2| twitter| MikeRossUpdates| | 7| 0| fax| 202-225-1314| | 7| 1| phone| 202-225-3772| | 7| 2| twitter| MikeRossUpdates| | 8| 0| fax| 202-225-1314| +---+-----+------------------------+-------------------------+ only showing top 20 rows Inspect the DynamicFrame that contains IDs > 10 +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 11| 0| phone| 202-225-5476| | 11| 1| twitter| RepDavidYoung| | 12| 0| phone| 202-225-4035| | 12| 1| twitter| RepStephMurphy| | 13| 0| fax| 202-226-0774| | 13| 1| phone| 202-225-6335| | 14| 0| fax| 202-226-0774| | 14| 1| phone| 202-225-6335| | 15| 0| fax| 202-226-0774| | 15| 1| phone| 202-225-6335| | 16| 0| fax| 202-226-0774| | 16| 1| phone| 202-225-6335| | 17| 0| fax| 202-226-0774| | 17| 1| phone| 202-225-6335| | 18| 0| fax| 202-226-0774| | 18| 1| phone| 202-225-6335| | 19| 0| fax| 202-226-0774| | 19| 1| phone| 202-225-6335| | 20| 0| fax| 202-226-0774| | 20| 1| phone| 202-225-6335| +---+-----+------------------------+-------------------------+ only showing top 20 rows ``` ## unbox **`unbox(path, format, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0, **options)`** 取消装箱（重新格式化）`DynamicFrame` 中的一个字符串字段并返回包含已取消装箱 `DynamicRecords` 的新的 `DynamicFrame`。一个 `DynamicRecord` 表示 `DynamicFrame` 中的一条逻辑记录。它类似于 Apache Spark `DataFrame` 中的一行，但其具有自描述性，可用于不符合固定架构的数据。 + `path` – 要取消装箱的字符串节点的完整路径。 + `format` – 格式规范（可选）。您可将其用于 Amazon S3 或支持多种格式的 AWS Glue 连接。相关受支持的格式，请参阅 [AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与此转换的错误报告关联的字符串 (可选)。 + `stageThreshold` – 此转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 + `totalThreshold` – 此转换之前及转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 + `options` – 下列一个或多个： + `separator` – 包含分隔符字符的字符串。 + `escaper` – 包含转义字符的字符串。 + `skipFirst` – 指示是否跳过第一个实例的布尔值。 + `withSchema` - 包含节点架构的 JSON 表示形式的字符串。架构的 JSON 表示格式由 `StructType.json()` 的输出定义。 + `withHeader` – 指示是否包括标头的布尔值。 ### 示例：使用 unbox 将字符串字段拆开为结构此代码示例使用 `unbox` 方法将 `DynamicFrame` 中的字符串字段*拆开*或重新格式化为结构类型的字段。 **示例数据集** 该示例通过以下架构和条目使用了名为 `DynamicFrame` 的 `mapped_with_string`。请注意名为 `AddressString` 的字段。这是拆开为结构示例中的字段。 ``` root |-- Average Total Payments: string |-- AddressString: string |-- Average Covered Charges: string |-- DRG Definition: string |-- Average Medicare Payments: string |-- Hospital Referral Region Description: string |-- Address: struct | |-- Zip.Code: string | |-- City: string | |-- Array: array | | |-- element: string | |-- State: string | |-- Street: string |-- Provider Id: string |-- Total Discharges: string |-- Provider Name: string +----------------------+--------------------+-----------------------+--------------------+-------------------------+------------------------------------+--------------------+-----------+----------------+--------------------+ |Average Total Payments| AddressString|Average Covered Charges| DRG Definition|Average Medicare Payments|Hospital Referral Region Description| Address|Provider Id|Total Discharges| Provider Name| +----------------------+--------------------+-----------------------+--------------------+-------------------------+------------------------------------+--------------------+-----------+----------------+--------------------+ | $5777.24|{"Street": "1108 ...| $32963.07|039 - EXTRACRANIA...| $4763.73| AL - Dothan|[36301, DOTHAN, [...| 10001| 91|SOUTHEAST ALABAMA...| | $5787.57|{"Street": "2505 ...| $15131.85|039 - EXTRACRANIA...| $4976.71| AL - Birmingham|[35957, BOAZ, [25...| 10005| 14|MARSHALL MEDICAL ...| | $5434.95|{"Street": "205 M...| $37560.37|039 - EXTRACRANIA...| $4453.79| AL - Birmingham|[35631, FLORENCE,...| 10006| 24|ELIZA COFFEE MEMO...| | $5417.56|{"Street": "50 ME...| $13998.28|039 - EXTRACRANIA...| $4129.16| AL - Birmingham|[35235, BIRMINGHA...| 10011| 25| ST VINCENT'S EAST| ... ``` **示例代码** ``` # Example: Use unbox to unbox a string field # into a struct in a DynamicFrame from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) unboxed = mapped_with_string.unbox("AddressString", "json") unboxed.printSchema() unboxed.toDF().show() ``` #### Output ``` root |-- Average Total Payments: string |-- AddressString: struct | |-- Street: string | |-- City: string | |-- State: string | |-- Zip.Code: string | |-- Array: array | | |-- element: string |-- Average Covered Charges: string |-- DRG Definition: string |-- Average Medicare Payments: string |-- Hospital Referral Region Description: string |-- Address: struct | |-- Zip.Code: string | |-- City: string | |-- Array: array | | |-- element: string | |-- State: string | |-- Street: string |-- Provider Id: string |-- Total Discharges: string |-- Provider Name: string +----------------------+--------------------+-----------------------+--------------------+-------------------------+------------------------------------+--------------------+-----------+----------------+--------------------+ |Average Total Payments| AddressString|Average Covered Charges| DRG Definition|Average Medicare Payments|Hospital Referral Region Description| Address|Provider Id|Total Discharges| Provider Name| +----------------------+--------------------+-----------------------+--------------------+-------------------------+------------------------------------+--------------------+-----------+----------------+--------------------+ | $5777.24|[1108 ROSS CLARK ...| $32963.07|039 - EXTRACRANIA...| $4763.73| AL - Dothan|[36301, DOTHAN, [...| 10001| 91|SOUTHEAST ALABAMA...| | $5787.57|[2505 U S HIGHWAY...| $15131.85|039 - EXTRACRANIA...| $4976.71| AL - Birmingham|[35957, BOAZ, [25...| 10005| 14|MARSHALL MEDICAL ...| | $5434.95|[205 MARENGO STRE...| $37560.37|039 - EXTRACRANIA...| $4453.79| AL - Birmingham|[35631, FLORENCE,...| 10006| 24|ELIZA COFFEE MEMO...| | $5417.56|[50 MEDICAL PARK ...| $13998.28|039 - EXTRACRANIA...| $4129.16| AL - Birmingham|[35235, BIRMINGHA...| 10011| 25| ST VINCENT'S EAST| | $5658.33|[1000 FIRST STREE...| $31633.27|039 - EXTRACRANIA...| $4851.44| AL - Birmingham|[35007, ALABASTER...| 10016| 18|SHELBY BAPTIST ME...| | $6653.80|[2105 EAST SOUTH ...| $16920.79|039 - EXTRACRANIA...| $5374.14| AL - Montgomery|[36116, MONTGOMER...| 10023| 67|BAPTIST MEDICAL C...| | $5834.74|[2000 PEPPERELL P...| $11977.13|039 - EXTRACRANIA...| $4761.41| AL - Birmingham|[36801, OPELIKA, ...| 10029| 51|EAST ALABAMA MEDI...| | $8031.12|[619 SOUTH 19TH S...| $35841.09|039 - EXTRACRANIA...| $5858.50| AL - Birmingham|[35233, BIRMINGHA...| 10033| 32|UNIVERSITY OF ALA...| | $6113.38|[101 SIVLEY RD, H...| $28523.39|039 - EXTRACRANIA...| $5228.40| AL - Huntsville|[35801, HUNTSVILL...| 10039| 135| HUNTSVILLE HOSPITAL| | $5541.05|[1007 GOODYEAR AV...| $75233.38|039 - EXTRACRANIA...| $4386.94| AL - Birmingham|[35903, GADSDEN, ...| 10040| 34|GADSDEN REGIONAL ...| | $5461.57|[600 SOUTH THIRD ...| $67327.92|039 - EXTRACRANIA...| $4493.57| AL - Birmingham|[35901, GADSDEN, ...| 10046| 14|RIVERVIEW REGIONA...| | $5356.28|[4370 WEST MAIN S...| $39607.28|039 - EXTRACRANIA...| $4408.20| AL - Dothan|[36305, DOTHAN, [...| 10055| 45| FLOWERS HOSPITAL| | $5374.65|[810 ST VINCENT'S...| $22862.23|039 - EXTRACRANIA...| $4186.02| AL - Birmingham|[35205, BIRMINGHA...| 10056| 43|ST VINCENT'S BIRM...| | $5366.23|[400 EAST 10TH ST...| $31110.85|039 - EXTRACRANIA...| $4376.23| AL - Birmingham|[36207, ANNISTON,...| 10078| 21|NORTHEAST ALABAMA...| | $5282.93|[1613 NORTH MCKEN...| $25411.33|039 - EXTRACRANIA...| $4383.73| AL - Mobile|[36535, FOLEY, [1...| 10083| 15|SOUTH BALDWIN REG...| | $5676.55|[1201 7TH STREET ...| $9234.51|039 - EXTRACRANIA...| $4509.11| AL - Huntsville|[35609, DECATUR, ...| 10085| 27|DECATUR GENERAL H...| | $5930.11|[6801 AIRPORT BOU...| $15895.85|039 - EXTRACRANIA...| $3972.85| AL - Mobile|[36608, MOBILE, [...| 10090| 27| PROVIDENCE HOSPITAL| | $6192.54|[809 UNIVERSITY B...| $19721.16|039 - EXTRACRANIA...| $5179.38| AL - Tuscaloosa|[35401, TUSCALOOS...| 10092| 31|D C H REGIONAL ME...| | $4968.00|[750 MORPHY AVENU...| $10710.88|039 - EXTRACRANIA...| $3898.88| AL - Mobile|[36532, FAIRHOPE,...| 10100| 18| THOMAS HOSPITAL| | $5996.00|[701 PRINCETON AV...| $51343.75|039 - EXTRACRANIA...| $4962.45| AL - Birmingham|[35211, BIRMINGHA...| 10103| 33|BAPTIST MEDICAL C...| +----------------------+--------------------+-----------------------+--------------------+-------------------------+------------------------------------+--------------------+-----------+----------------+--------------------+ only showing top 20 rows ``` ## 联合 **`union(frame1, frame2, transformation_ctx = "", info = "", stageThreshold = 0, totalThreshold = 0)`** 联合两个 DynamicFrame。返回 DynamicFrame，其中包含来自两个输入 DynamicFrame 的所有记录。这种转换可能会从两个 DataFrame 与等效数据的合并中返回不同的结果。如果您需要 Spark DataFrame 联合行为，可以考虑使用 `toDF`。 + `frame1` – 第一个要联合的 DynamicFrame。 + `frame2` – 第二个要联合的 DynamicFrame。 + `transformation_ctx` –（可选）用于标识统计信息/状态信息的唯一字符串 + `info` –（可选）与转换中的错误关联的任何字符串 + `stageThreshold` –（可选）在处理出错之前转换中出现的最大错误数 + `totalThreshold` –（可选）在处理出错之前出现的最大总错误数 ## unnest **`unnest(transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** 取消嵌套 `DynamicFrame` 中的嵌套对象，使其成为顶级对象，并返回新的取消嵌套的 `DynamicFrame`。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与此转换的错误报告关联的字符串 (可选)。 + `stageThreshold` – 此转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 + `totalThreshold` – 此转换之前及转换过程中遇到的将导致过程出错的错误数（可选）。默认值为零，则表示进程不应出错。 ### 示例：使用 unnest 将嵌套字段转换为顶级字段此代码示例使用 `unnest` 方法将 `DynamicFrame` 中的所有嵌套字段展平为顶级字段。 **示例数据集** 该示例通过以下架构使用了名为 `mapped_medicare` 的 `DynamicFrame`。请注意，`Address` 字段是唯一包含嵌套数据的字段。 ``` root |-- Average Total Payments: string |-- Average Covered Charges: string |-- DRG Definition: string |-- Average Medicare Payments: string |-- Hospital Referral Region Description: string |-- Address: struct | |-- Zip.Code: string | |-- City: string | |-- Array: array | | |-- element: string | |-- State: string | |-- Street: string |-- Provider Id: string |-- Total Discharges: string |-- Provider Name: string ``` **示例代码** ``` # Example: Use unnest to unnest nested # objects in a DynamicFrame from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Unnest all nested fields unnested = mapped_medicare.unnest() unnested.printSchema() ``` #### Output ``` root |-- Average Total Payments: string |-- Average Covered Charges: string |-- DRG Definition: string |-- Average Medicare Payments: string |-- Hospital Referral Region Description: string |-- Address.Zip.Code: string |-- Address.City: string |-- Address.Array: array | |-- element: string |-- Address.State: string |-- Address.Street: string |-- Provider Id: string |-- Total Discharges: string |-- Provider Name: string ``` ## unnest\$1ddb\$1json 解除 `DynamicFrame` 中的嵌套列，其具体位于 DynamoDB JSON 结构中，并返回一个新的非嵌套 `DynamicFrame`。属于结构类型数组的列将不会被解除嵌套。请注意，这是一种特定类型的非嵌套转换，其行为与常规 `unnest` 转换不同，并且要求数据已存在于 DynamoDB JSON 结构中。有关更多信息，请参阅 [DynamoDB JSON](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Output.html#DataExport.Output.Data)。 **`unnest_ddb_json(transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与此转换的错误报告关联的字符串 (可选)。 + `stageThreshold` – 此转换过程中遇到的将导致过程出错的错误数 (可选，默认为零，表示此过程应该不会出错)。 + `totalThreshold` – 此转换之前及转换过程中遇到的将导致过程出错的错误数 (可选，默认为零，表示此过程应该不会出错)。例如，使用 DynamoDB JSON 结构读取导出的架构可能如下所示： ``` root |-- Item: struct | |-- ColA: struct | | |-- S: string | |-- ColB: struct | | |-- S: string | |-- ColC: struct | | |-- N: string | |-- ColD: struct | | |-- L: array | | | |-- element: null ``` `unnest_ddb_json()` 转换会将此转换为： ``` root |-- ColA: string |-- ColB: string |-- ColC: string |-- ColD: array | |-- element: null ``` 以下代码示例演示了如何使用 AWS Glue DynamoDB 导出连接器、调用 DynamoDB JSON 解除嵌套命令，以及打印分区数量： ``` import sys from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job from awsglue.utils import getResolvedOptions args = getResolvedOptions(sys.argv, ["JOB_NAME"]) glue_context= GlueContext(SparkContext.getOrCreate()) job = Job(glue_context) job.init(args["JOB_NAME"], args) dynamicFrame = glue_context.create_dynamic_frame.from_options( connection_type="dynamodb", connection_options={ "dynamodb.export": "ddb", "dynamodb.tableArn": "", "dynamodb.s3.bucket": "", "dynamodb.s3.prefix": "", "dynamodb.s3.bucketOwner": "", } ) unnested = dynamicFrame.unnest_ddb_json() print(unnested.getNumPartitions()) job.commit() ``` ## write **`write(connection_type, connection_options, format, format_options, accumulator_size)`** 从此 `DynamicFrame` 的 [GlueContext 类](aws-glue-api-crawler-pyspark-extensions-glue-context.md) 获得指定连接类型的 [DataSink(object)](aws-glue-api-crawler-pyspark-extensions-types.md#aws-glue-api-crawler-pyspark-extensions-types-awsglue-data-sink) 并将其用于格式化和写入此 `DynamicFrame` 的内容。返回按指定进行格式化和写入的新的 `DynamicFrame`。 + `connection_type` – 要使用的连接类型。有效值包括 `s3`、`mysql`、`postgresql`、`redshift`、`sqlserver` 和 `oracle`。 + `connection_options` – 要使用的连接选项（可选）。对于 `connection_type` 的 `s3`，将会定义 Amazon S3 路径。 ``` connection_options = {"path": "s3://aws-glue-target/temp"} ``` 对于 JDBC 连接，必须定义多个属性。请注意，数据库名称必须是 URL 的一部分。它可以选择性地包含在连接选项中。 **警告** 不建议在脚本中存储密码。请考虑使用 `boto3` 从 AWS Secrets Manager 或 AWS Glue Data Catalog 检索它们。 ``` connection_options = {"url": "jdbc-url/database", "user": "username", "password": passwordVariable,"dbtable": "table-name", "redshiftTmpDir": "s3-tempdir-path"} ``` + `format` – 格式规范（可选）。这用于 Amazon Simple Storage Service（Amazon S3）或支持多种格式的 AWS Glue 连接。有关支持的格式，请参阅 [AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。 + `format_options` – 指定格式的格式选项。有关支持的格式，请参阅 [AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。 + `accumulator_size` - 要使用的可累积大小（以字节为单位）（可选)。 ## – 错误 – + [assertErrorThreshold](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-assertErrorThreshold) + [errorsAsDynamicFrame](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-errorsAsDynamicFrame) + [errorsCount](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-errorsCount) + [stageErrorsCount](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-stageErrorsCount) ## assertErrorThreshold `assertErrorThreshold( )` – 创建此 `DynamicFrame` 的转换中的错误的资产。从底层 `DataFrame` 返回 `Exception`。 ## errorsAsDynamicFrame `errorsAsDynamicFrame( )` – 返回其中包含嵌套的错误记录的 `DynamicFrame`。 ### 示例：使用 errorsAsDynamicFrame 查看错误记录以下代码示例展示了如何使用 `errorsAsDynamicFrame` 方法查看 `DynamicFrame` 的错误记录。 **示例数据集** 该示例使用以下数据集，您可以将以下数据集作为 JSON 上传到 Amazon S3。请注意，第二条记录的格式有误。当您使用 SparkSQL 时，格式错误的数据通常会中断文件解析。但是，`DynamicFrame` 会识别格式错误的问题，并将格式错误的行转换为您能单独处理的错误记录。 ``` {"id": 1, "name": "george", "surname": "washington", "height": 178} {"id": 2, "name": "benjamin", "surname": "franklin", {"id": 3, "name": "alexander", "surname": "hamilton", "height": 171} {"id": 4, "name": "john", "surname": "jay", "height": 190} ``` **示例代码** ``` # Example: Use errorsAsDynamicFrame to view error records. # Replace s3://DOC-EXAMPLE-S3-BUCKET/error_data.json with your location. from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Create errors DynamicFrame, view schema errors = glueContext.create_dynamic_frame.from_options( "s3", {"paths": ["s3://DOC-EXAMPLE-S3-BUCKET/error_data.json"]}, "json" ) print("Schema of errors DynamicFrame:") errors.printSchema() # Show that errors only contains valid entries from the dataset print("errors contains only valid records from the input dataset (2 of 4 records)") errors.toDF().show() # View errors print("Errors count:", str(errors.errorsCount())) print("Errors:") errors.errorsAsDynamicFrame().toDF().show() # View error fields and error data error_record = errors.errorsAsDynamicFrame().toDF().head() error_fields = error_record["error"] print("Error fields: ") print(error_fields.asDict().keys()) print("\nError record data:") for key in error_fields.asDict().keys(): print("\n", key, ": ", str(error_fields[key])) ``` #### Output ``` Schema of errors DynamicFrame: root |-- id: int |-- name: string |-- surname: string |-- height: int errors contains only valid records from the input dataset (2 of 4 records) +---+------+----------+------+ | id| name| surname|height| +---+------+----------+------+ | 1|george|washington| 178| | 4| john| jay| 190| +---+------+----------+------+ Errors count: 1 Errors: +--------------------+ | error| +--------------------+ |[[ File "/tmp/20...| +--------------------+ Error fields: dict_keys(['callsite', 'msg', 'stackTrace', 'input', 'bytesread', 'source', 'dynamicRecord']) Error record data: callsite : Row(site=' File "/tmp/2060612586885849088", line 549, in \n sys.exit(main())\n File "/tmp/2060612586885849088", line 523, in main\n response = handler(content)\n File "/tmp/2060612586885849088", line 197, in execute_request\n result = node.execute()\n File "/tmp/2060612586885849088", line 103, in execute\n exec(code, global_dict)\n File "", line 10, in \n File "/opt/amazon/lib/python3.6/site-packages/awsglue/dynamicframe.py", line 625, in from_options\n format_options, transformation_ctx, push_down_predicate, **kwargs)\n File "/opt/amazon/lib/python3.6/site-packages/awsglue/context.py", line 233, in create_dynamic_frame_from_options\n source.setFormat(format, **format_options)\n', info='') msg : error in jackson reader stackTrace : com.fasterxml.jackson.core.JsonParseException: Unexpected character ('{' (code 123)): was expecting either valid name character (for unquoted name) or double-quote (for quoted) to start field name at [Source: com.amazonaws.services.glue.readers.BufferedStream@73492578; line: 3, column: 2] at com.fasterxml.jackson.core.JsonParser._constructError(JsonParser.java:1581) at com.fasterxml.jackson.core.base.ParserMinimalBase._reportError(ParserMinimalBase.java:533) at com.fasterxml.jackson.core.base.ParserMinimalBase._reportUnexpectedChar(ParserMinimalBase.java:462) at com.fasterxml.jackson.core.json.UTF8StreamJsonParser._handleOddName(UTF8StreamJsonParser.java:2012) at com.fasterxml.jackson.core.json.UTF8StreamJsonParser._parseName(UTF8StreamJsonParser.java:1650) at com.fasterxml.jackson.core.json.UTF8StreamJsonParser.nextToken(UTF8StreamJsonParser.java:740) at com.amazonaws.services.glue.readers.JacksonReader$$anonfun$hasNextGoodToken$1.apply(JacksonReader.scala:57) at com.amazonaws.services.glue.readers.JacksonReader$$anonfun$hasNextGoodToken$1.apply(JacksonReader.scala:57) at scala.collection.Iterator$$anon$9.next(Iterator.scala:162) at scala.collection.Iterator$$anon$16.hasNext(Iterator.scala:599) at scala.collection.Iterator$$anon$16.hasNext(Iterator.scala:598) at scala.collection.Iterator$class.foreach(Iterator.scala:891) at scala.collection.AbstractIterator.foreach(Iterator.scala:1334) at com.amazonaws.services.glue.readers.JacksonReader$$anonfun$1.apply(JacksonReader.scala:120) at com.amazonaws.services.glue.readers.JacksonReader$$anonfun$1.apply(JacksonReader.scala:116) at com.amazonaws.services.glue.DynamicRecordBuilder.handleErr(DynamicRecordBuilder.scala:209) at com.amazonaws.services.glue.DynamicRecordBuilder.handleErrorWithException(DynamicRecordBuilder.scala:202) at com.amazonaws.services.glue.readers.JacksonReader.nextFailSafe(JacksonReader.scala:116) at com.amazonaws.services.glue.readers.JacksonReader.next(JacksonReader.scala:109) at com.amazonaws.services.glue.readers.JSONReader.next(JSONReader.scala:247) at com.amazonaws.services.glue.hadoop.TapeHadoopRecordReaderSplittable.nextKeyValue(TapeHadoopRecordReaderSplittable.scala:103) at org.apache.spark.rdd.NewHadoopRDD$$anon$1.hasNext(NewHadoopRDD.scala:230) at org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37) at scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:409) at scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:409) at scala.collection.Iterator$$anon$13.hasNext(Iterator.scala:462) at scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:409) at scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:409) at scala.collection.Iterator$$anon$13.hasNext(Iterator.scala:462) at scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:409) at scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:409) at org.apache.spark.sql.execution.SparkPlan$$anonfun$2.apply(SparkPlan.scala:255) at org.apache.spark.sql.execution.SparkPlan$$anonfun$2.apply(SparkPlan.scala:247) at org.apache.spark.rdd.RDD$$anonfun$mapPartitionsInternal$1$$anonfun$apply$24.apply(RDD.scala:836) at org.apache.spark.rdd.RDD$$anonfun$mapPartitionsInternal$1$$anonfun$apply$24.apply(RDD.scala:836) at org.apache.spark.rdd.MapPartitionsRDD.compute(MapPartitionsRDD.scala:52) at org.apache.spark.rdd.RDD.computeOrReadCheckpoint(RDD.scala:324) at org.apache.spark.rdd.RDD.iterator(RDD.scala:288) at org.apache.spark.rdd.MapPartitionsRDD.compute(MapPartitionsRDD.scala:52) at org.apache.spark.rdd.RDD.computeOrReadCheckpoint(RDD.scala:324) at org.apache.spark.rdd.RDD.iterator(RDD.scala:288) at org.apache.spark.scheduler.ResultTask.runTask(ResultTask.scala:90) at org.apache.spark.scheduler.Task.run(Task.scala:121) at org.apache.spark.executor.Executor$TaskRunner$$anonfun$10.apply(Executor.scala:408) at org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1360) at org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:414) at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) at java.lang.Thread.run(Thread.java:750) input : bytesread : 252 source : dynamicRecord : Row(id=2, name='benjamin', surname='franklin') ``` ## DynamicFrame 综合示例以下示例演示了在基本 Glue 目录场景之外创建和使用 DynamicFrames 的各种方法。 ### 使用 SQL SELECT 查询从 PostgreSQL 加载此示例显示了如何使用自定义 SQL SELECT 查询从 PostgreSQL 数据库加载数据： ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) # Load specific data from PostgreSQL with custom query postgres_dyf = glueContext.create_dynamic_frame.from_options( connection_type="postgresql", connection_options={ "url": "jdbc:postgresql://your-postgres-host:5432/your-database", "user": "your-username", "password": "your-password", "dbtable": "(SELECT customer_id, customer_name, email FROM customers WHERE active = true) AS filtered_customers" } ) ``` ### 加载特定列避免全表扫描此示例演示了如何从大型数据库表中仅加载特定列： ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) # Load only specific columns from a large table selected_columns_dyf = glueContext.create_dynamic_frame.from_options( connection_type="mysql", connection_options={ "url": "jdbc:mysql://your-mysql-host:3306/your-database", "user": "your-username", "password": "your-password", "dbtable": "(SELECT order_id, customer_id FROM large_orders_table) AS selected_data" } ) # Alternative approach using column selection in query efficient_load_dyf = glueContext.create_dynamic_frame.from_options( connection_type="postgresql", connection_options={ "url": "jdbc:postgresql://your-postgres-host:5432/your-database", "user": "your-username", "password": "your-password", "query": "SELECT product_id, product_name FROM products WHERE category = 'electronics'" } ) ``` ### 通过 JDBC 连接进行行级筛选此示例显示了如何使用行级筛选从数据库表中仅加载特定行： ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) # Load filtered rows using WHERE clause filtered_rows_dyf = glueContext.create_dynamic_frame.from_options( connection_type="postgresql", connection_options={ "url": "jdbc:postgresql://your-postgres-host:5432/your-database", "user": "your-username", "password": "your-password", "dbtable": "(SELECT * FROM transactions WHERE transaction_date >= '2024-01-01' AND amount > 100) AS recent_large_transactions" } ) # Using partitionColumn for parallel loading with filtering partitioned_load_dyf = glueContext.create_dynamic_frame.from_options( connection_type="mysql", connection_options={ "url": "jdbc:mysql://your-mysql-host:3306/your-database", "user": "your-username", "password": "your-password", "dbtable": "sales_data", "partitionColumn": "sale_date", "lowerBound": "2024-01-01", "upperBound": "2024-12-31", "numPartitions": "10" } ) ``` ### 从内存中的 Python 数据创建 DynamicFrame 此示例演示了如何从 Python 列表、元组或字典创建 DynamicFrame： ``` from awsglue.context import GlueContext from awsglue.dynamicframe import DynamicFrame from pyspark.context import SparkContext from pyspark.sql import Row sc = SparkContext() glueContext = GlueContext(sc) # Method 1: From list of tuples data_tuples = [ ("John", "Doe", 30, "Engineer"), ("Jane", "Smith", 25, "Designer"), ("Bob", "Johnson", 35, "Manager") ] # Convert to RDD of Rows rdd = sc.parallelize([Row(first_name=row[0], last_name=row[1], age=row[2], job=row[3]) for row in data_tuples]) df = glueContext.spark_session.createDataFrame(rdd) dyf_from_tuples = DynamicFrame.fromDF(df, glueContext, "employees_from_tuples") # Method 2: From list of dictionaries data_dicts = [ {"product_id": 1, "product_name": "Laptop", "price": 999.99, "category": "Electronics"}, {"product_id": 2, "product_name": "Book", "price": 19.99, "category": "Education"}, {"product_id": 3, "product_name": "Chair", "price": 149.99, "category": "Furniture"} ] df_from_dicts = glueContext.spark_session.createDataFrame(data_dicts) dyf_from_dicts = DynamicFrame.fromDF(df_from_dicts, glueContext, "products_from_dicts") # Method 3: From nested data structures nested_data = [ { "customer_id": 1, "customer_info": { "name": "Alice Brown", "email": "alice@example.com" }, "orders": [ {"order_id": 101, "amount": 250.00}, {"order_id": 102, "amount": 175.50} ] } ] df_nested = glueContext.spark_session.createDataFrame(nested_data) dyf_nested = DynamicFrame.fromDF(df_nested, glueContext, "customers_with_orders") ``` ### 大型数据集性能优化处理大型数据集时，请考虑以下性能优化技术： ``` # Use partitioning for parallel reads large_table_dyf = glueContext.create_dynamic_frame.from_options( connection_type="postgresql", connection_options={ "url": "jdbc:postgresql://your-postgres-host:5432/your-database", "user": "your-username", "password": "your-password", "dbtable": "large_table", "partitionColumn": "id", "lowerBound": "1", "upperBound": "1000000", "numPartitions": "20" } ) # Use pushdown predicates to filter at source filtered_dyf = glueContext.create_dynamic_frame.from_options( connection_type="mysql", connection_options={ "url": "jdbc:mysql://your-mysql-host:3306/your-database", "user": "your-username", "password": "your-password", "dbtable": "transactions" }, push_down_predicate="transaction_date >= '2024-01-01'" ) ``` ## errorsCount `errorsCount( )` – 返回 `DynamicFrame` 中的错误总数。 ## stageErrorsCount `stageErrorsCount` – 返回生成此 `DynamicFrame` 的过程中发生的错误数。 # DynamicFrameCollection 类 `DynamicFrameCollection` 是 [DynamicFrame 类](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md) 对象的字段，在其中键是 `DynamicFrames` 的名称，值是 `DynamicFrame` 对象。 ## \$1\$1init\$1\$1 **`__init__(dynamic_frames, glue_ctx)`** + `dynamic_frames` – [DynamicFrame 类](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md) 对象的字典。 + `glue_ctx` – 一个 [GlueContext 类](aws-glue-api-crawler-pyspark-extensions-glue-context.md) 对象。 ## 键 `keys( )` – 返回此集合中的键的列表，通常由相应的 `DynamicFrame` 值的名称组成。 ## 值 `values(key)` – 返回此集合中的 `DynamicFrame` 值的列表。 ## Select **`select(key)`** 返回与指定键对应的 `DynamicFrame` (通常是 `DynamicFrame` 的名称)。 + `key` – `DynamicFrameCollection` 中的键，通常表示 `DynamicFrame` 的名称。 ## Map **`map(callable, transformation_ctx="")`** 使用传入函数根据此集合中的 `DynamicFrames` 创建并返回新的 `DynamicFrameCollection`。 + `callable` – 一个函数，它采用 `DynamicFrame` 以及指定转换上下文作为参数并返回一个 `DynamicFrame`。 + `transformation_ctx` – 要由可调用脚本使用的转换上下文 (可选)。 ## Flatmap **`flatmap(f, transformation_ctx="")`** 使用传入函数根据此集合中的 `DynamicFrames` 创建并返回新的 `DynamicFrameCollection`。 + `f` – 一个函数，它采用 `DynamicFrame` 作为参数并返回一个 `DynamicFrame` 或 `DynamicFrameCollection`。 + `transformation_ctx` – 要由函数使用的转换上下文 (可选)。 # DynamicFrameWriter 类 ## Methods + [\$1\$1init\$1\$1](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-writer-__init__) + [from\$1options](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-writer-from_options) + [from\$1catalog](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-writer-from_catalog) + [from\$1jdbc\$1conf](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-writer-from_jdbc_conf) ## \$1\$1init\$1\$1 **`__init__(glue_context)`** + `glue_context` – 要使用的 [GlueContext 类](aws-glue-api-crawler-pyspark-extensions-glue-context.md)。 ## from\$1options **`from_options(frame, connection_type, connection_options={}, format=None, format_options={}, transformation_ctx="")`** 使用指定的连接和格式编写一个 `DynamicFrame`。 + `frame` – 要编写的 `DynamicFrame`。 + `connection_type` – 连接类型。有效值包括 `s3`、`mysql`、`postgresql`、`redshift`、`sqlserver` 和 `oracle`。 + `connection_options` – 连接选项，例如路径和数据库表 (可选)。对于 `connection_type` 的 `s3`，将会定义 Amazon S3 路径。 ``` connection_options = {"path": "s3://aws-glue-target/temp"} ``` 对于 JDBC 连接，必须定义多个属性。请注意，数据库名称必须是 URL 的一部分。它可以选择性地包含在连接选项中。 **警告** 不建议在脚本中存储密码。请考虑使用 `boto3` 从 AWS Secrets Manager 或 AWS Glue Data Catalog 检索它们。 ``` connection_options = {"url": "jdbc-url/database", "user": "username", "password": passwordVariable,"dbtable": "table-name", "redshiftTmpDir": "s3-tempdir-path"} ``` `dbtable` 属性是 JDBC 表的名称。对于在数据库中支持架构的 JDBC 数据存储，指定 `schema.table-name`。如果未提供架构，则使用默认的“public”架构。有关更多信息，请参阅 [AWS Glue for Spark 中适用于 ETL 的连接类型和选项](aws-glue-programming-etl-connect.md)。 + `format` – 格式规范（可选）。这用于 Amazon Simple Storage Service（Amazon S3）或支持多种格式的 AWS Glue 连接。有关支持的格式，请参阅 [AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。 + `format_options` – 指定格式的格式选项。有关支持的格式，请参阅 [AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 ## from\$1catalog **`from_catalog(frame, name_space, table_name, redshift_tmp_dir="", transformation_ctx="")`** 使用指定的目录数据库和表名称编写一个 `DynamicFrame`。 + `frame` – 要编写的 `DynamicFrame`。 + `name_space` – 要使用的数据库。 + `table_name` – 要使用的 `table_name`。 + `redshift_tmp_dir` – 要使用的 Amazon Redshift 临时目录（可选）。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 + `additional_options` 提供给 AWS Glue 的额外选项。要写入 Lake Formation 受管表，可以使用以下附加选项： + `transactionId` –（字符串）用于写入受管表的事务 ID。此事务无法提交或中止，否则写入将失败。 + `callDeleteObjectsOnCancel ` –（布尔值，可选）如果设置为 `true`（原定设置）、则在将对象写入 Amazon S3 后 AWS Glue 将自动调用 `DeleteObjectsOnCancel` API。有关更多信息，请参阅 *AWS Lake Formation 开发人员指南*中的 [DeleteObjectsOnCancel](https://docs.aws.amazon.com/lake-formation/latest/dg/aws-lake-formation-api-transactions-api.html#aws-lake-formation-api-transactions-api-DeleteObjectsOnCancel)。 **Example 示例：写入 Lake Formation 中的受管表** ``` txId = glueContext.start_transaction(read_only=False) glueContext.write_dynamic_frame.from_catalog( frame=dyf, database = db, table_name = tbl, transformation_ctx = "datasource0", additional_options={"transactionId":txId}) ... glueContext.commit_transaction(txId) ``` ## from\$1jdbc\$1conf **`from_jdbc_conf(frame, catalog_connection, connection_options={}, redshift_tmp_dir = "", transformation_ctx="")`** 使用指定的 JDBC 连接信息编写一个 `DynamicFrame`。 + `frame` – 要编写的 `DynamicFrame`。 + `catalog_connection` – 要使用的目录连接。 + `connection_options` – 连接选项，例如路径和数据库表 (可选)。 + `redshift_tmp_dir` – 要使用的 Amazon Redshift 临时目录（可选）。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 ## write\$1dynamic\$1frame 示例此示例结合使用 S3 的 `connection_type` 与 `connection_options` 中的 POSIX 路径参数，在本地写入输出，从而允许将数据写入本地存储。 ``` glueContext.write_dynamic_frame.from_options(\ frame = dyf_splitFields,\ connection_options = {'path': '/home/glue/GlueLocalOutput/'},\ connection_type = 's3',\ format = 'json') ``` # DynamicFrameReader 类 ## – 方法 – + [\$1\$1init\$1\$1](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-__init__) + [from\$1rdd](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-from_rdd) + [from\$1options](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-from_options) + [from\$1catalog](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-from_catalog) ## \$1\$1init\$1\$1 **`__init__(glue_context)`** + `glue_context` – 要使用的 [GlueContext 类](aws-glue-api-crawler-pyspark-extensions-glue-context.md)。 ## from\$1rdd **`from_rdd(data, name, schema=None, sampleRatio=None)`** 从弹性分布式数据集 (RDD) 读取 `DynamicFrame`。 + `data` – 要从中读取的数据集。 + `name` – 要从中读取的名称。 + `schema` – 要读取的架构 (可选)。 + `sampleRatio` – 采样率 (可选)。 ## from\$1options **`from_options(connection_type, connection_options={}, format=None, format_options={}, transformation_ctx="")`** 使用指定的连接和格式读取 `DynamicFrame`。 + `connection_type` – 连接类型。有效值包括 `s3`、`mysql`、`postgresql`、`redshift`、`sqlserver`、`oracle`、`dynamodb` 和 `snowflake`。 + `connection_options` – 连接选项，例如路径和数据库表 (可选)。有关更多信息，请参阅 [AWSGlue for Spark 中的 ETL 的连接类型和选项](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-connect.html)。对于 `connection_type` 的 `s3`，Amazon S3 路径在数组中定义。 ``` connection_options = {"paths": [ "s3://amzn-s3-demo-bucket/object_a", "s3://amzn-s3-demo-bucket/object_b"]} ``` 对于 JDBC 连接，必须定义多个属性。请注意，数据库名称必须是 URL 的一部分。它可以选择性地包含在连接选项中。 **警告** 不建议在脚本中存储密码。请考虑使用 `boto3` 从 AWS Secrets Manager 或 AWS Glue Data Catalog 检索它们。 ``` connection_options = {"url": "jdbc-url/database", "user": "username", "password": passwordVariable,"dbtable": "table-name", "redshiftTmpDir": "s3-tempdir-path"} ``` 对于执行并行读取的 JDBC 连接，您可以设置 hashfield 选项。例如： ``` connection_options = {"url": "jdbc-url/database", "user": "username", "password": passwordVariable,"dbtable": "table-name", "redshiftTmpDir": "s3-tempdir-path" , "hashfield": "month"} ``` 有关更多信息，请参阅 [从 JDBC 表并行读取](run-jdbc-parallel-read-job.md)。 + `format` – 格式规范（可选）。这用于 Amazon Simple Storage Service（Amazon S3）或支持多种格式的 AWS Glue 连接。有关支持的格式，请参阅 [AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。 + `format_options` – 指定格式的格式选项。有关支持的格式，请参阅 [AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 + `push_down_predicate` – 筛选分区，而不必列出并读取数据集中的所有文件。有关更多信息，请参阅[使用下推谓词进行预筛选](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html#aws-glue-programming-etl-partitions-pushdowns)。 ## from\$1catalog **`from_catalog(database, table_name, redshift_tmp_dir="", transformation_ctx="", push_down_predicate="", additional_options={})`** 使用指定的目录命名空间和表名称读取 `DynamicFrame`。 + `database` – 要从中读取的数据库。 + `table_name` – 要从中读取的表的名称。 + `redshift_tmp_dir` – 要使用的 Amazon Redshift 临时目录（如果不从 Redshift 中读取数据，则此项是可选的）。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 + `push_down_predicate` – 筛选分区，而不必列出并读取数据集中的所有文件。有关更多信息，请参阅 [使用下推谓词进行预筛选](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-pushdowns)。 + `additional_options` 提供给 AWS Glue 的额外选项。 + 要使用执行并行读取的 JDBC 连接，您可以设置 `hashfield`、`hashexpression` 或 `hashpartitions` 选项。例如： ``` additional_options = {"hashfield": "month"} ``` 有关更多信息，请参阅 [从 JDBC 表并行读取](run-jdbc-parallel-read-job.md)。 + 要传递目录表达式以根据索引列进行筛选，您可以查看 `catalogPartitionPredicate` 选项。 `catalogPartitionPredicate` – 要传递目录表达式以根据索引列进行筛选。这样会将筛选下推到服务器端。有关更多信息，请参阅 [AWS Glue 分区数据](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html)。请注意，`push_down_predicate` 和 `catalogPartitionPredicate` 使用不同的语法。前者使用 Spark SQL 标准语法，后者使用 JSQL 解析器。有关更多信息，请参阅 [管理 AWS Glue 中用于 ETL 输出的分区](aws-glue-programming-etl-partitions.md)。 # GlueContext 类包装 Apache Spark [SparkContext](https://spark.apache.org/docs/latest/api/java/org/apache/spark/SparkContext.html) 对象，从而提供与 Apache Spark 平台交互的机制。 ## \$1\$1init\$1\$1 **`__init__(sparkContext)`** + `sparkContext` – 要使用的 Apache Spark 上下文。 ## Creating + [\$1\$1init\$1\$1](#aws-glue-api-crawler-pyspark-extensions-glue-context-__init__) + [getSource](#aws-glue-api-crawler-pyspark-extensions-glue-context-get-source) + [create\$1dynamic\$1frame\$1from\$1rdd](#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_rdd) + [create\$1dynamic\$1frame\$1from\$1catalog](#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_catalog) + [create\$1dynamic\$1frame\$1from\$1options](#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options) + [create\$1sample\$1dynamic\$1frame\$1from\$1catalog](#aws-glue-api-crawler-pyspark-extensions-glue-context-create-sample-dynamic-frame-from-catalog) + [create\$1sample\$1dynamic\$1frame\$1from\$1options](#aws-glue-api-crawler-pyspark-extensions-glue-context-create-sample-dynamic-frame-from-options) + [add\$1ingestion\$1time\$1columns](#aws-glue-api-crawler-pyspark-extensions-glue-context-add-ingestion-time-columns) + [create\$1data\$1frame\$1from\$1catalog](#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-catalog) + [create\$1data\$1frame\$1from\$1options](#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-options) + [forEachBatch](#aws-glue-api-crawler-pyspark-extensions-glue-context-forEachBatch) ## getSource **`getSource(connection_type, transformation_ctx = "", **options)`** 创建一个 `DataSource` 对象，该对象可用于从外部来源读取 `DynamicFrames`。 + `connection_type` – 要使用的连接类型，例如 Amazon Simple Storage Service（Amazon S3）、Amazon Redshift 和 JDBC。有效值包括 `s3`、`mysql`、`postgresql`、`redshift`、`sqlserver`、`oracle` 和 `dynamodb`。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 + `options` – 可选名称/值对的集合。有关更多信息，请参阅 [AWS Glue for Spark 中适用于 ETL 的连接类型和选项](aws-glue-programming-etl-connect.md)。以下是使用 `getSource` 的示例。 ``` >>> data_source = context.getSource("file", paths=["/in/path"]) >>> data_source.setFormat("json") >>> myFrame = data_source.getFrame() ``` ## create\$1dynamic\$1frame\$1from\$1rdd **`create_dynamic_frame_from_rdd(data, name, schema=None, sample_ratio=None, transformation_ctx="")`** 返回一个从 Apache Spark 弹性分布式数据集 (RDD) 创建的 `DynamicFrame`。 + `data` – 要使用的数据源。 + `name` – 要使用的数据的名称。 + `schema` – 要使用的架构 (可选)。 + `sample_ratio` – 要使用的采样率 (可选)。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 ## create\$1dynamic\$1frame\$1from\$1catalog **`create_dynamic_frame_from_catalog(database, table_name, redshift_tmp_dir, transformation_ctx = "", push_down_predicate= "", additional_options = {}, catalog_id = None)`** 返回一个使用数据目录数据库和表名称创建的 `DynamicFrame`。使用此方法时，您可以通过指定的 AWS Glue Data Catalog 表中的表属性提供 `format_options`，并通过 `additional_options` 参数提供其他选项。 + `Database` – 要从中读取的数据库。 + `table_name` – 要从中读取的表的名称。 + `redshift_tmp_dir` – 要使用的 Amazon Redshift 临时目录（可选）。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 + `push_down_predicate` – 筛选分区，而不必列出并读取数据集中的所有文件。有关支持的来源和限制，请参阅[在 AWS Glue ETL 中使用下推优化读取](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-pushdown.html)。有关更多信息，请参阅 [使用下推谓词进行预筛选](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-pushdowns)。 + `additional_options` – 可选名称/值对的集合。可能选项包括 [AWS Glue for Spark 中适用于 ETL 的连接类型和选项](aws-glue-programming-etl-connect.md) 中列出的选项，但 `endpointUrl`、`streamName`、`bootstrap.servers`、`security.protocol`、`topicName`、`classification` 和 `delimiter` 除外。另一个支持的选项是 `catalogPartitionPredicate`： `catalogPartitionPredicate` – 要传递目录表达式以根据索引列进行筛选。这样会将筛选下推到服务器端。有关更多信息，请参阅 [AWS Glue 分区数据](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html)。请注意，`push_down_predicate` 和 `catalogPartitionPredicate` 使用不同的语法。前者使用 Spark SQL 标准语法，后者使用 JSQL 解析器。 + `catalog_id` – 正在访问的数据目录 ID（账户 ID）。当为 None 时，将使用调用方的默认账户 ID。 ## create\$1dynamic\$1frame\$1from\$1options **`create_dynamic_frame_from_options(connection_type, connection_options={}, format=None, format_options={}, transformation_ctx = "")`** 返回一个使用指定连接和格式创建的 `DynamicFrame`。 + `connection_type` – 连接类型，例如 Amazon S3、Amazon Redshift 和 JDBC。有效值包括 `s3`、`mysql`、`postgresql`、`redshift`、`sqlserver`、`oracle` 和 `dynamodb`。 + `connection_options` – 连接选项，例如路径和数据库表（可选）。对于 `s3` 的 `connection_type`，定义 Amazon S3 路径的列表。 ``` connection_options = {"paths": ["s3://aws-glue-target/temp"]} ``` 对于 JDBC 连接，必须定义多个属性。请注意，数据库名称必须是 URL 的一部分。它可以选择性地包含在连接选项中。 **警告** 不建议在脚本中存储密码。请考虑使用 `boto3` 从 AWS Secrets Manager 或 AWS Glue Data Catalog 检索它们。 ``` connection_options = {"url": "jdbc-url/database", "user": "username", "password": passwordVariable,"dbtable": "table-name", "redshiftTmpDir": "s3-tempdir-path"} ``` `dbtable` 属性是 JDBC 表的名称。对于在数据库中支持架构的 JDBC 数据存储，指定 `schema.table-name`。如果未提供架构，则使用默认的“public”架构。有关更多信息，请参阅 [AWS Glue for Spark 中适用于 ETL 的连接类型和选项](aws-glue-programming-etl-connect.md)。 + `format` – 格式规范。这用于 Amazon S3 或支持多种格式的 AWS Glue 连接。有关支持的格式，请参阅 [AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。 + `format_options` – 指定格式的格式选项。有关支持的格式，请参阅 [AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 + `push_down_predicate` – 筛选分区，而不必列出并读取数据集中的所有文件。有关支持的来源和限制，请参阅[在 AWS Glue ETL 中使用下推优化读取](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-pushdown.html)。有关更多信息，请参阅[使用下推谓词进行预筛选](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html#aws-glue-programming-etl-partitions-pushdowns)。 ## create\$1sample\$1dynamic\$1frame\$1from\$1catalog **`create_sample_dynamic_frame_from_catalog(database, table_name, num, redshift_tmp_dir, transformation_ctx = "", push_down_predicate= "", additional_options = {}, sample_options = {}, catalog_id = None)`** 返回一个使用数据目录数据库和表名称创建的 `DynamicFrame` 示例。`DynamicFrame` 只包含来自数据源的第一个 `num` 记录。 + `database` – 要从中读取的数据库。 + `table_name` – 要从中读取的表的名称。 + `num` – 返回的动态帧示例中的最大记录数。 + `redshift_tmp_dir` – 要使用的 Amazon Redshift 临时目录（可选）。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 + `push_down_predicate` – 筛选分区，而不必列出并读取数据集中的所有文件。有关更多信息，请参阅 [使用下推谓词进行预筛选](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-pushdowns)。 + `additional_options` – 可选名称/值对的集合。可能选项包括 [AWS Glue for Spark 中适用于 ETL 的连接类型和选项](aws-glue-programming-etl-connect.md) 中列出的选项，但 `endpointUrl`、`streamName`、`bootstrap.servers`、`security.protocol`、`topicName`、`classification` 和 `delimiter` 除外。 + `sample_options` – 控制采样行为的参数（可选）。Amazon S3 源的当前可用参数： + `maxSamplePartitions` – 采样将读取的最大分区数。默认值为 10 + `maxSampleFilesPerPartition` – 采样将在一个分区中读取的最大文件数。默认值为 10。这些参数有助于减少文件列表所耗费的时间。例如，假设数据集有 1000 个分区，每个分区有 10 个文件。如果您设置 `maxSamplePartitions` = 10，以及 `maxSampleFilesPerPartition` = 10，则取样不会列出所有 10,000 个文件，而是只列出并读取前 10 个分区，每个分区中的前 10 个文件：10\$110 = 共 100 个文件。 + `catalog_id` – 正在访问的数据目录的目录 ID（数据目录的账户 ID）。默认设置为 `None`。`None` 默认为服务中调用账户的目录 ID。 ## create\$1sample\$1dynamic\$1frame\$1from\$1options **`create_sample_dynamic_frame_from_options(connection_type, connection_options={}, num, sample_options={}, format=None, format_options={}, transformation_ctx = "")`** 返回一个使用指定连接和格式创建的 `DynamicFrame` 示例。`DynamicFrame` 只包含来自数据源的第一个 `num` 记录。 + `connection_type` – 连接类型，例如 Amazon S3、Amazon Redshift 和 JDBC。有效值包括 `s3`、`mysql`、`postgresql`、`redshift`、`sqlserver`、`oracle` 和 `dynamodb`。 + `connection_options` – 连接选项，例如路径和数据库表（可选）。有关更多信息，请参阅 [AWS Glue for Spark 中适用于 ETL 的连接类型和选项](aws-glue-programming-etl-connect.md)。 + `num` – 返回的动态帧示例中的最大记录数。 + `sample_options` – 控制采样行为的参数（可选）。Amazon S3 源的当前可用参数： + `maxSamplePartitions` – 采样将读取的最大分区数。默认值为 10 + `maxSampleFilesPerPartition` – 采样将在一个分区中读取的最大文件数。默认值为 10。这些参数有助于减少文件列表所耗费的时间。例如，假设数据集有 1000 个分区，每个分区有 10 个文件。如果您设置 `maxSamplePartitions` = 10，以及 `maxSampleFilesPerPartition` = 10，则取样不会列出所有 10,000 个文件，而是只列出并读取前 10 个分区，每个分区中的前 10 个文件：10\$110 = 共 100 个文件。 + `format` – 格式规范。这用于 Amazon S3 或支持多种格式的 AWS Glue 连接。有关支持的格式，请参阅 [AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。 + `format_options` – 指定格式的格式选项。有关支持的格式，请参阅 [AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 + `push_down_predicate` – 筛选分区，而不必列出并读取数据集中的所有文件。有关更多信息，请参阅 [使用下推谓词进行预筛选](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-pushdowns)。 ## add\$1ingestion\$1time\$1columns **`add_ingestion_time_columns(dataFrame, timeGranularity = "")`** 将提取时间列（例如 `ingest_year`、`ingest_month`、`ingest_day`、`ingest_hour`、`ingest_minute`）附加到输入 `DataFrame`。当您指定以 Amazon S3 为目标的数据目录表时，AWS Glue 生成的脚本中会自动生成此函数。此函数使用输出表上的提取时间列自动更新分区。这允许根据提取时间自动对输出数据进行分区，而不需要在输入数据中显示提取时间列。 + `dataFrame` – 提取时间列要附加到的 `dataFrame`。 + `timeGranularity` – 时间列的粒度。有效值为“`day`”、“`hour`”和“`minute`”。例如，如果“`hour`”传递到函数，原始 `dataFrame` 将附加“`ingest_year`”、“`ingest_month`”、“`ingest_day`”和“`ingest_hour`”时间列。在附加时间粒度列后返回数据框。示例： ``` dynamic_frame = DynamicFrame.fromDF(glueContext.add_ingestion_time_columns(dataFrame, "hour")) ``` ## create\$1data\$1frame\$1from\$1catalog **`create_data_frame_from_catalog(database, table_name, transformation_ctx = "", additional_options = {})`** 返回一个使用数据目录数据表中的信息创建的 `DataFrame`。 + `database` – 要从中读取数据的数据目录数据库。 + `table_name` – 要从中读取数据的数据目录表的名称。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 + `additional_options` – 可选名称/值对的集合。可能选项包括流式传输源的 [AWS Glue for Spark 中适用于 ETL 的连接类型和选项](aws-glue-programming-etl-connect.md) 中列出的选项，例如 `startingPosition`、`maxFetchTimeInMs` 和 `startingOffsets`。 + `useSparkDataSource` — 如果设置为 true，则强制 AWS Glue 使用本机 Spark 数据源 API 来读取表。Spark 数据源 API 支持以下格式：AVRO、二进制、CSV、JSON、ORC、Parquet 和文本。在数据目录表中，您可以使用 `classification` 属性指定格式。要了解有关 Spark 数据源 API 的更多信息，请参阅 [Apache Spark 官方文档](https://spark.apache.org/docs/latest/sql-data-sources-load-save-functions.html)。 `create_data_frame_from_catalog` 与 `useSparkDataSource` 结合使用具有以下优势： + 直接返回一个 `DataFrame` 并提供 `create_dynamic_frame.from_catalog().toDF()` 的替代项。 + 支持对本机格式实施 AWS Lake Formation 表级权限控制。 + 支持在没有 AWS Lake Formation 表级权限控制的情况下读取数据湖格式。有关更多信息，请参阅 [在 AWS Glue ETL 任务中使用数据湖框架](aws-glue-programming-etl-datalake-native-frameworks.md)。启用 `useSparkDataSource` 后，您还可以根据需要在 `additional_options` 中添加任一 [Spark 数据源选项](https://spark.apache.org/docs/latest/sql-data-sources.html)。AWSGlue 会将这些选项直接传递给 Spark 读取器。 + `useCatalogSchema` — 如果设置为 true，AWS Glue 会对生成的 `DataFrame` 应用此数据目录架构。否则，读取器会从数据中推断出架构。如果启用 `useCatalogSchema`，则必须同时将 `useSparkDataSource` 设置为 true。 **限制** 使用 `useSparkDataSource` 选项时请考虑以下限制： + 使用 `useSparkDataSource` 时，AWS Glue 会在与原始 Spark 会话不同的单独 Spark 会话中创建一个新的 `DataFrame`。 + Spark DataFrame 分区筛选不适用于以下 AWS Glue 功能。 + [作业书签](monitor-continuations.md) + [排除 Amazon S3 存储类](aws-glue-programming-etl-storage-classes.md#aws-glue-programming-etl-storage-classes-dynamic-frame) + [目录分区谓词](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-cat-predicates) 要对这些功能使用分区筛选，可以使用 AWS Glue 下推谓词。有关更多信息，请参阅 [使用下推谓词进行预筛选](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-pushdowns)。对未分区列的筛选不受影响。以下示例脚本演示了使用 `excludeStorageClasses` 选项执行分区筛选的错误方法。 ``` // Incorrect partition filtering using Spark filter with excludeStorageClasses read_df = glueContext.create_data_frame.from_catalog( database=database_name, table_name=table_name, additional_options = { "useSparkDataSource": True, "excludeStorageClasses" : ["GLACIER", "DEEP_ARCHIVE"] } ) // Suppose year and month are partition keys. // Filtering on year and month won't work, the filtered_df will still // contain data with other year/month values. filtered_df = read_df.filter("year == '2017 and month == '04' and 'state == 'CA'") ``` 以下示例脚本演示了使用下推谓词以使用 `excludeStorageClasses` 选项执行分区筛选的正确方法。 ``` // Correct partition filtering using the AWS Glue pushdown predicate // with excludeStorageClasses read_df = glueContext.create_data_frame.from_catalog( database=database_name, table_name=table_name, // Use AWS Glue pushdown predicate to perform partition filtering push_down_predicate = "(year=='2017' and month=='04')" additional_options = { "useSparkDataSource": True, "excludeStorageClasses" : ["GLACIER", "DEEP_ARCHIVE"] } ) // Use Spark filter only on non-partitioned columns filtered_df = read_df.filter("state == 'CA'") ``` **示例：使用 Spark 数据源读取器创建 CSV 表** ``` // Read a CSV table with '\t' as separator read_df = glueContext.create_data_frame.from_catalog( database=, table_name=, additional_options = {"useSparkDataSource": True, "sep": '\t'} ) ``` ## create\$1data\$1frame\$1from\$1options **`create_data_frame_from_options(connection_type, connection_options={}, format=None, format_options={}, transformation_ctx = "")`** 此 API 现已弃用。请改用 `getSource()` API。返回一个使用指定连接和格式创建的 `DataFrame`。仅将此函数与 AWS Glue 串流源结合使用。 + `connection_type` – 流式传输连接类型。有效值包括 `kinesis` 和 `kafka`。 + `connection_options` – 连接选项，不同于 Kinesis 和 Kafka。您可以在 [AWS Glue for Spark 中适用于 ETL 的连接类型和选项](aws-glue-programming-etl-connect.md) 找到每个流式传输数据源的所有连接选项列表。请注意流式传输连接选项的以下差异： + Kinesis 流式传输源需要 `streamARN`、`startingPosition`、`inferSchema` 和 `classification`。 + Kinesis 流式传输源需要 `connectionName`、`topicName`、`startingOffsets`、`inferSchema` 和 `classification`。 + `format` – 格式规范。这用于 Amazon S3 或支持多种格式的 AWS Glue 连接。有关所支持格式的信息，请参阅[AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。 + `format_options` – 指定格式的格式选项。有关所支持的格式选项的信息，请参阅[AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 Amazon Kinesis 流式传输源示例： ``` kinesis_options = { "streamARN": "arn:aws:kinesis:us-east-2:777788889999:stream/fromOptionsStream", "startingPosition": "TRIM_HORIZON", "inferSchema": "true", "classification": "json" } data_frame_datasource0 = glueContext.create_data_frame.from_options(connection_type="kinesis", connection_options=kinesis_options) ``` Kafka 流式传输源示例： ``` kafka_options = { "connectionName": "ConfluentKafka", "topicName": "kafka-auth-topic", "startingOffsets": "earliest", "inferSchema": "true", "classification": "json" } data_frame_datasource0 = glueContext.create_data_frame.from_options(connection_type="kafka", connection_options=kafka_options) ``` ## forEachBatch **`forEachBatch(frame, batch_function, options)`** 将传入的 `batch_function` 应用于从流式传输源读取的每个微批处理。 + `frame` – 包含当前微处理的 DataFrame。 + `batch_function` – 应用于每个微处理的函数。 + `options` – 键值对集合，其中包含有关如何处理微批处理的信息。以下选项为必填： + `windowSize` – 处理每个批处理所花费的时间量。 + `checkpointLocation` – 为流式传输 ETL 任务存储检查点的位置。 + `batchMaxRetries` – 在该批处理失败时重试的最大次数。默认值为 3。此选项仅适用于 Glue 版本 2.0 及更高版本。 **示例：** ``` glueContext.forEachBatch( frame = data_frame_datasource0, batch_function = processBatch, options = { "windowSize": "100 seconds", "checkpointLocation": "s3://kafka-auth-dataplane/confluent-test/output/checkpoint/" } ) def processBatch(data_frame, batchId): if (data_frame.count() > 0): datasource0 = DynamicFrame.fromDF( glueContext.add_ingestion_time_columns(data_frame, "hour"), glueContext, "from_data_frame" ) additionalOptions_datasink1 = {"enableUpdateCatalog": True} additionalOptions_datasink1["partitionKeys"] = ["ingest_yr", "ingest_mo", "ingest_day"] datasink1 = glueContext.write_dynamic_frame.from_catalog( frame = datasource0, database = "tempdb", table_name = "kafka-auth-table-output", transformation_ctx = "datasink1", additional_options = additionalOptions_datasink1 ) ``` ## 在 Amazon S3 中使用数据集 + [purge\$1table](#aws-glue-api-crawler-pyspark-extensions-glue-context-purge_table) + [purge\$1s3\$1path](#aws-glue-api-crawler-pyspark-extensions-glue-context-purge_s3_path) + [transition\$1table](#aws-glue-api-crawler-pyspark-extensions-glue-context-transition_table) + [transition\$1s3\$1path](#aws-glue-api-crawler-pyspark-extensions-glue-context-transition_s3_path) ## purge\$1table **`purge_table(catalog_id=None, database="", table_name="", options={}, transformation_ctx="")`** 从 Amazon S3 中删除指定目录的数据库和表的文件。如果删除一个分区中的所有文件，则也会从目录中删除该分区。我们不支持对注册到 Lake Formation 的表执行 purge\$1table 操作。如果您希望能恢复已删除的对象，可以在 Amazon S3 存储桶上启用[对象版本控制](https://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectVersioning.html)。如果从未启用对象版本控制的存储桶中删除一个对象，则无法恢复该对象。有关如何恢复已启用版本控制的存储桶中的已删除对象的更多信息，请参阅 AWS 支持知识中心中的[如何检索已删除的 Amazon S3 对象？](https://aws.amazon.com/premiumsupport/knowledge-center/s3-undelete-configuration/)。 + `catalog_id` – 正在访问的数据目录的目录 ID（数据目录的账户 ID）。默认设置为 `None`。`None` 默认为服务中调用账户的目录 ID。 + `database` – 要使用的数据库。 + `table_name` – 要使用的表的名称。 + `options` – 用于筛选要删除的文件和清单文件生成的选项。 + `retentionPeriod` – 指定保留文件的时段（以小时为单位）。比保留期更新的文件将被保留。默认情况下设置为 168 小时（7 天）。 + `partitionPredicate` – 满足此谓词的分区将被删除。这些分区中保留期内的文件不会被删除。设置为 `""` – 默认情况下为空。 + `excludeStorageClasses` – `excludeStorageClasses` 集中包含存储类的文件不会被删除。默认值是 `Set()` – 一个空集。 + `manifestFilePath` – 用于生成清单文件的可选路径。所有成功清除的文件将记录在 `Success.csv` 中，所有未能清除的文件将记录在 `Failed.csv` 中 + `transformation_ctx` – 要使用的转换上下文 (可选)。在清单文件路径中使用。 **Example** ``` glueContext.purge_table("database", "table", {"partitionPredicate": "(month=='march')", "retentionPeriod": 1, "excludeStorageClasses": ["STANDARD_IA"], "manifestFilePath": "s3://bucketmanifest/"}) ``` ## purge\$1s3\$1path **`purge_s3_path(s3_path, options={}, transformation_ctx="")`** 以递归方式从指定的 Amazon S3 路径中删除文件。如果您希望能恢复已删除的对象，可以在 Amazon S3 存储桶上启用[对象版本控制](https://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectVersioning.html)。如果从未启用对象版本控制的存储桶中删除一个对象，则无法恢复该对象。有关如何恢复已启用版本控制的存储桶中的已删除对象的更多信息，请参阅支持知识中心中的[如何检索已删除的 Amazon S3 对象？](https://aws.amazon.com/premiumsupport/knowledge-center/s3-undelete-configuration/)。 + `s3_path` – 要删除的文件 Amazon S3 中的路径，格式为 `s3:////` + `options` – 用于筛选要删除的文件和清单文件生成的选项。 + `retentionPeriod` – 指定保留文件的时段（以小时为单位）。比保留期更新的文件将被保留。默认情况下设置为 168 小时（7 天）。 + `excludeStorageClasses` – `excludeStorageClasses` 集中包含存储类的文件不会被删除。默认值是 `Set()` – 一个空集。 + `manifestFilePath` – 用于生成清单文件的可选路径。所有成功清除的文件将记录在 `Success.csv` 中，所有未能清除的文件将记录在 `Failed.csv` 中 + `transformation_ctx` – 要使用的转换上下文 (可选)。在清单文件路径中使用。 **Example** ``` glueContext.purge_s3_path("s3://bucket/path/", {"retentionPeriod": 1, "excludeStorageClasses": ["STANDARD_IA"], "manifestFilePath": "s3://bucketmanifest/"}) ``` ## transition\$1table **`transition_table(database, table_name, transition_to, options={}, transformation_ctx="", catalog_id=None)`** 为指定目录的数据库和表转换存储在 Amazon S3 上的文件的存储类。可以在任意两个存储类之间转换。对于 `GLACIER` 和 `DEEP_ARCHIVE` 存储类，您可以转换到这些类。但您可以使用 `S3 RESTORE` 从 `GLACIER` 和 `DEEP_ARCHIVE` 存储类进行转换。如果您要运行从 Amazon S3 读取文件或分区的 AWS Glue ETL 任务，则可以排除某些 Amazon S3 存储类类型。有关更多信息，请参阅[排除 Amazon S3 存储类](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-storage-classes.html)。 + `database` – 要使用的数据库。 + `table_name` – 要使用的表的名称。 + `transition_to` – 要切换到的 [Amazon S3 存储类](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/s3/model/StorageClass.html)。 + `options` – 用于筛选要删除的文件和清单文件生成的选项。 + `retentionPeriod` – 指定保留文件的时段（以小时为单位）。比保留期更新的文件将被保留。默认情况下设置为 168 小时（7 天）。 + `partitionPredicate` – 将转换满足此谓词的分区。这些分区中保留期内的文件不会被转换。设置为 `""` – 默认情况下为空。 + `excludeStorageClasses` – `excludeStorageClasses` 集中包含存储类的文件不会被转换。默认值是 `Set()` – 一个空集。 + `manifestFilePath` – 用于生成清单文件的可选路径。所有成功转换的文件将记录在 `Success.csv` 中，所有未能转换的文件将记录在 `Failed.csv` 中 + `accountId` – 要运行转换的 Amazon Web Services 账户 ID。对于此转换是必需的。 + `roleArn` – 要运行转换的 AWS 角色。对于此转换是必需的。 + `transformation_ctx` – 要使用的转换上下文 (可选)。在清单文件路径中使用。 + `catalog_id` – 正在访问的数据目录的目录 ID（数据目录的账户 ID）。默认设置为 `None`。`None` 默认为服务中调用账户的目录 ID。 **Example** ``` glueContext.transition_table("database", "table", "STANDARD_IA", {"retentionPeriod": 1, "excludeStorageClasses": ["STANDARD_IA"], "manifestFilePath": "s3://bucketmanifest/", "accountId": "12345678901", "roleArn": "arn:aws:iam::123456789012:user/example-username"}) ``` ## transition\$1s3\$1path **`transition_s3_path(s3_path, transition_to, options={}, transformation_ctx="")`** 以递归方式转换指定 Amazon S3 路径中的文件的存储类。可以在任意两个存储类之间转换。对于 `GLACIER` 和 `DEEP_ARCHIVE` 存储类，您可以转换到这些类。但您可以使用 `S3 RESTORE` 从 `GLACIER` 和 `DEEP_ARCHIVE` 存储类进行转换。如果您要运行从 Amazon S3 读取文件或分区的 AWS Glue ETL 任务，则可以排除某些 Amazon S3 存储类类型。有关更多信息，请参阅[排除 Amazon S3 存储类](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-storage-classes.html)。 + `s3_path` – 要转换的文件的 Amazon S3 中的路径，格式为 `s3:////` + `transition_to` – 要切换到的 [Amazon S3 存储类](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/s3/model/StorageClass.html)。 + `options` – 用于筛选要删除的文件和清单文件生成的选项。 + `retentionPeriod` – 指定保留文件的时段（以小时为单位）。比保留期更新的文件将被保留。默认情况下设置为 168 小时（7 天）。 + `partitionPredicate` – 将转换满足此谓词的分区。这些分区中保留期内的文件不会被转换。设置为 `""` – 默认情况下为空。 + `excludeStorageClasses` – `excludeStorageClasses` 集中包含存储类的文件不会被转换。默认值是 `Set()` – 一个空集。 + `manifestFilePath` – 用于生成清单文件的可选路径。所有成功转换的文件将记录在 `Success.csv` 中，所有未能转换的文件将记录在 `Failed.csv` 中 + `accountId` – 要运行转换的 Amazon Web Services 账户 ID。对于此转换是必需的。 + `roleArn` – 要运行转换的 AWS 角色。对于此转换是必需的。 + `transformation_ctx` – 要使用的转换上下文 (可选)。在清单文件路径中使用。 **Example** ``` glueContext.transition_s3_path("s3://bucket/prefix/", "STANDARD_IA", {"retentionPeriod": 1, "excludeStorageClasses": ["STANDARD_IA"], "manifestFilePath": "s3://bucketmanifest/", "accountId": "12345678901", "roleArn": "arn:aws:iam::123456789012:user/example-username"}) ``` ## 提取 + [extract\$1jdbc\$1conf](#aws-glue-api-crawler-pyspark-extensions-glue-context-extract_jdbc_conf) ## extract\$1jdbc\$1conf **`extract_jdbc_conf(connection_name, catalog_id = None)`** 从数据目录中的 `dict` 连接对象返回具有键（包含配置属性）的 AWS Glue。 + `user` - 数据库用户名。 + `password` - 数据库密码。 + `vendor` - 指定供应商（`mysql`、`postgresql`、`oracle`、`sqlserver`、等）。 + `enforceSSL` - 一个布尔字符串，指示是否需要安全连接。 + `customJDBCCert` - 使用指示的 Amazon S3 路径中的特定客户端证书。 + `skipCustomJDBCCertValidation` - 一个布尔字符串，指示 `customJDBCCert` 是否必须由 CA 验证。 + `customJDBCCertString` - 关于自定义证书的其他信息，特定于驱动程序类型。 + `url` -（已弃用）仅包含协议、服务器和端口的 JDBC URL。 + `fullUrl` - 创建连接时输入的 JDBC URL（AWS Glue 版本 3.0 或更高版本中可用）。检索 JDBC 配置的示例： ``` jdbc_conf = glueContext.extract_jdbc_conf(connection_name="your_glue_connection_name") print(jdbc_conf) >>> {'enforceSSL': 'false', 'skipCustomJDBCCertValidation': 'false', 'url': 'jdbc:mysql://myserver:3306', 'fullUrl': 'jdbc:mysql://myserver:3306/mydb', 'customJDBCCertString': '', 'user': 'admin', 'customJDBCCert': '', 'password': '1234', 'vendor': 'mysql'} ``` ## 事务 + [start\$1transaction](#aws-glue-api-pyspark-extensions-glue-context-start-transaction) + [commit\$1transaction](#aws-glue-api-pyspark-extensions-glue-context-commit-transaction) + [cancel\$1transaction](#aws-glue-api-pyspark-extensions-glue-cancel-transaction) ## start\$1transaction **`start_transaction(read_only)`** 开启新事务。内部调用 Lake Formation [startTransaction](https://docs.aws.amazon.com/lake-formation/latest/dg/aws-lake-formation-api-aws-lake-formation-api-transactions.html#aws-lake-formation-api-aws-lake-formation-api-transactions-StartTransaction) API。 + `read_only` –（布尔值）指示此事务应为只读还是读写。使用只读事务 ID 进行的写入将被拒绝。只读事务不需要提交。返回事务 ID。 ## commit\$1transaction **`commit_transaction(transaction_id, wait_for_commit = True)`** 尝试提交指定的事务。可能在事务完成提交之前返回 `commit_transaction`。内部调用 Lake Formation [commitTransaction](https://docs.aws.amazon.com/lake-formation/latest/dg/aws-lake-formation-api-aws-lake-formation-api-transactions.html#aws-lake-formation-api-aws-lake-formation-api-transactions-CommitTransaction) API。 + `transaction_id ` –（字符串）要提交的事务。 + `wait_for_commit` –（布尔值）确定是否立即返回 `commit_transaction`。默认值为 true。如果为假，则轮询 `commit_transaction` 并等待事务提交。等待时间限制为 1 分钟使用指数回退，最多重试 6 次。返回布尔值，以指示是否完成提交。 ## cancel\$1transaction **`cancel_transaction(transaction_id)`** 尝试取消指定的事务。如果事务以前已提交，则返回 `TransactionCommittedException` 异常。内部调用 Lake Formation [CancelTransaction](https://docs.aws.amazon.com/lake-formation/latest/dg/aws-lake-formation-api-aws-lake-formation-api-transactions.html#aws-lake-formation-api-aws-lake-formation-api-transactions-CancelTransaction) API。 + `transaction_id` –（字符串）要取消的事务。 ## 编写 + [getSink](#aws-glue-api-crawler-pyspark-extensions-glue-context-get-sink) + [write\$1dynamic\$1frame\$1from\$1options](#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options) + [write\$1from\$1options](#aws-glue-api-crawler-pyspark-extensions-glue-context-write_from_options) + [write\$1dynamic\$1frame\$1from\$1catalog](#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_catalog) + [write\$1data\$1frame\$1from\$1catalog](#aws-glue-api-crawler-pyspark-extensions-glue-context-write_data_frame_from_catalog) + [write\$1dynamic\$1frame\$1from\$1jdbc\$1conf](#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_jdbc_conf) + [write\$1from\$1jdbc\$1conf](#aws-glue-api-crawler-pyspark-extensions-glue-context-write_from_jdbc_conf) ## getSink **`getSink(connection_type, format = None, transformation_ctx = "", **options)`** 获取一个 `DataSink` 对象，该对象可用于将 `DynamicFrames` 写入外部来源。先检查 SparkSQL `format` 以确保获得预期的接收器。 + `connection_type` – 要使用的连接类型，例如 Amazon S3、Amazon Redshift 和 JDBC。有效值包括 `s3`、`mysql`、`postgresql`、`redshift`、`sqlserver`、`oracle`、`kinesis` 和 `kafka`。 + `format` – 要使用的 SparkSQL 格式 (可选)。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 + `options` – 用于指定连接选项的名称-值对的集合。一些可能的值包括： + `user` 和 `password`：适用于授权 + `url`：数据存储的端点 + `dbtable`：目标表的名称 + `bulkSize`：插入操作的并行度可以指定的选项取决于连接类型。有关其他值和示例，请参阅 [AWS Glue for Spark 中适用于 ETL 的连接类型和选项](aws-glue-programming-etl-connect.md)。示例： ``` >>> data_sink = context.getSink("s3") >>> data_sink.setFormat("json"), >>> data_sink.writeFrame(myFrame) ``` ## write\$1dynamic\$1frame\$1from\$1options **`write_dynamic_frame_from_options(frame, connection_type, connection_options={}, format=None, format_options={}, transformation_ctx = "")`** 写入并返回一个使用指定连接和格式的 `DynamicFrame`。 + `frame` – 要编写的 `DynamicFrame`。 + `connection_type` – 连接类型，例如 Amazon S3、Amazon Redshift 和 JDBC。有效值包括 `s3`、`mysql`、`postgresql`、`redshift`、`sqlserver`、`oracle`、`kinesis` 和 `kafka`。 + `connection_options` – 连接选项，例如路径和数据库表 (可选)。对于 `connection_type` 的 `s3`，将会定义 Amazon S3 路径。 ``` connection_options = {"path": "s3://aws-glue-target/temp"} ``` 对于 JDBC 连接，必须定义多个属性。请注意，数据库名称必须是 URL 的一部分。它可以选择性地包含在连接选项中。 **警告** 不建议在脚本中存储密码。请考虑使用 `boto3` 从 AWS Secrets Manager 或 AWS Glue Data Catalog 检索它们。 ``` connection_options = {"url": "jdbc-url/database", "user": "username", "password": passwordVariable,"dbtable": "table-name", "redshiftTmpDir": "s3-tempdir-path"} ``` `dbtable` 属性是 JDBC 表的名称。对于在数据库中支持架构的 JDBC 数据存储，指定 `schema.table-name`。如果未提供架构，则使用默认的“public”架构。有关更多信息，请参阅 [AWS Glue for Spark 中适用于 ETL 的连接类型和选项](aws-glue-programming-etl-connect.md)。 + `format` – 格式规范。这用于 Amazon S3 或支持多种格式的 AWS Glue 连接。有关支持的格式，请参阅 [AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。 + `format_options` – 指定格式的格式选项。有关支持的格式，请参阅 [AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 ## write\$1from\$1options **`write_from_options(frame_or_dfc, connection_type, connection_options={}, format={}, format_options={}, transformation_ctx = "")`** 写入并返回一个使用指定连接和格式信息创建的 `DynamicFrame` or `DynamicFrameCollection`。 + `frame_or_dfc` – 要写入的 `DynamicFrame` 或 `DynamicFrameCollection`。 + `connection_type` – 连接类型，例如 Amazon S3、Amazon Redshift 和 JDBC。有效值包括 `s3`、`mysql`、`postgresql`、`redshift`、`sqlserver` 和 `oracle`。 + `connection_options` – 连接选项，例如路径和数据库表 (可选)。对于 `connection_type` 的 `s3`，将会定义 Amazon S3 路径。 ``` connection_options = {"path": "s3://aws-glue-target/temp"} ``` 对于 JDBC 连接，必须定义多个属性。请注意，数据库名称必须是 URL 的一部分。它可以选择性地包含在连接选项中。 **警告** 不建议在脚本中存储密码。请考虑使用 `boto3` 从 AWS Secrets Manager 或 AWS Glue Data Catalog 检索它们。 ``` connection_options = {"url": "jdbc-url/database", "user": "username", "password": passwordVariable,"dbtable": "table-name", "redshiftTmpDir": "s3-tempdir-path"} ``` `dbtable` 属性是 JDBC 表的名称。对于在数据库中支持架构的 JDBC 数据存储，指定 `schema.table-name`。如果未提供架构，则使用默认的“public”架构。有关更多信息，请参阅 [AWS Glue for Spark 中适用于 ETL 的连接类型和选项](aws-glue-programming-etl-connect.md)。 + `format` – 格式规范。这用于 Amazon S3 或支持多种格式的 AWS Glue 连接。有关支持的格式，请参阅 [AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。 + `format_options` – 指定格式的格式选项。有关支持的格式，请参阅 [AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 ## write\$1dynamic\$1frame\$1from\$1catalog **`write_dynamic_frame_from_catalog(frame, database, table_name, redshift_tmp_dir, transformation_ctx = "", additional_options = {}, catalog_id = None)`** 写入并返回一个使用数据目录数据库和表中信息的 `DynamicFrame`。 + `frame` – 要编写的 `DynamicFrame`。 + `Database` – 包含表的数据目录数据库。 + `table_name` – 与目标关联的数据目录表的名称。 + `redshift_tmp_dir` – 要使用的 Amazon Redshift 临时目录（可选）。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 + `additional_options` – 可选名称/值对的集合。 + `catalog_id` – 正在访问的数据目录 ID（账户 ID）。当为 None 时，将使用调用方的默认账户 ID。 ## write\$1data\$1frame\$1from\$1catalog **`write_data_frame_from_catalog(frame, database, table_name, redshift_tmp_dir, transformation_ctx = "", additional_options = {}, catalog_id = None)`** 写入并返回一个使用数据目录数据库和表中信息的 `DataFrame`。此方法支持写入数据湖格式（Hudi、Iceberg 和 Delta Lake）。有关更多信息，请参阅 [在 AWS Glue ETL 任务中使用数据湖框架](aws-glue-programming-etl-datalake-native-frameworks.md)。 + `frame` – 要编写的 `DataFrame`。 + `Database` – 包含表的数据目录数据库。 + `table_name` – 与目标关联的数据目录表的名称。 + `redshift_tmp_dir` – 要使用的 Amazon Redshift 临时目录（可选）。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 + `additional_options` – 可选名称/值对的集合。 + `useSparkDataSink` — 如果设置为 true，则强制 AWS Glue 使用本机 Spark 数据接收器 API 来写入表。启用此选项后，您还可以根据需要在 `additional_options` 中添加任何 [Spark 数据来源](https://spark.apache.org/docs/latest/sql-data-sources.html)选项。AWSGlue 将这些选项直接传递给 Spark 写入器。 + `catalog_id` – 正在访问的数据目录 ID（账户 ID）。如果您未指定值，则使用调用方的默认账户 ID。 **限制** 使用 `useSparkDataSink` 选项时请考虑以下限制： + 使用 `useSparkDataSink` 选项时不支持 [`enableUpdateCatalog`](update-from-job.md) 选项。 **示例：使用 Spark 数据源写入器写入 Hudi 表** ``` hudi_options = { 'useSparkDataSink': True, 'hoodie.table.name': , 'hoodie.datasource.write.storage.type': 'COPY_ON_WRITE', 'hoodie.datasource.write.recordkey.field': 'product_id', 'hoodie.datasource.write.table.name': , 'hoodie.datasource.write.operation': 'upsert', 'hoodie.datasource.write.precombine.field': 'updated_at', 'hoodie.datasource.write.hive_style_partitioning': 'true', 'hoodie.upsert.shuffle.parallelism': 2, 'hoodie.insert.shuffle.parallelism': 2, 'hoodie.datasource.hive_sync.enable': 'true', 'hoodie.datasource.hive_sync.database': , 'hoodie.datasource.hive_sync.table': , 'hoodie.datasource.hive_sync.use_jdbc': 'false', 'hoodie.datasource.hive_sync.mode': 'hms'} glueContext.write_data_frame.from_catalog( frame = , database = , table_name = , additional_options = hudi_options ) ``` ## write\$1dynamic\$1frame\$1from\$1jdbc\$1conf **`write_dynamic_frame_from_jdbc_conf(frame, catalog_connection, connection_options={}, redshift_tmp_dir = "", transformation_ctx = "", catalog_id = None)`** 写入并返回一个使用指定 JDBC 和连接信息的 `DynamicFrame`。 + `frame` – 要编写的 `DynamicFrame`。 + `catalog_connection` – 要使用的目录连接。 + `connection_options` – 连接选项，例如路径和数据库表 (可选)。有关更多信息，请参阅 [AWS Glue for Spark 中适用于 ETL 的连接类型和选项](aws-glue-programming-etl-connect.md)。 + `redshift_tmp_dir` – 要使用的 Amazon Redshift 临时目录（可选）。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 + `catalog_id` – 正在访问的数据目录 ID（账户 ID）。当为 None 时，将使用调用方的默认账户 ID。 ## write\$1from\$1jdbc\$1conf **`write_from_jdbc_conf(frame_or_dfc, catalog_connection, connection_options={}, redshift_tmp_dir = "", transformation_ctx = "", catalog_id = None)`** 写入并返回一个使用指定 JDBC 和连接信息的 `DynamicFrame` or `DynamicFrameCollection`。 + `frame_or_dfc` – 要写入的 `DynamicFrame` 或 `DynamicFrameCollection`。 + `catalog_connection` – 要使用的目录连接。 + `connection_options` – 连接选项，例如路径和数据库表 (可选)。有关更多信息，请参阅 [AWS Glue for Spark 中适用于 ETL 的连接类型和选项](aws-glue-programming-etl-connect.md)。 + `redshift_tmp_dir` – 要使用的 Amazon Redshift 临时目录（可选）。 + `transformation_ctx` – 要使用的转换上下文 (可选)。 + `catalog_id` – 正在访问的数据目录 ID（账户 ID）。当为 None 时，将使用调用方的默认账户 ID。 # AWS Glue PySpark 转换参考 AWS Glue 提供了以下可在 PySpark ETL 操作中使用的内置转换。您的数据在一个称为 *DynamicFrame* 的数据结构中从转换传递到转换，该数据结构是 Apache Spark SQL `DataFrame` 的扩展。`DynamicFrame` 包含您的数据，并引用其架构来处理您的数据。此外，其中的大多数转换也将作为 `DynamicFrame` 类的方法存在。更多相关信息，请参阅 [DynamicFrame 转换](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-_transforms)。 + [GlueTransform 基类](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md) + [ApplyMapping 类](aws-glue-api-crawler-pyspark-transforms-ApplyMapping.md) + [DropFields 类](aws-glue-api-crawler-pyspark-transforms-DropFields.md) + [DropNullFields 类](aws-glue-api-crawler-pyspark-transforms-DropNullFields.md) + [ErrorsAsDynamicFrame 类](aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame.md) + [EvaluateDataQuality 类](aws-glue-api-crawler-pyspark-transforms-EvaluateDataQuality.md) + [FillMissingValues 类](aws-glue-api-crawler-pyspark-transforms-fillmissingvalues.md) + [Filter 类](aws-glue-api-crawler-pyspark-transforms-filter.md) + [FindIncrementalMatches 类](aws-glue-api-crawler-pyspark-transforms-findincrementalmatches.md) + [FindMatches 类](aws-glue-api-crawler-pyspark-transforms-findmatches.md) + [FlatMap 类](aws-glue-api-crawler-pyspark-transforms-flat-map.md) + [Join 类](aws-glue-api-crawler-pyspark-transforms-join.md) + [Map 类](aws-glue-api-crawler-pyspark-transforms-map.md) + [MapToCollection 类](aws-glue-api-crawler-pyspark-transforms-MapToCollection.md) + [mergeDynamicFrame](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-merge) + [Relationalize 类](aws-glue-api-crawler-pyspark-transforms-Relationalize.md) + [RenameField 类](aws-glue-api-crawler-pyspark-transforms-RenameField.md) + [ResolveChoice 类](aws-glue-api-crawler-pyspark-transforms-ResolveChoice.md) + [SelectFields 类](aws-glue-api-crawler-pyspark-transforms-SelectFields.md) + [SelectFromCollection 类](aws-glue-api-crawler-pyspark-transforms-SelectFromCollection.md) + [Simplify\$1ddb\$1json 类](aws-glue-api-crawler-pyspark-transforms-simplify-ddb-json.md) + [Spigot 类](aws-glue-api-crawler-pyspark-transforms-spigot.md) + [SplitFields 类](aws-glue-api-crawler-pyspark-transforms-SplitFields.md) + [SplitRows 类](aws-glue-api-crawler-pyspark-transforms-SplitRows.md) + [Unbox 类](aws-glue-api-crawler-pyspark-transforms-Unbox.md) + [UnnestFrame 类](aws-glue-api-crawler-pyspark-transforms-UnnestFrame.md) # GlueTransform 基类所有 `awsglue.transforms` 类继承的基类。这些类全部定义 `__call__` 方法。它们要么重写以下各节中列出的 `GlueTransform` 类方法，要么在默认情况下使用类名调用它们。 ## 方法 + [apply(cls, \$1args, \$1\$1kwargs)](#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply) + [name(cls)](#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name) + [describeArgs(cls)](#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs) + [describeReturn(cls)](#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn) + [describeTransform(cls)](#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform) + [describeErrors(cls)](#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors) + [describe(cls)](#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe) ## apply(cls, \$1args, \$1\$1kwargs) 通过调用转换类来应用转换，并返回结果。 + `cls` – `self` 类对象。 ## name(cls) 返回派生的转换类的名称。 + `cls` – `self` 类对象。 ## describeArgs(cls) + `cls` – `self` 类对象。返回各自与命名参数对应的字典的列表，格式如下： ``` [ { "name": "(name of argument)", "type": "(type of argument)", "description": "(description of argument)", "optional": "(Boolean, True if the argument is optional)", "defaultValue": "(Default value string, or None)(String; the default value, or None)" }, ... ] ``` 在未实现它的派生转换中调用时引发 `NotImplementedError` 异常。 ## describeReturn(cls) + `cls` – `self` 类对象。返回具有有关返回类型的信息的字典，格式如下： ``` { "type": "(return type)", "description": "(description of output)" } ``` 在未实现它的派生转换中调用时引发 `NotImplementedError` 异常。 ## describeTransform(cls) 返回一个描述转换的字符串。 + `cls` – `self` 类对象。在未实现它的派生转换中调用时引发 `NotImplementedError` 异常。 ## describeErrors(cls) + `cls` – `self` 类对象。返回各自描述此转换引发的可能异常的字典的列表，格式如下： ``` [ { "type": "(type of error)", "description": "(description of error)" }, ... ] ``` ## describe(cls) + `cls` – `self` 类对象。返回具有以下格式的对象： ``` { "transform" : { "name" : cls.name( ), "args" : cls.describeArgs( ), "returns" : cls.describeReturn( ), "raises" : cls.describeErrors( ), "location" : "internal" } } ``` # ApplyMapping 类在 `DynamicFrame` 中应用映射。 ## 示例我们建议您使用 [`DynamicFrame.apply_mapping()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-apply_mapping) 方法在 `DynamicFrame` 中应用映射。要查看代码示例，请参阅 [示例：使用 apply\$1mapping 重命名字段并更改字段类型](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-apply_mapping-example)。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-ApplyMapping-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-ApplyMapping-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-ApplyMapping-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-ApplyMapping-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-ApplyMapping-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-ApplyMapping-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-ApplyMapping-describeErrors) + [描述](#aws-glue-api-crawler-pyspark-transforms-ApplyMapping-describe) ## \$1\$1call\$1\$1(frame, mappings, transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0) 将声明映射到指定的 `DynamicFrame`。 + `frame` – 要对其应用映射的 `DynamicFrame`（必需）。 + `mappings` – 映射元组列表（必需）。每个元组包括：（源列，源类型，目标列，目标类型）。如果源列中有一个点“`.`”在名称里，则必须在名称外加上反引号“````”。例如，要将 `this.old.name`（字符串）映射到 `thisNewName`，可以使用以下元组： ``` ("`this.old.name`", "string", "thisNewName", "string") ``` + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与转换中的错误关联的字符串（可选）。 + `stageThreshold` – 在转换出错之前可能在其中发生的最大错误数（可选）。默认值为 0。 + `totalThreshold` – 在处理出错之前可能全面发生的最大错误数（可选）。默认值为 0。仅返回“映射”元组中指定的 `DynamicFrame` 字段。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # DropFields 类删除 `DynamicFrame` 中的字段。 ## 示例我们建议您使用 [`DynamicFrame.drop_fields()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-drop_fields) 方法从 `DynamicFrame` 中删除字段。要查看代码示例，请参阅 [示例：使用 drop\$1fields 从 `DynamicFrame` 中删除字段](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-drop_fields-example)。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-DropFields-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-DropFields-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-DropFields-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-DropFields-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-DropFields-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-DropFields-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-DropFields-describeErrors) + [描述](#aws-glue-api-crawler-pyspark-transforms-DropFields-describe) ## \$1\$1call\$1\$1(frame, paths, transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0) 删除 `DynamicFrame` 中的字节。 + `frame` – 要在其中删除节点的 `DynamicFrame`（必需）。 + `paths` – 要删除的节点的完整路径的列表 (必需)。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与转换中的错误关联的字符串 (可选)。 + `stageThreshold` – 在转换出错之前可能在其中发生的最大错误数（可选）。默认值为 0。 + `totalThreshold` – 在处理出错之前可能全面发生的最大错误数（可选）。默认值为 0。返回不包含指定字段的新 `DynamicFrame`。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # DropNullFields 类删除 `DynamicFrame` 中类型为 `NullType` 的所有 null 字段。即 `DynamicFrame` 数据集内每个记录中缺少值或值为 null 的字段。 ## 示例此示例用 `DropNullFields` 创建新的 `DynamicFrame`，其中类型为 `NullType` 的字段已删除。为了演示如何使用 `DropNullFields`，我们将类型为 null 的新列 `empty_column` 添加到已加载的 `persons` 数据集。 **注意** 要访问本示例中使用的数据集，请参阅 [代码示例：对数据进行联接和关系化](aws-glue-programming-python-samples-legislators.md) 并按照 [步骤 1：爬取 Amazon S3 存储桶中的数据](aws-glue-programming-python-samples-legislators.md#aws-glue-programming-python-samples-legislators-crawling) 中的说明进行操作。 ``` # Example: Use DropNullFields to create a new DynamicFrame without NullType fields from pyspark.context import SparkContext from awsglue.context import GlueContext from pyspark.sql.functions import lit from pyspark.sql.types import NullType from awsglue.dynamicframe import DynamicFrame from awsglue.transforms import DropNullFields # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Create DynamicFrame persons = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="persons_json" ) print("Schema for the persons DynamicFrame:") persons.printSchema() # Add new column "empty_column" with NullType persons_with_nulls = persons.toDF().withColumn("empty_column", lit(None).cast(NullType())) persons_with_nulls_dyf = DynamicFrame.fromDF(persons_with_nulls, glueContext, "persons_with_nulls") print("Schema for the persons_with_nulls_dyf DynamicFrame:") persons_with_nulls_dyf.printSchema() # Remove the NullType field persons_no_nulls = DropNullFields.apply(persons_with_nulls_dyf) print("Schema for the persons_no_nulls DynamicFrame:") persons_no_nulls.printSchema() ``` ### Output ``` Schema for the persons DynamicFrame: root |-- family_name: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- gender: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- sort_name: string |-- images: array | |-- element: struct | | |-- url: string |-- given_name: string |-- birth_date: string |-- id: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- death_date: string Schema for the persons_with_nulls_dyf DynamicFrame: root |-- family_name: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- gender: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- sort_name: string |-- images: array | |-- element: struct | | |-- url: string |-- given_name: string |-- birth_date: string |-- id: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- death_date: string |-- empty_column: null null_fields ['empty_column'] Schema for the persons_no_nulls DynamicFrame: root |-- family_name: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- gender: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- sort_name: string |-- images: array | |-- element: struct | | |-- url: string |-- given_name: string |-- birth_date: string |-- id: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- death_date: string ``` ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-DropNullFields-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-DropNullFields-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-DropNullFields-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-DropNullFields-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-DropNullFields-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-DropNullFields-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-DropNullFields-describeErrors) + [描述](#aws-glue-api-crawler-pyspark-transforms-DropNullFields-describe) ## \$1\$1call\$1\$1(frame, transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0) 删除 `DynamicFrame` 中类型为 `NullType` 的所有 null 字段。即 `DynamicFrame` 数据集内每个记录中缺少值或值为 null 的字段。 + `frame` – 要在其中删除 null 字段的 `DynamicFrame`（必需）。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与转换中的错误关联的字符串 (可选)。 + `stageThreshold` – 在转换出错之前可能在其中发生的最大错误数（可选）。默认值为 0。 + `totalThreshold` – 在处理出错之前可能全面发生的最大错误数（可选）。默认值为 0。返回一个不包含 null 字段的新 `DynamicFrame`。 ## apply(cls, \$1args, \$1\$1kwargs) + `cls` – cls ## name(cls) + `cls` – cls ## describeArgs(cls) + `cls` – cls ## describeReturn(cls) + `cls` – cls ## describeTransform(cls) + `cls` – cls ## describeErrors(cls) + `cls` – cls ## describe(cls) + `cls` – cls # ErrorsAsDynamicFrame 类返回 `DynamicFrame`，其中包含源 `DynamicFrame` 创建时所发生错误的嵌套记录。 ## 示例我们建议您使用 [`DynamicFrame.errorsAsDynamicFrame()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-errorsAsDynamicFrame) 方法检索和查看错误记录。要查看代码示例，请参阅 [示例：使用 errorsAsDynamicFrame 查看错误记录](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-errorsAsDynamicFrame-example)。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame-apply) + [名称](#aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame-describeErrors) + [描述](#aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame-describe) ## \$1\$1call\$1\$1(frame) 返回 `DynamicFrame`，其中包含与源 `DynamicFrame` 相关的嵌套错误记录。 + `frame` – 源 `DynamicFrame` (必需)。 ## apply(cls, \$1args, \$1\$1kwargs) + `cls` – cls ## name(cls) + `cls` – cls ## describeArgs(cls) + `cls` – cls ## describeReturn(cls) + `cls` – cls ## describeTransform(cls) + `cls` – cls ## describeErrors(cls) + `cls` – cls ## describe(cls) + `cls` – cls # EvaluateDataQuality 类根据 `DynamicFrame` 中的数据评估数据质量规则集，并返回一个包含数据质量评估结果的新 `DynamicFrame`。 ## 示例以下示例代码演示了如何评估 `DynamicFrame` 的数据质量，然后查看数据质量结果。 ``` from awsglue.transforms import * from pyspark.context import SparkContext from awsglue.context import GlueContext from awsgluedq.transforms import EvaluateDataQuality #Create Glue context sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Define DynamicFrame legislatorsAreas = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="areas_json") # Create data quality ruleset ruleset = """Rules = [ColumnExists "id", IsComplete "id"]""" # Evaluate data quality dqResults = EvaluateDataQuality.apply( frame=legislatorsAreas, ruleset=ruleset, publishing_options={ "dataQualityEvaluationContext": "legislatorsAreas", "enableDataQualityCloudWatchMetrics": True, "enableDataQualityResultsPublishing": True, "resultsS3Prefix": "amzn-s3-demo-bucket1", }, ) # Inspect data quality results dqResults.printSchema() dqResults.toDF().show() ``` ### Output ``` root |-- Rule: string |-- Outcome: string |-- FailureReason: string |-- EvaluatedMetrics: map | |-- keyType: string | |-- valueType: double +-----------------------+-------+-------------+---------------------------------------+ |Rule |Outcome|FailureReason|EvaluatedMetrics | +-----------------------+-------+-------------+---------------------------------------+ |ColumnExists "id" |Passed |null |{} | |IsComplete "id" |Passed |null |{Column.first_name.Completeness -> 1.0}| +-----------------------+-------+-------------+---------------------------------------+ ``` ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-EvaluateDataQuality-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-EvaluateDataQuality-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-EvaluateDataQuality-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-EvaluateDataQuality-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-EvaluateDataQuality-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-EvaluateDataQuality-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-EvaluateDataQuality-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-EvaluateDataQuality-describe) ## \$1\$1call\$1\$1(frame, ruleset, publishing\$1options = \$1\$1) + `frame` – 表示您想要评估其数据质量的 `DynamicFrame`。 + `ruleset` – 字符串格式的数据质量定义语言（DQDL）规则集。要了解有关 DQDL 的更多信息，请参阅[数据质量定义语言（DQDL）引用](dqdl.md)指南。 + `publishing_options` – 一个字典，用于为发布评估结果和指标指定以下选项： + `dataQualityEvaluationContext` – 一个字符串，用于指定 AWS Glue 应在哪个命名空间下发布 Amazon CloudWatch 指标和数据质量结果。汇总指标显示在 CloudWatch 中，而完整结果显示在 AWS Glue Studio 界面中。 + 必需：否 + 默认值：`default_context` + `enableDataQualityCloudWatchMetrics` – 指定是否应将数据质量评估结果发布到 CloudWatch。您可以使用 `dataQualityEvaluationContext` 选项为指标指定命名空间。 + 必需：否 + 默认值：False + `enableDataQualityResultsPublishing` – 指定是否应在 AWS Glue Studio 界面的 **Data Quality**（数据质量）选项卡上显示数据质量结果。 + 必需：否 + 默认值：true + `resultsS3Prefix` – 指定 AWS Glue 可以写入数据质量评估结果的 Amazon S3 位置。 + 必需：否 + 默认值：""（空字符串） ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # FillMissingValues 类 `FillMissingValues` 类使用机器学习方法（如线性回归和随机森林）填充指定 `DynamicFrame` 列中的 null 值和空字符串，以预测缺失值。ETL 任务使用输入数据集中的值来训练机器学习模型，然后该模型预测缺失的值应该是什么。 **提示** 如果您使用增量数据集，则每个增量集都会用作机器学习模型的训练数据，因此结果可能不是如此准确。导入： ``` from awsglueml.transforms import FillMissingValues ``` ## 方法 + [Apply](#aws-glue-api-crawler-pyspark-transforms-fillmissingvalues-apply) ## apply(frame, missing\$1values\$1column, output\$1column ="", transformation\$1ctx ="", info ="", stageThreshold = 0, totalThreshold = 0) 填充指定列中的动态帧缺失值，并在新列中返回包含估计值的新帧。对于没有缺失值的行，指定列的值将复制到新列。 + `frame` – 要填充缺失值的 `DynamicFrame`。必需。 + `missing_values_column` – 包含缺失值（`null` 值和空字符串）的列。必需。 + `output_column` – 新列的名称，该列将包含缺失值的所有行的估计值。可选；默认值是后缀为 `"_filled"` 的 `missing_values_column`。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与转换中的错误关联的字符串 (可选)。 + `stageThreshold` – 在转换出错之前可能在其中发生的最大错误数 (可选；默认值为零)。 + `totalThreshold` – 在处理出错之前可能全面发生的最大错误数 (可选；默认值为零)。返回带附加列的新 `DynamicFrame`，该列包含带缺失值的行的估计值和其他行的当前值。 # Filter 类生成新的 `DynamicFrame`，其中包含满足指定谓词函数的输入 `DynamicFrame` 中的记录。 ## 示例我们建议您使用 [`DynamicFrame.filter()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-filter) 方法在 `DynamicFrame` 中筛选记录。要查看代码示例，请参阅 [示例：使用筛选条件获取筛选后的字段选择](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-filter-example)。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-filter-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-filter-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-filter-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-filter-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-filter-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-filter-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-filter-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-filter-describe) ## \$1\$1call\$1\$1(frame, f, transformation\$1ctx="", info="", stageThreshold=0, totalThreshold=0)) 返回新的 `DynamicFrame`，其通过从满足指定谓词函数的输入 `DynamicFrame` 中选择记录生成。 + `frame` – 要将指定筛选函数应用到的源 `DynamicFrame` (必需)。 + `f` – 要应用到 `DynamicFrame` 中的每个 `DynamicRecord` 的谓词函数。该函数必须将 `DynamicRecord` 作为实际参数，并且如果 `DynamicRecord` 满足筛选要求，则返回 True，否则返回 False（必需）。一个 `DynamicRecord` 表示 `DynamicFrame` 中的一条逻辑记录。其类似于 Spark `DataFrame` 中的一行，但其具有自描述性，可用于不符合固定架构的数据。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与转换中的错误关联的字符串（可选）。 + `stageThreshold` – 在转换出错之前可能在其中发生的最大错误数（可选）。默认值为 0。 + `totalThreshold` – 在处理出错之前可能全面发生的最大错误数（可选）。默认值为 0。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # FindIncrementalMatches 类标识现有和递增 `DynamicFrame` 中的匹配记录，并创建一个新的 `DynamicFrame`，其中包含分配给每组匹配记录的唯一标识符。导入： ``` from awsglueml.transforms import FindIncrementalMatches ``` ## 方法 + [Apply](#aws-glue-api-crawler-pyspark-transforms-findincrementalmatches-apply) ## apply(existingFrame, incrementalFrame, transformId, transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0, enforcedMatches = none, computeMatchConfidenceScores = 0) 标识输入 `DynamicFrame` 中的匹配记录，并创建一个新的 `DynamicFrame`，其中包含分配给每组匹配记录的唯一标识符。 + `existingFrame` – 现有和预先匹配的 `DynamicFrame`，应用 FindIncrementalMatches 转换。必需。 + `incrementalFrame` – 递增 `DynamicFrame`，应用 FindIncrementalMatches 转换以匹配 `existingFrame`。必需。 + `transformId` – 与 FindIncrementalMatches 转换关联的唯一 ID，在 `DynamicFrames` 中的记录上应用。必需。 + `transformation_ctx` – 用于标识状态信息的唯一字符串。可选。 + `info` – 与转换中的错误关联的字符串。可选。 + `stageThreshold` – 在转换出错之前可能在其中发生的最大错误数。可选。默认值为 0。 + `totalThreshold` – 在处理出错之前可能全面发生的最大错误数。可选。默认值为 0。 + `enforcedMatches` – 用于强制实施匹配的 `DynamicFrame`。可选。默认值为 None (无)。 + `computeMatchConfidenceScores` – 布尔值，指示是否为每组匹配记录计算置信度得分。可选。默认值为 false。返回新 `DynamicFrame`，并为每组匹配记录分配唯一标识符。 # FindMatches 类标识输入 `DynamicFrame` 中的匹配记录，并创建一个新的 `DynamicFrame`，其中包含分配给每组匹配记录的唯一标识符。导入： ``` from awsglueml.transforms import FindMatches ``` ## 方法 + [Apply](#aws-glue-api-crawler-pyspark-transforms-findmatches-apply) ## apply(frame, transformId, transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0, enforcedMatches = none, computeMatchConfidenceScores = 0) 标识输入 `DynamicFrame` 中的匹配记录，并创建一个新的 `DynamicFrame`，其中包含分配给每组匹配记录的唯一标识符。 + `frame` – `DynamicFrame`，应用 FindMatches 转换。必需。 + `transformId` – 与 FindMatches 转换关联的唯一 ID，在 `DynamicFrame` 中的记录上应用。必需。 + `transformation_ctx` – 用于标识状态信息的唯一字符串。可选。 + `info` – 与转换中的错误关联的字符串。可选。 + `stageThreshold` – 在转换出错之前可能在其中发生的最大错误数。可选。默认值为 0。 + `totalThreshold` – 在处理出错之前可能全面发生的最大错误数。可选。默认值为 0。 + `enforcedMatches` – 用于强制实施匹配的 `DynamicFrame`。可选。默认值为 None (无)。 + `computeMatchConfidenceScores` – 布尔值，指示是否为每组匹配记录计算置信度得分。可选。默认值为 false。返回新 `DynamicFrame`，并为每组匹配记录分配唯一标识符。 # FlatMap 类对集合中的每个 `DynamicFrame` 应用转换。结果不会拼凑成单个 `DynamicFrame`，而是作为一个集合保存。 ## FlatMap 的示例以下示例片段展示了当应用于 `FlatMap` 时，如何对动态帧集合使用 `ResolveChoice` 转换。用于输入的数据是位于占位符 Amazon S3 地址 `s3://bucket/path-for-data/sample.json` 的 JSON，包含以下数据。 ### JSON 数据示例 ``` [{ "firstname": "Arnav", "lastname": "Desai", "address": { "street": "6 Anyroad Avenue", "city": "London", "state": "England", "country": "UK" }, "phone": 17235550101, "affiliations": [ "General Anonymous Example Products", "Example Independent Research", "Government Department of Examples" ] }, { "firstname": "Mary", "lastname": "Major", "address": { "street": "7821 Spot Place", "city": "Centerville", "state": "OK", "country": "US" }, "phone": 19185550023, "affiliations": [ "Example Dot Com", "Example Independent Research", "Example.io" ] }, { "firstname": "Paulo", "lastname": "Santos", "address": { "street": "123 Maple Street", "city": "London", "state": "Ontario", "country": "CA" }, "phone": 12175550181, "affiliations": [ "General Anonymous Example Products", "Example Dot Com" ] }] ``` **Example 将 ResolveChoice 应用于 DynamicFrameCollection，将显示输出。** ``` #Read DynamicFrame datasource = glueContext.create_dynamic_frame_from_options("s3", connection_options = {"paths":["s3://bucket/path/to/file/mysamplejson.json"]}, format="json") datasource.printSchema() datasource.show() ## Split to create a DynamicFrameCollection split_frame=datasource.split_fields(["firstname","lastname","address"],"personal_info","business_info") split_frame.keys() print("---") ## Use FlatMap to run ResolveChoice kwargs = {"choice": "cast:string"} flat = FlatMap.apply(split_frame, ResolveChoice, frame_name="frame", transformation_ctx='tcx', **kwargs) flat.keys() ##Select one of the DynamicFrames personal_info = flat.select("personal_info") personal_info.printSchema() personal_info.show() print("---") business_info = flat.select("business_info") business_info.printSchema() business_info.show() ``` 调用 `FlatMap.apply` 时，`frame_name` 参数**必须**为 `"frame"`。目前不接受其他值。 ### 示例输出 ``` root |-- firstname: string |-- lastname: string |-- address: struct | |-- street: string | |-- city: string | |-- state: string | |-- country: string |-- phone: long |-- affiliations: array | |-- element: string --- { "firstname": "Mary", "lastname": "Major", "address": { "street": "7821 Spot Place", "city": "Centerville", "state": "OK", "country": "US" }, "phone": 19185550023, "affiliations": [ "Example Dot Com", "Example Independent Research", "Example.io" ] } { "firstname": "Paulo", "lastname": "Santos", "address": { "street": "123 Maple Street", "city": "London", "state": "Ontario", "country": "CA" }, "phone": 12175550181, "affiliations": [ "General Anonymous Example Products", "Example Dot Com" ] } --- root |-- firstname: string |-- lastname: string |-- address: struct | |-- street: string | |-- city: string | |-- state: string | |-- country: string { "firstname": "Mary", "lastname": "Major", "address": { "street": "7821 Spot Place", "city": "Centerville", "state": "OK", "country": "US" } } { "firstname": "Paulo", "lastname": "Santos", "address": { "street": "123 Maple Street", "city": "London", "state": "Ontario", "country": "CA" } } --- root |-- phone: long |-- affiliations: array | |-- element: string { "phone": 19185550023, "affiliations": [ "Example Dot Com", "Example Independent Research", "Example.io" ] } { "phone": 12175550181, "affiliations": [ "General Anonymous Example Products", "Example Dot Com" ] } ``` ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-flat-map-__call__) + [Apply](#aws-glue-api-crawler-pyspark-transforms-flat-map-apply) + [名称](#aws-glue-api-crawler-pyspark-transforms-flat-map-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-flat-map-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-flat-map-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-flat-map-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-flat-map-describeErrors) + [描述](#aws-glue-api-crawler-pyspark-transforms-flat-map-describe) ## frame\$1name \$1\$1call\$1\$1 (dfc，BaseTransform transformation\$1ctx = “”，\$1\$1，base\$1kwargs)，向集合中的每个 `DynamicFrame` 应用转换，并展平结果。 + `dfc` – 要展平的 `DynamicFrameCollection` (必需)。 + `BaseTransform` – 派生自 `GlueTransform`、要应用于集合的每个成员的转换 (必需)。 + `frame_name` – 要将集合元素传递到的参数名称 (必需)。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `base_kwargs` – 要传递到基本转换的参数 (必需)。通过将返回新 `DynamicFrameCollection` 创建的每个转换 `DynamicFrame` 在源 `DynamicFrameCollection`。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # Join 类对两个 `DynamicFrames` 执行等式联接。 ## 示例我们建议您使用 [`DynamicFrame.join()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-join) 方法联接 `DynamicFrames`。要查看代码示例，请参阅 [示例：使用联接来组合 `DynamicFrames`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-join-example)。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-join-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-join-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-join-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-join-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-join-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-join-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-join-describeErrors) + [描述](#aws-glue-api-crawler-pyspark-transforms-join-describe) ## \$1\$1call\$1\$1(frame1, frame2, keys1, keys2, transformation\$1ctx = "") 对两个 `DynamicFrames` 执行等式联接。 + `frame1` – 要联接的第一个 `DynamicFrame` (必需)。 + `frame2` – 要联接的第二个 `DynamicFrame` (必需)。 + `keys1` – 第一个帧要联接的键 (必需)。 + `keys2` – 第二个帧要联接的键 (必需)。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。返回新的 `DynamicFrame`，其通过联接两个 `DynamicFrames` 创建。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # Map 类通过将函数应用于输入 `DynamicFrame` 中的所有记录来生成新的 `DynamicFrame`。 ## 示例我们建议您使用 [`DynamicFrame.map()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-map) 方法将函数应用于 `DynamicFrame` 中所有记录。要查看代码示例，请参阅 [示例：使用映射将函数应用于 `DynamicFrame` 中的每个记录](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-map-example)。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-map-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-map-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-map-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-map-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-map-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-map-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-map-describeErrors) + [描述](#aws-glue-api-crawler-pyspark-transforms-map-describe) ## \$1\$1call\$1\$1(frame, f, transformation\$1ctx="", info="", stageThreshold=0, totalThreshold=0) 返回一个新的 `DynamicFrame`，它源自将指定函数应用到原始 `DynamicFrame` 中的所有 `DynamicRecords`。 + `frame` – 要对其应用映射函数的原始 `DynamicFrame`（必需）。 + `f` – 要应用到 `DynamicRecords` 中的所有 `DynamicFrame` 的函数。该函数必须将 `DynamicRecord` 作为实际参数并返回一个由映射生成的新的 `DynamicRecord`（必需）。一个 `DynamicRecord` 表示 `DynamicFrame` 中的一条逻辑记录。它类似于 Apache Spark `DataFrame` 中的一行，但其具有自描述性，可用于不符合固定架构的数据。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与转换中的错误关联的字符串 (可选)。 + `stageThreshold` – 在转换出错之前可能在其中发生的最大错误数（可选）。默认值为 0。 + `totalThreshold` – 在处理出错之前可能全面发生的最大错误数（可选）。默认值为 0。返回一个新的 `DynamicFrame`，它源自将指定函数应用到原始 `DynamicFrame` 中的所有 `DynamicRecords`。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # MapToCollection 类对指定 `DynamicFrameCollection` 中的每个 `DynamicFrame` 应用转换。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-MapToCollection-__call__) + [Apply](#aws-glue-api-crawler-pyspark-transforms-MapToCollection-apply) + [名称](#aws-glue-api-crawler-pyspark-transforms-MapToCollection-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-MapToCollection-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-MapToCollection-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-MapToCollection-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-MapToCollection-describeErrors) + [描述](#aws-glue-api-crawler-pyspark-transforms-MapToCollection-describe) ## frame\$1name \$1\$1call\$1\$1 (dfc，BaseTransform transformation\$1ctx = “”，\$1\$1，base\$1kwargs)，对指定 `DynamicFrameCollection` 中的每个 `DynamicFrame` 应用转换函数。 + `dfc` – 要对其应用转换函数的原始 `DynamicFrameCollection` (必需)。 + `callable` – 要应用于集合的每个成员的可调用转换函数 (必需)。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。通过将返回新 `DynamicFrameCollection` 创建的每个转换 `DynamicFrame` 在源 `DynamicFrameCollection`。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply) ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # Relationalize 类在 `DynamicFrame` 中展平嵌套架构，并从展平帧透视数组列。 ## 示例我们建议您使用 [`DynamicFrame.relationalize()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-relationalize) 方法关系化 `DynamicFrame`。要查看代码示例，请参阅 [示例：使用 relatialize 在 `DynamicFrame` 中展平嵌套架构](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-relationalize-example)。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-Relationalize-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-Relationalize-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-Relationalize-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-Relationalize-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-Relationalize-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-Relationalize-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-Relationalize-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-Relationalize-describe) ## \$1\$1call\$1\$1(frame, staging\$1path=None, name='roottable', options=None, transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0) 关系化 `DynamicFrame` 并生成一个帧列表，这些帧是通过取消嵌套列的嵌套并透视数组列生成的。可使用在取消嵌套阶段生成的联接键将透视数组列联接到根表。 + `frame` – 要关系化的 `DynamicFrame` (必需)。 + `staging_path` – 要将 CSV 格式的透视表分区存储到的路径（可选）。从该路径读取透视表。 + `name` – 根表的名称 (可选)。 + `options` – 可选参数的词典。目前未使用。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与转换中的错误关联的字符串 (可选)。 + `stageThreshold` – 在转换出错之前可能在其中发生的最大错误数（可选）。默认值为 0。 + `totalThreshold` – 在处理出错之前可能全面发生的最大错误数（可选）。默认值为 0。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # RenameField 类在 `DynamicFrame` 内重命名一个节点。 ## 示例我们建议您使用 [`DynamicFrame.rename_field()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-rename_field) 方法在 `DynamicFrame` 中重命名字段。要查看代码示例，请参阅 [示例：使用 rename\$1field 重命名 `DynamicFrame` 中的字段](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-rename_field-example)。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-RenameField-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-RenameField-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-RenameField-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-RenameField-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-RenameField-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-RenameField-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-RenameField-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-RenameField-describe) ## \$1\$1call\$1\$1(frame, old\$1name, new\$1name, transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0) 在 `DynamicFrame` 内重命名一个节点。 + `frame` – 在其中重命名节点的 `DynamicFrame` (必需)。 + `old_name` – 要重命名的节点的完整路径（必需）。如果旧名称中包含点，则 RenameField 将不起作用，除非使用反引号（````）将其引起来。例如，要将 `this.old.name` 替换为 `thisNewName`，您需要调用 RenameField，如下所示： ``` newDyF = RenameField(oldDyF, "`this.old.name`", "thisNewName") ``` + `new_name` – 新名称，其中包括完整路径（必需）。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与转换中的错误关联的字符串 (可选)。 + `stageThreshold` – 在转换出错之前可能在其中发生的最大错误数（可选）。默认值为 0。 + `totalThreshold` – 在处理出错之前可能全面发生的最大错误数（可选）。默认值为 0。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # ResolveChoice 类解析 `DynamicFrame` 内的选择类型。 ## 示例我们建议您使用 [`DynamicFrame.resolveChoice()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-resolveChoice) 方法来处理 `DynamicFrame` 中包含多种类型的字段。要查看代码示例，请参阅 [示例：使用 resolveChoice 处理包含多种类型的列](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-resolveChoice-example)。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-ResolveChoice-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-ResolveChoice-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-ResolveChoice-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-ResolveChoice-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-ResolveChoice-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-ResolveChoice-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-ResolveChoice-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-ResolveChoice-describe) ## \$1\$1call\$1\$1(frame, specs = none, choice = "", transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0) 提供有关解析 `DynamicFrame` 内歧义类型的信息。它返回生成的 `DynamicFrame`。 + `frame` – 在其中解析选择类型的 `DynamicFrame` (必需)。 + `specs` – 要解析的特定歧义列表，每个歧义均采用元组形式：`(path, action)`。`path` 值标识特定歧义元素，`action` 值标识相应解析。只能使用 `spec` 和 `choice` 参数之一。如果 `spec` 参数不为 `None`，则 `choice` 参数必须为空字符串。反过来，如果 `choice` 不为空字符串，则 `spec` 参数必须为 `None`。如果两个参数均未提供，则 AWS Glue 尝试解析架构并用它来解析歧义。 `specs` 元组的 `action` 部分可以指定以下解析策略之一： + `cast` – 允许指定一种要强制转换到的类型（例如，`cast:int`）。 + `make_cols` – 通过展平数据来解析潜在的歧义。例如，如果 `columnA` 是 `int` 或 `string`，则解析就是在结果 `DynamicFrame` 中生成名为 `columnA_int` 和 `columnA_string` 的两个列。 + `make_struct` – 通过用一种结构表示数据来解析潜在的歧义。例如，如果某个列中的数据是 `int` 或 `string`，则使用 `make_struct` 操作会在结果 `DynamicFrame` 中生成结构列，而每个结构都同时包含 `int` 和 `string`。 + `project` – 通过仅在结果 `DynamicFrame` 中保留指定类型的值来解析潜在的歧义。例如，如果 `ChoiceType` 列中的数据可以是 `int` 或 `string`，则指定 `project:string` 操作会从结果 `DynamicFrame` 中删除非 `string` 类型的值。如果 `path` 识别到数组，则在数组名称后放置一个空的方括号可避免歧义。例如，假设您正在使用结构如下的数据： ``` "myList": [ { "price": 100.00 }, { "price": "$100.00" } ] ``` 可以通过将 `path` 设置为 `"myList[].price"`、将 `action` 设置为 `"cast:double"` 来选择价格的数字而非字符串版本。 + `choice` – `specs` 参数为 `None` 时的默认解析操作。如果 `specs` 参数不为 `None`，则只能将此项设置为空字符串，不能设置为其他值。除了先前描述的 `specs` 操作外，此参数还支持以下操作： + `MATCH_CATALOG` – 尝试将每个 `ChoiceType` 转换为指定数据目录表中的对应类型。 + `database` – 用于 `MATCH_CATALOG` 选择的 AWS Glue Data Catalog 数据库（对于 `MATCH_CATALOG` 是必需的）。 + `table_name` – 用于 `MATCH_CATALOG` 操作的 AWS Glue Data Catalog 表名称（对于 `MATCH_CATALOG` 是必需的）。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与转换中的错误关联的字符串 (可选)。 + `stageThreshold` – 在转换出错之前可能在其中发生的最大错误数（可选）。默认值为 0。 + `totalThreshold` – 在处理出错之前可能全面发生的最大错误数（可选）。默认值为 0。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # SelectFields 类 `SelectFields` 类在现有的 `DynamicFrame` 中创建新 `DynamicFrame`，并且只保留您指定的字段。`SelectFields` 提供与 SQL `SELECT` 语句类似的功能。 ## 示例我们建议您使用 [`DynamicFrame.select_fields()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-select_fields) 方法从 `DynamicFrame` 中选择字段。要查看代码示例，请参阅 [示例：使用 select\$1fields 以利用选定字段创建新 `DynamicFrame`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-select_fields-example)。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-SelectFields-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-SelectFields-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-SelectFields-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-SelectFields-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-SelectFields-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-SelectFields-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-SelectFields-describeErrors) + [描述](#aws-glue-api-crawler-pyspark-transforms-SelectFields-describe) ## \$1\$1call\$1\$1(frame, paths, transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0) 获取 `DynamicFrame` 中的字段 (节点)。 + `frame` – 要在其中选择字段的 `DynamicFrame`（必需）。 + `paths` – 要选择的字段的完整路径的列表 (必需)。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与转换中的错误关联的字符串（可选）。 + `stageThreshold` – 在转换出错之前可能在其中发生的最大错误数（可选）。默认值为 0。 + `totalThreshold` – 在处理出错之前可能全面发生的最大错误数（可选）。默认值为 0。返回仅包含指定字段的新 `DynamicFrame`。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # SelectFromCollection 类选择 `DynamicFrameCollection` 中的一个 `DynamicFrame`。 ## 示例此示例使用 `SelectFromCollection` 从 `DynamicFrameCollection` 中选择 `DynamicFrame`。 **示例数据集** 该示例从名为 `split_rows_collection` 的 `DynamicFrameCollection` 中选择了两个 `DynamicFrames`。以下是 `split_rows_collection` 中的键列表。 ``` dict_keys(['high', 'low']) ``` **示例代码** ``` # Example: Use SelectFromCollection to select # DynamicFrames from a DynamicFrameCollection from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.transforms import SelectFromCollection # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Select frames and inspect entries frame_low = SelectFromCollection.apply(dfc=split_rows_collection, key="low") frame_low.toDF().show() frame_high = SelectFromCollection.apply(dfc=split_rows_collection, key="high") frame_high.toDF().show() ``` ### 输出 ``` +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 1| 0| fax| 202-225-3307| | 1| 1| phone| 202-225-5731| | 2| 0| fax| 202-225-3307| | 2| 1| phone| 202-225-5731| | 3| 0| fax| 202-225-3307| | 3| 1| phone| 202-225-5731| | 4| 0| fax| 202-225-3307| | 4| 1| phone| 202-225-5731| | 5| 0| fax| 202-225-3307| | 5| 1| phone| 202-225-5731| | 6| 0| fax| 202-225-3307| | 6| 1| phone| 202-225-5731| | 7| 0| fax| 202-225-3307| | 7| 1| phone| 202-225-5731| | 8| 0| fax| 202-225-3307| | 8| 1| phone| 202-225-5731| | 9| 0| fax| 202-225-3307| | 9| 1| phone| 202-225-5731| | 10| 0| fax| 202-225-6328| | 10| 1| phone| 202-225-4576| +---+-----+------------------------+-------------------------+ only showing top 20 rows +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 11| 0| fax| 202-225-6328| | 11| 1| phone| 202-225-4576| | 11| 2| twitter| RepTrentFranks| | 12| 0| fax| 202-225-6328| | 12| 1| phone| 202-225-4576| | 12| 2| twitter| RepTrentFranks| | 13| 0| fax| 202-225-6328| | 13| 1| phone| 202-225-4576| | 13| 2| twitter| RepTrentFranks| | 14| 0| fax| 202-225-6328| | 14| 1| phone| 202-225-4576| | 14| 2| twitter| RepTrentFranks| | 15| 0| fax| 202-225-6328| | 15| 1| phone| 202-225-4576| | 15| 2| twitter| RepTrentFranks| | 16| 0| fax| 202-225-6328| | 16| 1| phone| 202-225-4576| | 16| 2| twitter| RepTrentFranks| | 17| 0| fax| 202-225-6328| | 17| 1| phone| 202-225-4576| +---+-----+------------------------+-------------------------+ only showing top 20 rows ``` ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-SelectFromCollection-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-SelectFromCollection-apply) + [名称](#aws-glue-api-crawler-pyspark-transforms-SelectFromCollection-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-SelectFromCollection-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-SelectFromCollection-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-SelectFromCollection-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-SelectFromCollection-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-SelectFromCollection-describe) ## \$1\$1call\$1\$1(dfc, key, transformation\$1ctx = "") 获取 `DynamicFrameCollection` 中的一个 `DynamicFrame`。 + `dfc` – 应从中选择 `DynamicFrame` 的 `DynamicFrameCollection`（必需）。 + `key` – 要选择的 `DynamicFrame` 的密钥 (必需)。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # Simplify\$1ddb\$1json 类简化 `DynamicFrame` 中的嵌套列，其具体位于 DynamoDB JSON 结构中，并返回一个新的简化 `DynamicFrame`。 ## 示例我们建议使用 `DynamicFrame.simplify_ddb_json()` 方法来简化 `DynamicFrame` 中的嵌套列，该列特别位于 DynamoDB JSON 结构中。要查看代码示例，请参阅 [示例：使用 simplify\$1ddb\$1json 调用 DynamoDB JSON simplify 命令](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-simplify-ddb-json-example)。 # Spigot 类将示例记录写入指定的目标，以帮助您验证 AWS Glue 作业执行的转换。 ## 示例我们建议您使用 [`DynamicFrame.spigot()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-spigot) 方法将 `DynamicFrame` 中的记录子集写入指定的目标。要查看代码示例，请参阅 [示例：使用 spigot 将 `DynamicFrame` 中的示例字段写入 Amazon S3](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-spigot-example)。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-spigot-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-spigot-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-spigot-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-spigot-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-spigot-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-spigot-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-spigot-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-spigot-describe) ## \$1\$1call\$1\$1(frame, path, options, transformation\$1ctx = "") 在转换期间将示例记录写入指定的目标。 + `frame` – 要执行 spigot 操作的 `DynamicFrame` (必需)。 + `path` – 要写入的目标的路径（必需）。 + `options` – 指定选项的 JSON 键值对（可选）。`"topk"` 选项指定应写入的第一个 *k* 记录。`"prob"` 选项指定选择任何给定记录的可能性（以十进制数字形式表示）。您可以在选择要写入的记录时使用它。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply) ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name) ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs) ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn) ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform) ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors) ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe) # SplitFields 类按指定字段将一个 `DynamicFrame` 拆分成两个新项。 ## 示例我们建议您使用 [`DynamicFrame.split_fields()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-split_fields) 方法拆分 `DynamicFrame` 中的字段。要查看代码示例，请参阅 [示例：使用 split\$1fields 将选定字段拆分为单独的 `DynamicFrame`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-split_fields-example)。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-SplitFields-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-SplitFields-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-SplitFields-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-SplitFields-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-SplitFields-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-SplitFields-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-SplitFields-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-SplitFields-describe) ## \$1\$1call\$1\$1(frame, paths, name1 = none, name2 = none, transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0) 将 `DynamicFrame` 中的一个或多个字段拆分成新的 `DynamicFrame` 并创建另一个包含保留字段的新 `DynamicFrame`。 + `frame` – 要拆分到新 DynamicFrame 中的源 `DynamicFrame` (必需)。 + `paths` – 要拆分的字段的完整路径的列表 (必需)。 + `name1` – 要为将包含要拆分的字段的 `DynamicFrame` 分配的名称（可选）。如果没有提供名称，则会使用源框架的名称并附加“1”。 + `name2` – 要为将包含在指定字段拆分后仍保留的字段的 `DynamicFrame` 分配的名称（可选）。如果没有提供名称，则会使用源框架的名称并附加“2”。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与转换中的错误关联的字符串 (可选)。 + `stageThreshold` – 在转换出错之前可能在其中发生的最大错误数（可选）。默认值为 0。 + `totalThreshold` – 在处理出错之前可能全面发生的最大错误数（可选）。默认值为 0。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # SplitRows 类创建一个包含两个 `DynamicFrames` 的 `DynamicFrameCollection`。一个 `DynamicFrame` 仅包含要拆分的指定行，另一个包含所有剩余行。 ## 示例我们建议您使用 [`DynamicFrame.split_rows()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-split_rows) 方法拆分 `DynamicFrame` 中的行。要查看代码示例，请参阅 [示例：使用 split\$1rows 拆分 `DynamicFrame` 中的行](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-split_rows-example)。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-SplitRows-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-SplitRows-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-SplitRows-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-SplitRows-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-SplitRows-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-SplitRows-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-SplitRows-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-SplitRows-describe) ## \$1\$1call\$1\$1(frame, comparison\$1dict, name1="frame1", name2="frame2", transformation\$1ctx = "", info = none, stageThreshold = 0, totalThreshold = 0) 将 `DynamicFrame` 中的一个或多个行拆分到新的 `DynamicFrame` 中。 + `frame` – 要拆分到新 DynamicFrame 中的源 `DynamicFrame` (必需)。 + `comparison_dict` – 一个词典，其中的键是到一个列的完整路径，值是另一个词典，用于将比较器映射到与该列值所比较的值。例如，`{"age": {">": 10, "<": 20}}` 拆分“age”值介于 10 和 20 之间的行，不包括“age”在范围之外的行 (必需)。 + `name1` – 要为将包含要拆分的行的 `DynamicFrame` 分配的名称 (可选)。 + `name2` – 要为将包含在指定行拆分后仍保留的行的 `DynamicFrame` 分配的名称 (可选)。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与转换中的错误关联的字符串 (可选)。 + `stageThreshold` – 在转换出错之前可能在其中发生的最大错误数（可选）。默认值为 0。 + `totalThreshold` – 在处理出错之前可能全面发生的最大错误数（可选）。默认值为 0。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # Unbox 类取消装箱（重新格式化）`DynamicFrame` 中的字符串字段。 ## 示例我们建议您使用 [`DynamicFrame.unbox()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-unbox) 方法取消装箱 `DynamicFrame` 中的字段。要查看代码示例，请参阅 [示例：使用 unbox 将字符串字段拆开为结构](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-unbox-example)。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-Unbox-__call__) + [applyapply](#aws-glue-api-crawler-pyspark-transforms-Unbox-apply) + [namename](#aws-glue-api-crawler-pyspark-transforms-Unbox-name) + [describeArgsdescribeArgs](#aws-glue-api-crawler-pyspark-transforms-Unbox-describeArgs) + [describeReturndescribeReturn](#aws-glue-api-crawler-pyspark-transforms-Unbox-describeReturn) + [describeTransformdescribeTransform](#aws-glue-api-crawler-pyspark-transforms-Unbox-describeTransform) + [describeErrorsdescribeErrors](#aws-glue-api-crawler-pyspark-transforms-Unbox-describeErrors) + [describedescribe](#aws-glue-api-crawler-pyspark-transforms-Unbox-describe) ## \$1\$1call\$1\$1(frame, path, format, transformation\$1ctx = "", info="", stageThreshold=0, totalThreshold=0, \$1\$1options) 拆开 `DynamicFrame` 中的字符串字段。 + `frame` – 要在其中拆开字段的 `DynamicFrame`（必需）。 + `path` – 要拆开的 `StringNode` 的完整路径 (必需)。 + `format` – 格式规范（可选）。这用于 Amazon S3 或支持多种格式的 AWS Glue 连接。相关受支持的格式，请参阅 [AWS Glue for Spark 中的输入和输出的数据格式选项](aws-glue-programming-etl-format.md)。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与转换中的错误关联的字符串 (可选)。 + `stageThreshold` – 在转换出错之前可能在其中发生的最大错误数（可选）。默认值为 0。 + `totalThreshold` – 在处理出错之前可能全面发生的最大错误数（可选）。默认值为 0。 + `separator` – 分隔符令牌 (可选)。 + `escaper` – 转义令牌 (可选)。 + `skipFirst` – 如果应该跳过第一行数据，则为 `True`，如果不应跳过，则为 `False` (可选)。 + withSchema`` – 一个字符串，其中包含要拆开的数据的架构（可选）。应始终使用 `StructType.json` 创建它。 + `withHeader` – 如果要解包的数据包含标头，则为 `True`，否则为 `False` (可选)。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # UnnestFrame 类取消嵌套 `DynamicFrame`，将嵌套的对象展平到顶级元素，并为数组对象生成联接键。 ## 示例我们建议您使用 [`DynamicFrame.unnest()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-unnest) 方法展平 `DynamicFrame` 中的嵌套结构。要查看代码示例，请参阅 [示例：使用 unnest 将嵌套字段转换为顶级字段](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-unnest-example)。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-UnnestFrame-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-UnnestFrame-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-UnnestFrame-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-UnnestFrame-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-UnnestFrame-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-UnnestFrame-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-UnnestFrame-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-UnnestFrame-describe) ## \$1\$1call\$1\$1(frame, transformation\$1ctx = "", info="", stageThreshold=0, totalThreshold=0) 取消嵌套 `DynamicFrame`，将嵌套的对象展平到顶级元素，并为数组对象生成联接键。 + `frame` – 要取消嵌套的 `DynamicFrame` (必需)。 + `transformation_ctx` – 用于标识状态信息的唯一字符串 (可选)。 + `info` – 与转换中的错误关联的字符串 (可选)。 + `stageThreshold` – 在转换出错之前可能在其中发生的最大错误数（可选）。默认值为 0。 + `totalThreshold` – 在处理出错之前可能全面发生的最大错误数（可选）。默认值为 0。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # FlagDuplicatesInColumn 类 `FlagDuplicatesInColumn` 转换会返回一个新列，每行都有指定值，指示该行的源列中的值是否与源列前面的行中的值匹配。找到匹配项后，它们会被标记为重复项。第一次出现不会被标记，因为它与前面的行不匹配。 ## 示例 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * sc = SparkContext() spark = SparkSession(sc) datasource1 = spark.read.json("s3://${BUCKET}/json/zips/raw/data") try: df_output = column.FlagDuplicatesInColumn.apply( data_frame=datasource1, spark_context=sc, source_column="city", target_column="flag_col", true_string="True", false_string="False" ) except: print("Unexpected Error happened ") raise ``` ## Output `FlagDuplicatesInColumn` 转换会将新列“flag\$1col”添加至“df\$1output”DataFrame。此列将包含一个字符串值，表示相应行在“city”列中是否有重复的值。如果某行具有重复的“city”值，则“flag\$1col”将包含“true\$1string”值“True”。如果某行具有唯一的“city”值，则“flag\$1col”将包含“false\$1string”值“False”。生成的“df\$1output”DataFrame 将包含原始“datasource1”DataFrame 中的所有列，以及用于表示重复的“city”值的“flag\$1col”附加列。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-FlagDuplicatesInColumn-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicatesInColumn-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicatesInColumn-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicatesInColumn-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicatesInColumn-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicatesInColumn-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicatesInColumn-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicatesInColumn-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, source\$1column, target\$1column, true\$1string=DEFAULT\$1TRUE\$1STRING, false\$1string=DEFAULT\$1FALSE\$1STRING) `FlagDuplicatesInColumn` 转换会返回一个新列，每行都有指定值，指示该行的源列中的值是否与源列前面的行中的值匹配。找到匹配项后，它们会被标记为重复项。第一次出现不会被标记，因为它与前面的行不匹配。 + `source_column` – 源列的名称。 + `target_column` – 目标列的名称。 + `true_string` – 当源列的值与该列中前面的值重复时，在目标列中插入该字符串。 + `false_string` – 当源列的值与该列中前面的值不同时，在目标列中插入该字符串。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # FormatPhoneNumber 类 `FormatPhoneNumber` 转换会返回一列，其中将电话号码字符串转换为格式化值。 ## 示例 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * sc = SparkContext() spark = SparkSession(sc) input_df = spark.createDataFrame( [ ("408-341-5669",), ("4083415669",) ], ["phone"], ) try: df_output = column_formatting.FormatPhoneNumber.apply( data_frame=input_df, spark_context=sc, source_column="phone", default_region="US" ) df_output.show() except: print("Unexpected Error happened ") raise ``` ## Output 输出是： ``` ``` +---------------+ | phone| +---------------+ |(408) 341-5669| |(408) 341-5669| +---------------+ ``` ``` `FormatPhoneNumber` 转换会将“source\$1column”设为“"phone"”，将“default\$1region”设为“"US"”。该转换可成功地将两个电话号码（无论其初始格式如何）格式化为标准的美国格式“(408) 341-5669”。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-FormatPhoneNumber-__call__) + [applyapply](#aws-glue-api-crawler-pyspark-transforms-FormatPhoneNumber-apply) + [namename](#aws-glue-api-crawler-pyspark-transforms-FormatPhoneNumber-name) + [describeArgsdescribeArgs](#aws-glue-api-crawler-pyspark-transforms-FormatPhoneNumber-describeArgs) + [describeReturndescribeReturn](#aws-glue-api-crawler-pyspark-transforms-FormatPhoneNumber-describeReturn) + [describeTransformdescribeTransform](#aws-glue-api-crawler-pyspark-transforms-FormatPhoneNumber-describeTransform) + [describeErrorsdescribeErrors](#aws-glue-api-crawler-pyspark-transforms-FormatPhoneNumber-describeErrors) + [describedescribe](#aws-glue-api-crawler-pyspark-transforms-FormatPhoneNumber-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, source\$1column, phone\$1number\$1format=None, default\$1region=None, default\$1region\$1column=None) `FormatPhoneNumber` 转换会返回一列，其中将电话号码字符串转换为格式化值。 + `source_column`：现有列的名称。 + `phone_number_format` – 将电话号码转换为该格式。如果未指定格式，则默认为国际公认的标准电话号码格式 `E.164`。有效值包括： + E164（省略 E 之后的句点） + `default_region` – 由两个或三个大写字母组成的有效区域代码，当电话号码本身不包含国家/地区代码时，该代码将指定电话号码所在的地区。最多只能提供 `defaultRegion` 或 `defaultRegionColumn` 中的一个。 + `default_region_column` – 高级数据类型 `Country` 的列的名称。当电话号码本身不包含国家/地区代码时，指定列中的区域代码将用于确定电话号码的国家/地区代码。最多只能提供 `defaultRegion` 或 `defaultRegionColumn` 中的一个。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # FormatCase 类 `FormatCase` 转换会将列中的每个字符串更改为指定的大小写类型。 ## 示例 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * sc = SparkContext() spark = SparkSession(sc) datasource1 = spark.read.json("s3://${BUCKET}/json/zips/raw/data") try: df_output = data_cleaning.FormatCase.apply( data_frame=datasource1, spark_context=sc, source_column="city", case_type="LOWER" ) except: print("Unexpected Error happened ") raise ``` ## Output `FormatCase` 转换会根据“case\$1type="LOWER"”参数将“city”列中的值转换为小写字母。生成的“df\$1output”DataFrame 将包含原始“datasource1”DataFrame 中的所有列，但“city”列的值为小写。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-FormatCase-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-FormatCase-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-FormatCase-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-FormatCase-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-FormatCase-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-FormatCase-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-FormatCase-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-FormatCase-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, source\$1column, case\$1type) `FormatCase` 转换会将列中的每个字符串更改为指定的大小写类型。 + `source_column`：现有列的名称。 + `case_type` – 支持的大小写类型为 `CAPITAL`、`LOWER`、`UPPER`、`SENTENCE`。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # FillWithMode 类 `FillWithMode` 转换会根据您指定的电话号码格式设置列的格式。您也可以指定决定项逻辑，其中一些值是相同的。例如，考虑以下情况：`1 2 2 3 3 4` `MINIMUM` modeType 导致 `FillWithMode` 返回 2 作为模式值。如果 modeType 为 `MAXIMUM`，则模式为 3。如果是 `AVERAGE`，模式为 2.5。 ## 示例 ``` from awsglue.context import * from pyspark.sql import SparkSession from awsgluedi.transforms import * sc = SparkContext() spark = SparkSession(sc) input_df = spark.createDataFrame( [ (105.111, 13.12), (1055.123, 13.12), (None, 13.12), (13.12, 13.12), (None, 13.12), ], ["source_column_1", "source_column_2"], ) try: df_output = data_quality.FillWithMode.apply( data_frame=input_df, spark_context=sc, source_column="source_column_1", mode_type="MAXIMUM" ) df_output.show() except: print("Unexpected Error happened ") raise ``` ## Output 给定代码的输出如下： ``` ``` +---------------+---------------+ |source_column_1|source_column_2| +---------------+---------------+ | 105.111| 13.12| | 1055.123| 13.12| | 1055.123| 13.12| | 13.12| 13.12| | 1055.123| 13.12| +---------------+---------------+ ``` ``` “awsglue.data\$1quality”模块的 `FillWithMode` 转换应用于“input\$1df”DataFrame。它将 `source_column_1` 列中的“null”值替换为该列中非 null 值中的最大值（“mode\$1type="MAXIMUM"”）。在本例中，`source_column_1` 列中的最大值为“1055.123”。因此，在输出 DataFrame“df\$1output”中，`source_column_1` 中的“null”值被替换为“1055.123”。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-FillWithMode-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-FillWithMode-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-FillWithMode-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-FillWithMode-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-FillWithMode-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-FillWithMode-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-FillWithMode-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-FillWithMode-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, source\$1column, mode\$1type) `FillWithMode` 转换会格式化列中字符串的大小写。 + `source_column`：现有列的名称。 + `mode_type` – 如何解析数据中的平局值。此值必须是 `MINIMUM`、`NONE`、`AVERAGE` 或 `MAXIMUM` 其中之一。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # FlagDuplicateRows 类 `FlagDuplicateRows` 转换会返回一个新列，其中每行都有指定值，指示该行是否与数据集中的前面的行完全匹配。找到匹配项后，它们会被标记为重复项。第一次出现不会被标记，因为它与前面的行不匹配。 ## 示例 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * sc = SparkContext() spark = SparkSession(sc) input_df = spark.createDataFrame( [ (105.111, 13.12), (13.12, 13.12), (None, 13.12), (13.12, 13.12), (None, 13.12), ], ["source_column_1", "source_column_2"], ) try: df_output = data_quality.FlagDuplicateRows.apply( data_frame=input_df, spark_context=sc, target_column="flag_row", true_string="True", false_string="False", target_index=1 ) except: print("Unexpected Error happened ") raise ``` ## Output 输出是 PySpark DataFrame 以及一个附加列 `flag_row`，其根据 `source_column_1` 列指示某行是否重复。生成的“df\$1output”DataFrame 将包含以下行： ``` ``` +---------------+---------------+--------+ |source_column_1|source_column_2|flag_row| +---------------+---------------+--------+ | 105.111| 13.12| False| | 13.12| 13.12| True| | null| 13.12| True| | 13.12| 13.12| True| | null| 13.12| True| +---------------+---------------+--------+ ``` ``` `flag_row` 列指示某行是否重复。“true\$1string”设置为“True”，“false\$1string”设置为“False”。“target\$1index”设置为 1，这表示 `flag_row` 列将被插入到输出 DataFrame 的第二个位置（指数 1）。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-FlagDuplicateRows-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicateRows-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicateRows-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicateRows-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicateRows-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicateRows-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicateRows-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicateRows-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, target\$1column, true\$1string=DEFAULT\$1TRUE\$1STRING, false\$1string=DEFAULT\$1FALSE\$1STRING, target\$1index=None) `FlagDuplicateRows` 转换会返回一个新列，其中每行都有指定值，指示该行是否与数据集中的前面的行完全匹配。找到匹配项后，它们会被标记为重复项。第一次出现不会被标记，因为它与前面的行不匹配。 + `true_string` – 如果该行与前面的行匹配，则插入该值。 + `false_string` – 如果行是唯一的，则插入该值。 + `target_column` – 插入到数据集中的新列的名称。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # RemoveDuplicates 类如果在选定的源列中遇到重复值，则 `RemoveDuplicates` 转换会删除整行。 ## 示例 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * sc = SparkContext() spark = SparkSession(sc) input_df = spark.createDataFrame( [ (105.111, 13.12), (13.12, 13.12), (None, 13.12), (13.12, 13.12), (None, 13.12), ], ["source_column_1", "source_column_2"], ) try: df_output = data_quality.RemoveDuplicates.apply( data_frame=input_df, spark_context=sc, source_column="source_column_1" ) except: print("Unexpected Error happened ") raise ``` ## Output 输出是 PySpark DataFrame，其中根据 `source_column_1` 列删除了重复项。生成的“df\$1output”DataFrame 将包含以下行： ``` ``` +---------------+---------------+ |source_column_1|source_column_2| +---------------+---------------+ | 105.111| 13.12| | 13.12| 13.12| | null| 13.12| +---------------+---------------+ ``` ``` 请注意，`source_column_1` 值为“13.12”和“null”的行在输出 DataFrame 中仅会出现一次，因为已根据 `source_column_1` 列删除了重复项。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-RemoveDuplicates-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-RemoveDuplicates-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-RemoveDuplicates-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-RemoveDuplicates-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-RemoveDuplicates-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-RemoveDuplicates-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-RemoveDuplicates-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-RemoveDuplicates-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, source\$1column) 如果在选定的源列中遇到重复值，则 `RemoveDuplicates` 转换会删除整行。 + `source_column`：现有列的名称。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # MonthName 类 `MonthName` 转换会使用表示日期的字符串创建一个包含月份名称的新列。 ## 示例 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * sc = SparkContext() spark = SparkSession(sc) spark.conf.set("spark.sql.legacy.timeParserPolicy", "LEGACY") input_df = spark.createDataFrame( [ ("20-2018-12",), ("2018-20-12",), ("20182012",), ("12202018",), ("20122018",), ("20-12-2018",), ("12/20/2018",), ("02/02/02",), ("02 02 2009",), ("02/02/2009",), ("August/02/2009",), ("02/june/2009",), ("02/2020/june",), ("2013-02-21 06:35:45.658505",), ("August 02 2009",), ("2013/02/21",), (None,), ], ["column_1"], ) try: df_output = datetime_functions.MonthName.apply( data_frame=input_df, spark_context=sc, source_column="column_1", target_column="target_column" ) df_output.show() except: print("Unexpected Error happened ") raise ``` ## Output 输出是： ``` ``` +------------+------------+ | column_1|target_column| +------------+------------+ |20-2018-12 | December | |2018-20-12 | null | | 20182012| null | | 12202018| null | | 20122018| null | |20-12-2018 | December | |12/20/2018 | December | | 02/02/02 | February | |02 02 2009 | February | |02/02/2009 | February | |August/02/2009| August | |02/june/2009| null | |02/2020/june| null | |2013-02-21 06:35:45.658505| February | |August 02 2009| August | | 2013/02/21| February | | null | null | +------------+------------+ ``` ``` `MonthName` 转换会将“source\$1column”设为“column\$11”，将“target\$1column”设为“target\$1column”。它会尝试从“column\$11”列中的日期/时间字符串中提取月份名称，并将其放在“target\$1column”列中。如果日期/时间字符串的格式无法识别或无法解析，则“target\$1column”的值将设置为“null”。该转换可成功地从各种日期/时间格式中提取月份名称，例如“20-12-2018”、“12/20/2018”、“02/02/2009”、“2013-02-21 06:35:45.658505”和“August 02 2009”。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-MonthName-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-MonthName-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-MonthName-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-MonthName-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-MonthName-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-MonthName-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-MonthName-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-MonthName-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, target\$1column, source\$1column=None, value=None) `MonthName` 转换会使用表示日期的字符串创建一个包含月份名称的新列。 + `source_column`：现有列的名称。 + `value` – 要评估的字符串。 + `target_column` – 新创建的列的名称。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # IsEven 类 `IsEven` 转换会在新列中返回布尔值，用于指示源列或值是否为偶数。如果源列或值为十进制，则结果为 false。 ## 示例 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * sc = SparkContext() spark = SparkSession(sc) input_df = spark.createDataFrame( [(5,), (0,), (-1,), (2,), (None,)], ["source_column"], ) try: df_output = math_functions.IsEven.apply( data_frame=input_df, spark_context=sc, source_column="source_column", target_column="target_column", value=None, true_string="Even", false_string="Not even", ) df_output.show() except: print("Unexpected Error happened ") raise ``` ## Output 输出是： ``` ``` +------------+------------+ |source_column|target_column| +------------+------------+ | 5| Not even| | 0| Even| | -1| Not even| | 2| Even| | null| null| +------------+------------+ ``` ``` `IsEven` 转换会将“source\$1column”设为“source\$1column”，将“target\$1column”设为“target\$1column”。它会检查“source\$1column”中的值是否为偶数。如果该值为偶数，则会将“target\$1column”的值设置为“true\$1string”、“Even”。如果该值为奇数，则会将“target\$1column”的值设置为“false\$1string”、“Not even”。如果“source\$1column”的值为“null”，则“target\$1column”的值将设置为“null”。该转换可以正确识别偶数（0 和 2），并将“target\$1column”的值设置为“Even”。对于奇数（5 和 -1），它会将“target\$1column”的值设置为“Not even”。对于“source\$1column”中的“null”值，“target\$1column”的值会设置为“null”。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-IsEven-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-IsEven-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-IsEven-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-IsEven-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-IsEven-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-IsEven-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-IsEven-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-IsEven-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, target\$1column, source\$1column=None, true\$1string=DEFAULT\$1TRUE\$1STRING, false\$1string=DEFAULT\$1FALSE\$1STRING, value=None) `IsEven` 转换会在新列中返回布尔值，用于指示源列或值是否为偶数。如果源列或值为十进制，则结果为 false。 + `source_column`：现有列的名称。 + `target_column` – 要创建的新列的名称。 + `true_string`：指示值是否为偶数的字符串。 + `false_string` – 表示该值是否不为偶数的字符串。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # CryptographicHash 类 `CryptographicHash` 转换会将算法应用于列中的哈希值。 ## 示例 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * secret = "${SECRET}" sc = SparkContext() spark = SparkSession(sc) input_df = spark.createDataFrame( [ (1, "1234560000"), (2, "1234560001"), (3, "1234560002"), (4, "1234560003"), (5, "1234560004"), (6, "1234560005"), (7, "1234560006"), (8, "1234560007"), (9, "1234560008"), (10, "1234560009"), ], ["id", "phone"], ) try: df_output = pii.CryptographicHash.apply( data_frame=input_df, spark_context=sc, source_columns=["id", "phone"], secret_id=secret, algorithm="HMAC_SHA256", output_format="BASE64", ) df_output.show() except: print("Unexpected Error happened ") raise ``` ## Output 输出是： ``` ``` +---+------------+-------------------+-------------------+ | id| phone | id_hashed | phone_hashed | +---+------------+-------------------+-------------------+ | 1| 1234560000 | QUI1zXTJiXmfIb... | juDBAmiRnnO3g... | | 2| 1234560001 | ZAUWiZ3dVTzCo... | vC8lgUqBVDMNQ... | | 3| 1234560002 | ZP4VvZWkqYifu... | Kl3QAkgswYpzB... | | 4| 1234560003 | 3u8vO3wQ8EQfj... | CPBzK1P8PZZkV... | | 5| 1234560004 | eWkQJk4zAOIzx... | aLf7+mHcXqbLs... | | 6| 1234560005 | xtI9fZCJZCvsa... | dy2DFgdYWmr0p... | | 7| 1234560006 | iW9hew7jnHuOf... | wwfGMCOEv6oOv... | | 8| 1234560007 | H9V1pqvgkFhfS... | g9WKhagIXy9ht... | | 9| 1234560008 | xDhEuHaxAUbU5... | b3uQLKPY+Q5vU... | | 10| 1234560009 | GRN6nFXkxk349... | VJdsKt8VbxBbt... | +---+------------+-------------------+-------------------+ ``` ``` 该转换使用指定的算法和密钥计算“id”和“phone”列中值的加密哈希值，并以 Base64 格式对哈希进行编码。生成的“df\$1output”DataFrame 包含原始“input\$1df”DataFrame 中的所有列，以及带有计算哈希值的附加“id\$1hashed”和“phone\$1hashed”列。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-CryptographicHash-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-CryptographicHash-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-CryptographicHash-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-CryptographicHash-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-CryptographicHash-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-CryptographicHash-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-CryptographicHash-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-CryptographicHash-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, source\$1columns, secret\$1id, algorithm=None, secret\$1version=None, create\$1secret\$1if\$1missing=False, output\$1format=None, entity\$1type\$1filter=None) `CryptographicHash` 转换会将算法应用于列中的哈希值。 + `source_columns`：现有列的数组。 + `secret_id` – Secrets Manager 密钥的 ARN。在 HMAC 散列消息认证码前缀算法中用于对源列进行哈希处理的密钥。 + `secret_version`：可选。默认为最新的密钥版本。 + `entity_type_filter` – 可选的实体类型数组。可仅用于加密自由文本列中检测到的 PII。 + `create_secret_if_missing` – 可选布尔值。如果为 true，将尝试代表调用者创建密钥。 + `algorithm` – 用于对数据进行哈希处理的算法。有效的 enum 值：MD5、SHA1、SHA256、SHA512、HMAC\$1MD5、HMAC\$1SHA1、HMAC\$1SHA256、HMAC\$1SHA512。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # 解密类 `Decrypt` 转换会在 AWS Glue 内部解密。您也可以使用 AWS Encryption SDK 在 AWS Glue 之外解密数据。如果提供的 KMS 密钥 ARN 与用于加密列的密钥不匹配，则解密操作将失败。 ## 示例 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * kms = "${KMS}" sc = SparkContext() spark = SparkSession(sc) input_df = spark.createDataFrame( [ (1, "1234560000"), (2, "1234560001"), (3, "1234560002"), (4, "1234560003"), (5, "1234560004"), (6, "1234560005"), (7, "1234560006"), (8, "1234560007"), (9, "1234560008"), (10, "1234560009"), ], ["id", "phone"], ) try: df_encrypt = pii.Encrypt.apply( data_frame=input_df, spark_context=sc, source_columns=["phone"], kms_key_arn=kms ) df_decrypt = pii.Decrypt.apply( data_frame=df_encrypt, spark_context=sc, source_columns=["phone"], kms_key_arn=kms ) df_decrypt.show() except: print("Unexpected Error happened ") raise ``` ## Output 输出是 PySpark DataFrame，其中包含原始的“id”列和经解密的“phone”列： ``` ``` +---+------------+ | id| phone| +---+------------+ | 1| 1234560000| | 2| 1234560001| | 3| 1234560002| | 4| 1234560003| | 5| 1234560004| | 6| 1234560005| | 7| 1234560006| | 8| 1234560007| | 9| 1234560008| | 10| 1234560009| +---+------------+ ``` ``` `Encrypt` 转换会将“source\$1columns”设为“["phone"]”，将“kms\$1key\$1arn”设为“\$1\$1KMS\$1”环境变量的值。该转换使用指定的 KMS 密钥对“phone”列中的值进行加密。然后，经加密的 DataFrame“df\$1encrypt”从“awsglue.pii”模块传递给 `Decrypt` 转换。它会将“source\$1columns”设为“["phone"]”，将“kms\$1key\$1arn”设为“\$1\$1KMS\$1”环境变量的值。该转换使用相同的 KMS 密钥解密“phone”列中的加密值。生成的“df\$1decrypt”DataFrame 包含原始的“id”列和经解密的“phone”列。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-Decrypt-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-Decrypt-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-Decrypt-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-Decrypt-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-Decrypt-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-Decrypt-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-Decrypt-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-Decrypt-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, source\$1columns, kms\$1key\$1arn) `Decrypt` 转换会在 AWS Glue 内部解密。您也可以使用 AWS Encryption SDK 在 AWS Glue 之外解密数据。如果提供的 KMS 密钥 ARN 与用于加密列的密钥不匹配，则解密操作将失败。 + `source_columns`：现有列的数组。 + `kms_key_arn` – 用于解密源列的 AWS Key Management Service 密钥的密钥 ARN。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # 加密类 `Encrypt` 转换会使用 AWS Key Management Service 密钥对源列进行加密。`Encrypt` 转换每个单元格最多可以加密 128 MiB。它将在解密时尝试保留格式。要保留数据类型，数据类型元数据必须序列化为小于 1 KB。否则，您必须将 `preserve_data_type` 参数设置为 false。数据类型元数据将以纯文本形式存储在加密环境中。 ## 示例 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * kms = "${KMS}" sc = SparkContext() spark = SparkSession(sc) input_df = spark.createDataFrame( [ (1, "1234560000"), (2, "1234560001"), (3, "1234560002"), (4, "1234560003"), (5, "1234560004"), (6, "1234560005"), (7, "1234560006"), (8, "1234560007"), (9, "1234560008"), (10, "1234560009"), ], ["id", "phone"], ) try: df_encrypt = pii.Encrypt.apply( data_frame=input_df, spark_context=sc, source_columns=["phone"], kms_key_arn=kms ) except: print("Unexpected Error happened ") raise ``` ## Output 输出是 PySpark DataFrame，其中包含原始“id”列，以及一个包含“phone”列加密值的附加列。 ``` ``` +---+------------+-------------------------+ | id| phone | phone_encrypted | +---+------------+-------------------------+ | 1| 1234560000| EncryptedData1234...abc | | 2| 1234560001| EncryptedData5678...def | | 3| 1234560002| EncryptedData9012...ghi | | 4| 1234560003| EncryptedData3456...jkl | | 5| 1234560004| EncryptedData7890...mno | | 6| 1234560005| EncryptedData1234...pqr | | 7| 1234560006| EncryptedData5678...stu | | 8| 1234560007| EncryptedData9012...vwx | | 9| 1234560008| EncryptedData3456...yz0 | | 10| 1234560009| EncryptedData7890...123 | +---+------------+-------------------------+ ``` ``` `Encrypt` 转换会将“source\$1columns”设为“["phone"]”，将“kms\$1key\$1arn”设为“\$1\$1KMS\$1”环境变量的值。该转换使用指定的 KMS 密钥对“phone”列中的值进行加密。生成的“df\$1encrypt”DataFrame 包含原始“id”列、原始的“phone”列以及一个名为“phone\$1encrypted”的附加列，其中包含“phone”列加密值。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-Encrypt-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-Encrypt-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-Encrypt-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-Encrypt-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-Encrypt-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-Encrypt-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-Encrypt-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-Encrypt-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, source\$1columns, kms\$1key\$1arn, entity\$1type\$1filter=None, preserve\$1data\$1type=None) `Encrypt` 转换会使用 AWS Key Management Service 密钥对源列进行加密。 + `source_columns` – 现有列的数组。 + `kms_key_arn` – 用于加密源列的 AWS Key Management Service 密钥的密钥 ARN。 + `entity_type_filter` – 可选的实体类型数组。可仅用于加密自由文本列中检测到的 PII。 + `preserve_data_type` – 可选布尔值。默认值为 true。如果为 false，则不会存储数据类型。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # IntToIp 类 `IntToIp` 转换会将源列的整数值或其他值转换为目标列中相应的 IPv4 值，然后在新列中返回结果。 ## 示例 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * sc = SparkContext() spark = SparkSession(sc) input_df = spark.createDataFrame( [ (3221225473,), (0,), (1,), (100,), (168430090,), (4294967295,), (4294967294,), (4294967296,), (-1,), (None,), ], ["source_column_int"], ) try: df_output = web_functions.IntToIp.apply( data_frame=input_df, spark_context=sc, source_column="source_column_int", target_column="target_column", value=None ) df_output.show() except: print("Unexpected Error happened ") raise ``` ## Output 输出是： ``` ``` +---------------+---------------+ |source_column_int|target_column| +---------------+---------------+ | 3221225473| 192.0.0.1 | | 0| 0.0.0.0 | | 1| 0.0.0.1 | | 100| 0.0.0.100| | 168430090 | 10.0.0.10 | | 4294967295| 255.255.255.255| | 4294967294| 255.255.255.254| | 4294967296| null | | -1| null | | null| null | +---------------+---------------+ ``` ``` `IntToIp.apply` 转换会将“source\$1column”设为“source\$1column\$1int”，将“target\$1column”设为“target\$1column”，并将“source\$1column\$1int”列中的整数值转换为相应的 IPv4 地址表示形式，并将结果存储在“target\$1column”列中。对于 IPv4 地址范围（0 到 4294967295）内的有效整数值，该转换会成功地将其转换为其 IPv4 地址表示形式（例如 192.0.0.1、0.0.0.0、10.0.0.10、255.255.255.255）。对于超出有效范围的整数值（例如 4294967296、-1），“target\$1column”值设置为“null”。对于“source\$1column\$1int”列中的“null”值，“target\$1column”值也会设置为“null”。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-IntToIp-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-IntToIp-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-IntToIp-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-IntToIp-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-IntToIp-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-IntToIp-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-IntToIp-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-IntToIp-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, target\$1column, source\$1column=None, value=None) `IntToIp` 转换会将源列的整数值或其他值转换为目标列中相应的 IPv4 值，然后在新列中返回结果。 + `sourceColumn`：现有列的名称。 + `value`：要计算的字符串。 + `targetColumn` – 要创建的新列的名称。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 # IpToInt 类 `IpToInt` 转换会将源列的 Internet 协议版本 4（IPv4）值或其他值转换为目标列中相应的整数值，然后在新列中返回结果。 ## 示例对于 AWS Glue 4.0 及更高版本，使用 `key: --enable-glue-di-transforms, value: true` 创建或更新任务参数 ``` from pyspark.context import SparkContext from awsgluedi.transforms import * sc = SparkContext() input_df = spark.createDataFrame( [ ("192.0.0.1",), ("10.10.10.10",), ("1.2.3.4",), ("1.2.3.6",), ("http://12.13.14.15",), ("https://16.17.18.19",), ("1.2.3.4",), (None,), ("abc",), ("abc.abc.abc.abc",), ("321.123.123.123",), ("244.4.4.4",), ("255.255.255.255",), ], ["source_column_ip"], ) df_output = web_functions.IpToInt.apply( data_frame=input_df, spark_context=sc, source_column="source_column_ip", target_column="target_column", value=None ) df_output.show() ``` ## Output 输出是： ``` ``` +----------------+---------------+ |source_column_ip| target_column| +----------------+---------------+ | 192.0.0.1| 3221225473| | 10.10.10.10| 168427722| | 1.2.3.4| 16909060| | 1.2.3.6| 16909062| |http://12.13.14.15| null| |https://16.17.18.19| null| | 1.2.3.4| 16909060| | null| null| | abc| null| |abc.abc.abc.abc| null| | 321.123.123.123| null| | 244.4.4.4| 4102444804| | 255.255.255.255| 4294967295| +----------------+---------------+ ``` ``` `IpToInt` 转换会将“source\$1column”设为“source\$1column\$1ip”，将“target\$1column”设为“target\$1column”，并将“source\$1column\$1ip”列中的有效 IPv4 地址字符串转换为相应的 32 位整数表示形式，并将结果存储在“target\$1column”列中。对于有效的 IPv4 地址字符串（例如“192.0.0.1”、“10.10.10.10”、“1.2.3.4”），该转换可成功地将其转换为整数表示形式（例如 3221225473、168427722、16909060）。对于非有效 IPv4 地址的字符串 [例如 URL、非 IP 字符串（如“abc”）、无效 IP 格式（如“abc.abc.abc.abc”）]，“target\$1column”值会设置为“null”。对于“source\$1column\$1ip”列中的“null”值，“target\$1column”值也会设置为“null”。 ## 方法 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-IpToInt-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-IpToInt-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-IpToInt-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-IpToInt-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-IpToInt-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-IpToInt-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-IpToInt-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-IpToInt-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, target\$1column, source\$1column=None, value=None) `IpToInt` 转换会将源列的 Internet 协议版本 4（IPv4）值或其他值转换为目标列中相应的整数值，然后在新列中返回结果。 + `sourceColumn`：现有列的名称。 + `value`：要计算的字符串。 + `targetColumn` – 要创建的新列的名称。 ## apply(cls, \$1args, \$1\$1kwargs) 继承自 `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)。 ## name(cls) 继承自 `GlueTransform` [名称](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)。 ## describeArgs(cls) 继承自 `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)。 ## describeReturn(cls) 继承自 `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)。 ## describeTransform(cls) 继承自 `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)。 ## describeErrors(cls) 继承自 `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)。 ## describe(cls) 继承自 `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)。 ## 数据集成转换对于 AWS Glue 4.0 及更高版本，使用 `key: --enable-glue-di-transforms, value: true` 创建或更新任务参数。示例任务脚本： ``` from pyspark.context import SparkContext from awsgluedi.transforms import * sc = SparkContext() input_df = spark.createDataFrame( [(5,), (0,), (-1,), (2,), (None,)], ["source_column"], ) try: df_output = math_functions.IsEven.apply( data_frame=input_df, spark_context=sc, source_column="source_column", target_column="target_column", value=None, true_string="Even", false_string="Not even", ) df_output.show() except: print("Unexpected Error happened ") raise ``` 使用笔记本的示例会话 ``` %idle_timeout 2880 %glue_version 4.0 %worker_type G.1X %number_of_workers 5 %region eu-west-1 ``` ``` %%configure { "--enable-glue-di-transforms": "true" } ``` ``` from pyspark.context import SparkContext from awsgluedi.transforms import * sc = SparkContext() input_df = spark.createDataFrame( [(5,), (0,), (-1,), (2,), (None,)], ["source_column"], ) try: df_output = math_functions.IsEven.apply( data_frame=input_df, spark_context=sc, source_column="source_column", target_column="target_column", value=None, true_string="Even", false_string="Not even", ) df_output.show() except: print("Unexpected Error happened ") raise ``` 使用 AWS CLI 的示例会话 ``` aws glue create-session --default-arguments "--enable-glue-di-transforms=true" ``` DI 转换： + [FlagDuplicatesInColumn 类](aws-glue-api-pyspark-transforms-FlagDuplicatesInColumn.md) + [FormatPhoneNumber 类](aws-glue-api-pyspark-transforms-FormatPhoneNumber.md) + [FormatCase 类](aws-glue-api-pyspark-transforms-FormatCase.md) + [FillWithMode 类](aws-glue-api-pyspark-transforms-FillWithMode.md) + [FlagDuplicateRows 类](aws-glue-api-pyspark-transforms-FlagDuplicateRows.md) + [RemoveDuplicates 类](aws-glue-api-pyspark-transforms-RemoveDuplicates.md) + [MonthName 类](aws-glue-api-pyspark-transforms-MonthName.md) + [IsEven 类](aws-glue-api-pyspark-transforms-IsEven.md) + [CryptographicHash 类](aws-glue-api-pyspark-transforms-CryptographicHash.md) + [解密类](aws-glue-api-pyspark-transforms-Decrypt.md) + [加密类](aws-glue-api-pyspark-transforms-Encrypt.md) + [IntToIp 类](aws-glue-api-pyspark-transforms-IntToIp.md) + [IpToInt 类](aws-glue-api-pyspark-transforms-IpToInt.md) ### Maven：将插件与 Spark 应用程序捆绑在一起在本地开发 Spark 应用程序时，您可以通过在 Maven `pom.xml` 中添加插件依赖关系，将转换依赖项与 Spark 应用程序和 Spark 发行版（版本 3.3）捆绑在一起。 ``` ... aws-glue-etl-artifacts https://aws-glue-etl-artifacts.s3.amazonaws.com/release/ ... com.amazonaws AWSGlueTransforms 4.0.0 ``` 您也可以直接从 AWS Glue Maven 构件下载二进制文件，并将它们包含在您的 Spark 应用程序中，如下所示。 ``` #!/bin/bash sudo wget -v https://aws-glue-etl-artifacts.s3.amazonaws.com/release/com/amazonaws/AWSGlueTransforms/4.0.0/AWSGlueTransforms-4.0.0.jar -P /usr/lib/spark/jars/ ```