Module types

Specifies a transform that maps data property keys in the data source to data property keys in the data target. You can rename keys, modify the data types for keys, and choose which keys to drop from the dataset.

AthenaConnectorSource

Specifies a connector to an Amazon Athena data source.

AuditContext

A structure containing the Lake Formation audit context.

AuthConfiguration

The authentication configuration for a connection returned by the DescribeConnectionType API.

AuthenticationConfiguration

A structure containing the authentication configuration.

AuthenticationConfigurationInput

A structure containing the authentication configuration in the CreateConnection request.

AuthorizationCodeProperties

The set of properties required for the the OAuth2 AUTHORIZATION_CODE grant type workflow.

BackfillError

A list of errors that can occur when registering partition indexes for an existing table.

These errors give the details about why an index registration failed and provide a limited number of partitions in the response, so that you can fix the partitions at fault and try registering the index again. The most common set of errors that can occur are categorized as follows:

EncryptedPartitionError: The partitions are encrypted.
InvalidPartitionTypeDataError: The partition value doesn't match the data type for that partition column.
MissingPartitionValueError: The partitions are encrypted.
UnsupportedPartitionCharacterError: Characters inside the partition value are not supported. For example: U+0000 , U+0001, U+0002.
InternalError: Any error which does not belong to other error codes.

BasicAuthenticationCredentials

For supplying basic auth credentials when not providing a SecretArn value.

BasicCatalogTarget

Specifies a target that uses a Glue Data Catalog table.

BatchGetTableOptimizerEntry

Represents a table optimizer to retrieve in the BatchGetTableOptimizer operation.

BatchGetTableOptimizerError

Contains details on one of the errors in the error list returned by the BatchGetTableOptimizer operation.

BatchStopJobRunError

Records an error that occurred when attempting to stop a specified job run.

BatchStopJobRunSuccessfulSubmission

Records a successful request to stop a specified JobRun.

BatchTableOptimizer

Contains details for one of the table optimizers returned by the BatchGetTableOptimizer operation.

BatchUpdatePartitionFailureEntry

Contains information about a batch update partition error.

BatchUpdatePartitionRequestEntry

A structure that contains the values and structure used to update a partition.

BinaryColumnStatisticsData

Defines column statistics supported for bit sequence data values.

Blueprint

The details of a blueprint.

BlueprintDetails

The details of a blueprint.

BlueprintRun

The details of a blueprint run.

BooleanColumnStatisticsData

Defines column statistics supported for Boolean data columns.

Capabilities

Specifies the supported authentication types returned by the DescribeConnectionType API.

Catalog

The catalog object represents a logical grouping of databases in the Glue Data Catalog or a federated source. You can now create a Redshift-federated catalog or a catalog containing resource links to Redshift databases in another account or region.

CatalogDeltaSource

Specifies a Delta Lake data source that is registered in the Glue Data Catalog.

CatalogEntry

Specifies a table definition in the Glue Data Catalog.

CatalogHudiSource

Specifies a Hudi data source that is registered in the Glue Data Catalog.

CatalogImportStatus

A structure containing migration status information.

CatalogInput

A structure that describes catalog properties.

CatalogKafkaSource

Specifies an Apache Kafka data store in the Data Catalog.

CatalogKinesisSource

Specifies a Kinesis data source in the Glue Data Catalog.

CatalogProperties

A structure that specifies data lake access properties and other custom properties.

CatalogPropertiesOutput

Property attributes that include configuration properties for the catalog resource.

CatalogSchemaChangePolicy

A policy that specifies update behavior for the crawler.

CatalogSource

Specifies a data store in the Glue Data Catalog.

CatalogTarget

Specifies an Glue Data Catalog target.

Classifier

Classifiers are triggered during a crawl task. A classifier checks whether a given file is in a format it can handle. If it is, the classifier creates a schema in the form of a StructType object that matches that data format.

You can use the standard classifiers that Glue provides, or you can write your own classifiers to best categorize your data sources and specify the appropriate schemas to use for them. A classifier can be a grok classifier, an XML classifier, a JSON classifier, or a custom CSV classifier, as specified in one of the fields in the Classifier object.

CloudWatchEncryption

Specifies how Amazon CloudWatch data should be encrypted.

CodeGenConfigurationNode

CodeGenConfigurationNode enumerates all valid Node types. One and only one of its member variables can be populated.

CodeGenEdge

Represents a directional edge in a directed acyclic graph (DAG).

CodeGenNode

Represents a node in a directed acyclic graph (DAG)

CodeGenNodeArg

An argument or property of a node.

Column

A column in a Table.

ColumnError

Encapsulates a column name that failed and the reason for failure.

ColumnImportance

A structure containing the column name and column importance score for a column.

Column importance helps you understand how columns contribute to your model, by identifying which columns in your records are more important than others.

ColumnRowFilter

A filter that uses both column-level and row-level filtering.

ColumnStatistics

Represents the generated column-level statistics for a table or partition.

ColumnStatisticsData

Contains the individual types of column statistics data. Only one data object should be set and indicated by the Type attribute.

ColumnStatisticsError

Encapsulates a ColumnStatistics object that failed and the reason for failure.

ColumnStatisticsTaskRun

The object that shows the details of the column stats run.

ColumnStatisticsTaskSettings

The settings for a column statistics task.

CompactionMetrics

A structure that contains compaction metrics for the optimizer run.

ComputeEnvironmentConfiguration

An object containing configuration for a compute environment (such as Spark, Python or Athena) returned by the DescribeConnectionType API.

Condition

Defines a condition under which a trigger fires.

ConditionExpression

Condition expression defined in the Glue Studio data preparation recipe node.

ConfigurationObject

Specifies the values that an admin sets for each job or session parameter configured in a Glue usage profile.

ConfusionMatrix

The confusion matrix shows you what your transform is predicting accurately and what types of errors it is making.

For more information, see Confusion matrix in Wikipedia.

Connection

Defines a connection to a data source.

ConnectionInput

A structure that is used to specify a connection to create or update.

ConnectionPasswordEncryption

The data structure used by the Data Catalog to encrypt the password as part of CreateConnection or UpdateConnection and store it in the ENCRYPTED_PASSWORD field in the connection properties. You can enable catalog encryption or only password encryption.

When a CreationConnection request arrives containing a password, the Data Catalog first encrypts the password using your KMS key. It then encrypts the whole connection object again if catalog encryption is also enabled.

This encryption requires that you set KMS key permissions to enable or restrict access on the password key according to your security requirements. For example, you might want only administrators to have decrypt permission on the password key.

ConnectionTypeBrief

Brief information about a supported connection type returned by the ListConnectionTypes API.

ConnectionsList

Specifies the connections used by a job.

ConnectorDataSource

Specifies a source generated with standard connection options.

ConnectorDataTarget

Specifies a target generated with standard connection options.

Crawl

The details of a crawl in the workflow.

Crawler

Specifies a crawler program that examines a data source and uses classifiers to try to determine its schema. If successful, the crawler records metadata concerning the data source in the Glue Data Catalog.

CrawlerHistory

Contains the information for a run of a crawler.

CrawlerMetrics

Metrics for a specified crawler.

CrawlerNodeDetails

The details of a Crawler node present in the workflow.

CrawlerTargets

Specifies data stores to crawl.

CrawlsFilter

A list of fields, comparators and value that you can use to filter the crawler runs for a specified crawler.

CreateCsvClassifierRequest

Specifies a custom CSV classifier for CreateClassifier to create.

CreateGrokClassifierRequest

Specifies a grok classifier for CreateClassifier to create.

CreateJsonClassifierRequest

Specifies a JSON classifier for CreateClassifier to create.

CreateXmlClassifierRequest

Specifies an XML classifier for CreateClassifier to create.

CsvClassifier

A classifier for custom CSV content.

CustomCode

Specifies a transform that uses custom code you provide to perform the data transformation. The output is a collection of DynamicFrames.

CustomEntityType

An object representing a custom pattern for detecting sensitive data across the columns and rows of your structured data.

DataCatalogEncryptionSettings

Contains configuration information for maintaining Data Catalog security.

DataLakeAccessProperties

Input properties to configure data lake access for your catalog resource in the Glue Data Catalog.

DataLakeAccessPropertiesOutput

The output properties of the data lake access configuration for your catalog resource in the Glue Data Catalog.

DataLakePrincipal

The Lake Formation principal.

DataQualityAnalyzerResult

Describes the result of the evaluation of a data quality analyzer.

DataQualityEncryption

Specifies how Data Quality assets in your account should be encrypted.

DataQualityEvaluationRunAdditionalRunOptions

Additional run options you can specify for an evaluation run.

DataQualityMetricValues

Describes the data quality metric value according to the analysis of historical data.

DataQualityObservation

Describes the observation generated after evaluating the rules and analyzers.

DataQualityResult

Describes a data quality result.

DataQualityResultDescription

Describes a data quality result.

DataQualityResultFilterCriteria

Criteria used to return data quality results.

DataQualityRuleRecommendationRunDescription

Describes the result of a data quality rule recommendation run.

DataQualityRuleRecommendationRunFilter

A filter for listing data quality recommendation runs.

DataQualityRuleResult

Describes the result of the evaluation of a data quality rule.

DataQualityRulesetEvaluationRunDescription

Describes the result of a data quality ruleset evaluation run.

DataQualityRulesetEvaluationRunFilter

The filter criteria.

DataQualityRulesetFilterCriteria

The criteria used to filter data quality rulesets.

DataQualityRulesetListDetails

Describes a data quality ruleset returned by GetDataQualityRuleset.

DataQualityTargetTable

An object representing an Glue table.

DataSource

A data source (an Glue table) for which you want data quality results.

Database

The Database object represents a logical grouping of tables that might reside in a Hive metastore or an RDBMS.

DatabaseIdentifier

A structure that describes a target database for resource linking.

DatabaseInput

The structure used to create or update a database.

DatapointInclusionAnnotation

An Inclusion Annotation.

Datatype

A structure representing the datatype of the value.

DateColumnStatisticsData

Defines column statistics supported for timestamp data columns.

DecimalColumnStatisticsData

Defines column statistics supported for fixed-point number data columns.

DecimalNumber

Contains a numeric value in decimal format.

DeltaTarget

Specifies a Delta data store to crawl one or more Delta tables.

DevEndpoint

A development endpoint where a developer can remotely debug extract, transform, and load (ETL) scripts.

DevEndpointCustomLibraries

Custom libraries to be loaded into a development endpoint.

DirectJdbcSource

Specifies the direct JDBC source connection.

DirectKafkaSource

Specifies an Apache Kafka data store.

DirectKinesisSource

Specifies a direct Amazon Kinesis data source.

DirectSchemaChangePolicy

A policy that specifies update behavior for the crawler.

DoubleColumnStatisticsData

Defines column statistics supported for floating-point number data columns.

DqResultsPublishingOptions

Options to configure how your data quality evaluation results are published.

DqStopJobOnFailureOptions

Options to configure how your job will stop if your data quality evaluation fails.

DropDuplicates

Specifies a transform that removes rows of repeating data from a data set.

DropFields

Specifies a transform that chooses the data property keys that you want to drop.

DropNullFields

Specifies a transform that removes columns from the dataset if all values in the column are 'null'. By default, Glue Studio will recognize null objects, but some values such as empty strings, strings that are "null", -1 integers or other placeholders such as zeros, are not automatically recognized as nulls.

DynamicTransform

Specifies the set of parameters needed to perform the dynamic transform.

DynamoDbCatalogSource

Specifies a DynamoDB data source in the Glue Data Catalog.

DynamoDbTarget

Specifies an Amazon DynamoDB table to crawl.

Edge

An edge represents a directed connection between two Glue components that are part of the workflow the edge belongs to.

EncryptionAtRest

Specifies the encryption-at-rest configuration for the Data Catalog.

EncryptionConfiguration

Specifies an encryption configuration.

Entity

An entity supported by a given ConnectionType.

ErrorDetail

Contains details about an error.

ErrorDetails

An object containing error details.

EvaluateDataQuality

Specifies your data quality evaluation criteria.

EvaluateDataQualityMultiFrame

Specifies your data quality evaluation criteria.

EvaluationMetrics

Evaluation metrics provide an estimate of the quality of your machine learning transform.

EventBatchingCondition

Batch condition that must be met (specified number of events received or batch time window expired) before EventBridge event trigger fires.

ExecutionAttempt

A run attempt for a column statistics task run.

ExecutionProperty

An execution property of a job.

ExportLabelsTaskRunProperties

Specifies configuration properties for an exporting labels task run.

FederatedCatalog

A catalog that points to an entity outside the Glue Data Catalog.

FederatedDatabase

A database that points to an entity outside the Glue Data Catalog.

FederatedTable

A table that points to an entity outside the Glue Data Catalog.

Field

The Field object has information about the different properties associated with a field in the connector.

FillMissingValues

Specifies a transform that locates records in the dataset that have missing values and adds a new field with a value determined by imputation. The input data set is used to train the machine learning model that determines what the missing value should be.

Filter

Specifies a transform that splits a dataset into two, based on a filter condition.

FilterExpression

Specifies a filter expression.

FilterValue

Represents a single entry in the list of values for a FilterExpression.

FindMatchesMetrics

The evaluation metrics for the find matches algorithm. The quality of your machine learning transform is measured by getting your transform to predict some matches and comparing the results to known matches from the same dataset. The quality metrics are based on a subset of your data, so they are not precise.

FindMatchesParameters

The parameters to configure the find matches transform.

FindMatchesTaskRunProperties

Specifies configuration properties for a Find Matches task run.

GetConnectionsFilter

Filters the connection definitions that are returned by the GetConnections API operation.

GluePolicy

A structure for returning a resource policy.

GlueSchema

Specifies a user-defined schema when a schema cannot be determined by Glue.

GlueStudioSchemaColumn

Specifies a single column in a Glue schema definition.

GlueTable

The database and table in the Glue Data Catalog that is used for input or output data.

GovernedCatalogSource

Specifies the data store in the governed Glue Data Catalog.

GovernedCatalogTarget

Specifies a data target that writes to Amazon S3 using the Glue Data Catalog.

GrokClassifier

A classifier that uses grok patterns.

HudiTarget

Specifies an Apache Hudi data source.

IcebergCompactionMetrics

Compaction metrics for Iceberg for the optimizer run.

IcebergInput

A structure that defines an Apache Iceberg metadata table to create in the catalog.

IcebergOrphanFileDeletionConfiguration

The configuration for an Iceberg orphan file deletion optimizer.

IcebergOrphanFileDeletionMetrics

Orphan file deletion metrics for Iceberg for the optimizer run.

IcebergRetentionConfiguration

The configuration for an Iceberg snapshot retention optimizer.

IcebergRetentionMetrics

Snapshot retention metrics for Iceberg for the optimizer run.

IcebergTarget

Specifies an Apache Iceberg data source where Iceberg tables are stored in Amazon S3.

ImportLabelsTaskRunProperties

Specifies configuration properties for an importing labels task run.

InboundIntegration

A structure for an integration that writes data into a resource.

Integration

Describes a zero-ETL integration.

IntegrationError

An error associated with a zero-ETL integration.

IntegrationFilter

A filter that can be used when invoking a DescribeIntegrations request.

IntegrationPartition

A structure that describes how data is partitioned on the target.

JdbcConnectorOptions

Additional connection options for the connector.

JdbcConnectorSource

Specifies a connector to a JDBC data source.

JdbcConnectorTarget

Specifies a data target that writes to Amazon S3 in Apache Parquet columnar storage.

JdbcTarget

Specifies a JDBC data store to crawl.

Job

Specifies a job definition.

JobBookmarkEntry

Defines a point that a job can resume processing.

JobBookmarksEncryption

Specifies how job bookmark data should be encrypted.

JobCommand

Specifies code that runs when a job is run.

JobNodeDetails

The details of a Job node present in the workflow.

JobRun

Contains information about a job run.

JobUpdate

Specifies information used to update an existing job definition. The previous job definition is completely overwritten by this information.

Join

Specifies a transform that joins two datasets into one dataset using a comparison phrase on the specified data property keys. You can use inner, outer, left, right, left semi, and left anti joins.

JoinColumn

Specifies a column to be joined.

JsonClassifier

A classifier for JSON content.

KafkaStreamingSourceOptions

Additional options for streaming.

KeySchemaElement

A partition key pair consisting of a name and a type.

KinesisStreamingSourceOptions

Additional options for the Amazon Kinesis streaming data source.

LabelingSetGenerationTaskRunProperties

Specifies configuration properties for a labeling set generation task run.

LakeFormationConfiguration

Specifies Lake Formation configuration settings for the crawler.

LastActiveDefinition

When there are multiple versions of a blueprint and the latest version has some errors, this attribute indicates the last successful blueprint definition that is available with the service.

LastCrawlInfo

Status and error information about the most recent crawl.

LineageConfiguration

Specifies data lineage configuration settings for the crawler.

Location

The location of resources.

LongColumnStatisticsData

Defines column statistics supported for integer data columns.

Mapping

Specifies the mapping of data property keys.

MappingEntry

Defines a mapping.

Merge

Specifies a transform that merges a DynamicFrame with a staging DynamicFrame based on the specified primary keys to identify records. Duplicate records (records with the same primary keys) are not de-duplicated.

MetadataInfo

A structure containing metadata information for a schema version.

MetadataKeyValuePair

A structure containing a key value pair for metadata.

MetricBasedObservation

Describes the metric based observation generated based on evaluated data quality metrics.

MicrosoftSqlServerCatalogSource

Specifies a Microsoft SQL server data source in the Glue Data Catalog.

MicrosoftSqlServerCatalogTarget

Specifies a target that uses Microsoft SQL.

MlTransform

A structure for a machine learning transform.

MlUserDataEncryption

The encryption-at-rest settings of the transform that apply to accessing user data.

MongoDbTarget

Specifies an Amazon DocumentDB or MongoDB data store to crawl.

MySqlCatalogSource

Specifies a MySQL data source in the Glue Data Catalog.

MySqlCatalogTarget

Specifies a target that uses MySQL.

Node

A node represents an Glue component (trigger, crawler, or job) on a workflow graph.

NotificationProperty

Specifies configuration properties of a notification.

NullCheckBoxList

Represents whether certain values are recognized as null values for removal.

NullValueField

Represents a custom null value such as a zeros or other value being used as a null placeholder unique to the dataset.

OAuth2ClientApplication

The OAuth2 client app used for the connection.

OAuth2Credentials

The credentials used when the authentication type is OAuth2 authentication.

OAuth2Properties

A structure containing properties for OAuth2 authentication.

OAuth2PropertiesInput

A structure containing properties for OAuth2 in the CreateConnection request.

OpenTableFormatInput

A structure representing an open format table.

Option

Specifies an option value.

OracleSqlCatalogSource

Specifies an Oracle data source in the Glue Data Catalog.

OracleSqlCatalogTarget

Specifies a target that uses Oracle SQL.

Order

Specifies the sort order of a sorted column.

OrphanFileDeletionConfiguration

The configuration for an orphan file deletion optimizer.

OrphanFileDeletionMetrics

A structure that contains orphan file deletion metrics for the optimizer run.

OtherMetadataValueListItem

A structure containing other metadata for a schema version belonging to the same metadata key.

Partition

Represents a slice of table data.

PartitionError

Contains information about a partition error.

PartitionIndex

A structure for a partition index.

PartitionIndexDescriptor

A descriptor for a partition index in a table.

PartitionInput

The structure used to create and update a partition.

PartitionValueList

Contains a list of values defining partitions.

PhysicalConnectionRequirements

The OAuth client app in GetConnection response.

PiiDetection

Specifies a transform that identifies, removes or masks PII data.

PostgreSqlCatalogSource

Specifies a PostgresSQL data source in the Glue Data Catalog.

PostgreSqlCatalogTarget

Specifies a target that uses Postgres SQL.

Predecessor

A job run that was used in the predicate of a conditional trigger that triggered this job run.

Predicate

Defines the predicate of the trigger, which determines when it fires.

PrincipalPermissions

Permissions granted to a principal.

ProfileConfiguration

Specifies the job and session values that an admin configures in an Glue usage profile.

Property

An object that defines a connection type for a compute environment.

PropertyPredicate

Defines a property predicate.

QuerySessionContext

A structure used as a protocol between query engines and Lake Formation or Glue. Contains both a Lake Formation generated authorization identifier and information from the request's authorization context.

Recipe

A Glue Studio node that uses a Glue DataBrew recipe in Glue jobs.

RecipeAction

Actions defined in the Glue Studio data preparation recipe node.

RecipeReference

A reference to a Glue DataBrew recipe.

RecipeStep

A recipe step used in a Glue Studio data preparation recipe node.

RecrawlPolicy

When crawling an Amazon S3 data source after the first crawl is complete, specifies whether to crawl the entire dataset again or to crawl only folders that were added since the last crawler run. For more information, see Incremental Crawls in Glue in the developer guide.

RedshiftSource

Specifies an Amazon Redshift data store.

RedshiftTarget

Specifies a target that uses Amazon Redshift.

RegistryId

A wrapper structure that may contain the registry name and Amazon Resource Name (ARN).

RegistryListItem

A structure containing the details for a registry.

RelationalCatalogSource

Specifies a Relational database data source in the Glue Data Catalog.

RenameField

Specifies a transform that renames a single data property key.

ResourceUri

The URIs for function resources.

RetentionConfiguration

The configuration for a snapshot retention optimizer.

RetentionMetrics

A structure that contains retention metrics for the optimizer run.

RunIdentifier

A run identifier.

RunMetrics

Metrics for the optimizer run.

This structure is deprecated. See the individual metric members for compaction, retention, and orphan file deletion.

S3CatalogDeltaSource

Specifies a Delta Lake data source that is registered in the Glue Data Catalog. The data source must be stored in Amazon S3.

S3CatalogHudiSource

Specifies a Hudi data source that is registered in the Glue Data Catalog. The Hudi data source must be stored in Amazon S3.

S3CatalogSource

Specifies an Amazon S3 data store in the Glue Data Catalog.

S3CatalogTarget

Specifies a data target that writes to Amazon S3 using the Glue Data Catalog.

S3CsvSource

Specifies a command-separated value (CSV) data store stored in Amazon S3.

S3DeltaCatalogTarget

Specifies a target that writes to a Delta Lake data source in the Glue Data Catalog.

S3DeltaDirectTarget

Specifies a target that writes to a Delta Lake data source in Amazon S3.

S3DeltaSource

Specifies a Delta Lake data source stored in Amazon S3.

S3DirectSourceAdditionalOptions

Specifies additional connection options for the Amazon S3 data store.

S3DirectTarget

Specifies a data target that writes to Amazon S3.

S3Encryption

Specifies how Amazon Simple Storage Service (Amazon S3) data should be encrypted.

S3GlueParquetTarget

Specifies a data target that writes to Amazon S3 in Apache Parquet columnar storage.

S3HudiCatalogTarget

Specifies a target that writes to a Hudi data source in the Glue Data Catalog.

S3HudiDirectTarget

Specifies a target that writes to a Hudi data source in Amazon S3.

S3HudiSource

Specifies a Hudi data source stored in Amazon S3.

S3JsonSource

Specifies a JSON data store stored in Amazon S3.

S3ParquetSource

Specifies an Apache Parquet data store stored in Amazon S3.

S3SourceAdditionalOptions

Specifies additional connection options for the Amazon S3 data store.

S3Target

Specifies a data store in Amazon Simple Storage Service (Amazon S3).

Schedule

A scheduling object using a cron statement to schedule an event.

SchemaChangePolicy

A policy that specifies update and deletion behaviors for the crawler.

SchemaColumn

A key-value pair representing a column and data type that this transform can run against. The Schema parameter of the MLTransform may contain up to 100 of these structures.

SchemaId

The unique ID of the schema in the Glue schema registry.

SchemaListItem

An object that contains minimal details for a schema.

SchemaReference

An object that references a schema stored in the Glue Schema Registry.

SchemaVersionErrorItem

An object that contains the error details for an operation on a schema version.

SchemaVersionListItem

An object containing the details about a schema version.

SchemaVersionNumber

A structure containing the schema version information.

SecurityConfiguration

Specifies a security configuration.

Segment

Defines a non-overlapping region of a table's partitions, allowing multiple requests to be run in parallel.

SelectFields

Specifies a transform that chooses the data property keys that you want to keep.

SelectFromCollection

Specifies a transform that chooses one DynamicFrame from a collection of DynamicFrames. The output is the selected DynamicFrame

SerDeInfo

Information about a serialization/deserialization program (SerDe) that serves as an extractor and loader.

Session

The period in which a remote Spark runtime environment is running.

SessionCommand

The SessionCommand that runs the job.

SkewedInfo

Specifies skewed values in a table. Skewed values are those that occur with very high frequency.

SnowflakeNodeData

Specifies configuration for Snowflake nodes in Glue Studio.

SnowflakeSource

Specifies a Snowflake data source.

SnowflakeTarget

Specifies a Snowflake target.

SortCriterion

Specifies a field to sort by and a sort order.

SourceControlDetails

The details for a source control configuration for a job, allowing synchronization of job artifacts to or from a remote repository.

SourceProcessingProperties

The resource properties associated with the integration source.

SourceTableConfig

Properties used by the source leg to process data from the source.

SparkConnectorSource

Specifies a connector to an Apache Spark data source.

SparkConnectorTarget

Specifies a target that uses an Apache Spark connector.

SparkSql

Specifies a transform where you enter a SQL query using Spark SQL syntax to transform the data. The output is a single DynamicFrame.

Spigot

Specifies a transform that writes samples of the data to an Amazon S3 bucket.

SplitFields

Specifies a transform that splits data property keys into two DynamicFrames. The output is a collection of DynamicFrames: one with selected data property keys, and one with the remaining data property keys.

SqlAlias

Represents a single entry in the list of values for SqlAliases.

StartingEventBatchCondition

The batch condition that started the workflow run. Either the number of events in the batch size arrived, in which case the BatchSize member is non-zero, or the batch window expired, in which case the BatchWindow member is non-zero.

Statement

The statement or request for a particular action to occur in a session.

StatementOutput

The code execution output in JSON format.

StatementOutputData

The code execution output in JSON format.

StatisticAnnotation

A Statistic Annotation.

StatisticModelResult

The statistic model result.

StatisticSummary

Summary information about a statistic.

StatusDetails

A structure containing information about an asynchronous change to a table.

StorageDescriptor

Describes the physical storage of table data.

StreamingDataPreviewOptions

Specifies options related to data preview for viewing a sample of your data.

StringColumnStatisticsData

Defines column statistics supported for character sequence data values.

SupportedDialect

A structure specifying the dialect and dialect version used by the query engine.

Table

Represents a collection of related data organized in columns and rows.

TableError

An error record for table operations.

TableIdentifier

A structure that describes a target table for resource linking.

TableInput

A structure used to define a table.

TableOptimizer

Contains details about an optimizer associated with a table.

TableOptimizerConfiguration

Contains details on the configuration of a table optimizer. You pass this configuration when creating or updating a table optimizer.

TableOptimizerRun

Contains details for a table optimizer run.

TableStatus

A structure containing information about the state of an asynchronous change to a table.

TableVersion

Specifies a version of a table.

TableVersionError

An error record for table-version operations.

Tag

The Tag object represents a label that you can assign to an Amazon Web Services resource. Each tag consists of a key and an optional value, both of which you define.

For more information about tags, and controlling access to resources in Glue, see Amazon Web Services Tags in Glue and Specifying Glue Resource ARNs in the developer guide.

TargetProcessingProperties

The resource properties associated with the integration target.

TargetRedshiftCatalog

A structure that describes a target catalog for resource linking.

TargetTableConfig

Properties used by the target leg to partition the data on the target.

TaskRun

The sampling parameters that are associated with the machine learning transform.

TaskRunFilterCriteria

The criteria that are used to filter the task runs for the machine learning transform.

TaskRunProperties

The configuration properties for the task run.

TaskRunSortCriteria

The sorting criteria that are used to sort the list of task runs for the machine learning transform.

TestConnectionInput

A structure that is used to specify testing a connection to a service.

TimestampFilter

A timestamp filter.

TimestampedInclusionAnnotation

A timestamped inclusion annotation.

TransformConfigParameter

Specifies the parameters in the config file of the dynamic transform.

TransformEncryption

The encryption-at-rest settings of the transform that apply to accessing user data. Machine learning transforms can access user data encrypted in Amazon S3 using KMS.

Additionally, imported labels and trained transforms can now be encrypted using a customer provided KMS key.

TransformFilterCriteria

The criteria used to filter the machine learning transforms.

TransformParameters

The algorithm-specific parameters that are associated with the machine learning transform.

TransformSortCriteria

The sorting criteria that are associated with the machine learning transform.

Trigger

Information about a specific trigger.

TriggerNodeDetails

The details of a Trigger node present in the workflow.

TriggerUpdate

A structure used to provide information used to update a trigger. This object updates the previous trigger definition by overwriting it completely.

UnfilteredPartition

A partition that contains unfiltered metadata.

Union

Specifies a transform that combines the rows from two or more datasets into a single result.

UpdateCsvClassifierRequest

Specifies a custom CSV classifier to be updated.

UpdateGrokClassifierRequest

Specifies a grok classifier to update when passed to UpdateClassifier.

UpdateJsonClassifierRequest

Specifies a JSON classifier to be updated.

UpdateXmlClassifierRequest

Specifies an XML classifier to be updated.

UpsertRedshiftTargetOptions

The options to configure an upsert operation when writing to a Redshift target .

UsageProfileDefinition

Describes an Glue usage profile.

UserDefinedFunction

Represents the equivalent of a Hive user-defined function (UDF) definition.

UserDefinedFunctionInput

A structure used to create or update a user-defined function.

ViewDefinition

A structure containing details for representations.

ViewDefinitionInput

A structure containing details for creating or updating an Glue view.

ViewRepresentation

A structure that contains the dialect of the view, and the query that defines the view.

ViewRepresentationInput

A structure containing details of a representation to update or create a Lake Formation view.

ViewValidation

A structure that contains information for an analytical engine to validate a view, prior to persisting the view metadata. Used in the case of direct UpdateTable or CreateTable API calls.

Workflow

A workflow is a collection of multiple dependent Glue jobs and crawlers that are run to complete a complex ETL task. A workflow manages the execution and monitoring of all its jobs and crawlers.

WorkflowGraph

A workflow graph represents the complete workflow containing all the Glue components present in the workflow and all the directed connections between them.

WorkflowRun

A workflow run is an execution of a workflow providing all the runtime information.

WorkflowRunStatistics

Workflow run statistics provides statistics about the workflow run.

XmlClassifier

A classifier for XML content.

Enums§

AdditionalOptionKeys

When writing a match expression against AdditionalOptionKeys, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AggFunction

When writing a match expression against AggFunction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AllowFullTableExternalDataAccessEnum

When writing a match expression against AllowFullTableExternalDataAccessEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AuthenticationType

When writing a match expression against AuthenticationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

BackfillErrorCode

When writing a match expression against BackfillErrorCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

BlueprintRunState

When writing a match expression against BlueprintRunState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

BlueprintStatus

When writing a match expression against BlueprintStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CatalogEncryptionMode

When writing a match expression against CatalogEncryptionMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CloudWatchEncryptionMode

When writing a match expression against CloudWatchEncryptionMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ColumnStatisticsState

When writing a match expression against ColumnStatisticsState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ColumnStatisticsType

When writing a match expression against ColumnStatisticsType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Comparator

When writing a match expression against Comparator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Compatibility

When writing a match expression against Compatibility, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CompressionType

When writing a match expression against CompressionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ComputationType

When writing a match expression against ComputationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ComputeEnvironment

When writing a match expression against ComputeEnvironment, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ConnectionPropertyKey

When writing a match expression against ConnectionPropertyKey, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ConnectionStatus

When writing a match expression against ConnectionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ConnectionType

When writing a match expression against ConnectionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CrawlState

When writing a match expression against CrawlState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CrawlerHistoryState

When writing a match expression against CrawlerHistoryState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CrawlerLineageSettings

When writing a match expression against CrawlerLineageSettings, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CrawlerState

When writing a match expression against CrawlerState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CsvHeaderOption

When writing a match expression against CsvHeaderOption, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CsvSerdeOption

When writing a match expression against CsvSerdeOption, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DataFormat

When writing a match expression against DataFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DataOperation

When writing a match expression against DataOperation, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DataQualityEncryptionMode

When writing a match expression against DataQualityEncryptionMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DataQualityModelStatus

When writing a match expression against DataQualityModelStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DataQualityRuleResultStatus

When writing a match expression against DataQualityRuleResultStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DatabaseAttributes

When writing a match expression against DatabaseAttributes, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DeleteBehavior

When writing a match expression against DeleteBehavior, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DeltaTargetCompressionType

When writing a match expression against DeltaTargetCompressionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DqCompositeRuleEvaluationMethod

When writing a match expression against DqCompositeRuleEvaluationMethod, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DqStopJobOnFailureTiming

When writing a match expression against DqStopJobOnFailureTiming, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DqTransformOutput

When writing a match expression against DqTransformOutput, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EnableHybridValues

When writing a match expression against EnableHybridValues, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ExecutionClass

When writing a match expression against ExecutionClass, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ExecutionStatus

When writing a match expression against ExecutionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ExistCondition

When writing a match expression against ExistCondition, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FederationSourceErrorCode

When writing a match expression against FederationSourceErrorCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FieldDataType

When writing a match expression against FieldDataType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FieldFilterOperator

When writing a match expression against FieldFilterOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FieldName

When writing a match expression against FieldName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FilterLogicalOperator

When writing a match expression against FilterLogicalOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FilterOperation

When writing a match expression against FilterOperation, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FilterOperator

When writing a match expression against FilterOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FilterValueType

When writing a match expression against FilterValueType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

GlueRecordType

When writing a match expression against GlueRecordType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

HudiTargetCompressionType

When writing a match expression against HudiTargetCompressionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

InclusionAnnotationValue

When writing a match expression against InclusionAnnotationValue, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

IntegrationStatus

When writing a match expression against IntegrationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

JdbcConnectionType

When writing a match expression against JdbcConnectionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

JdbcDataType

When writing a match expression against JdbcDataType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

JdbcMetadataEntry

When writing a match expression against JdbcMetadataEntry, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

JobBookmarksEncryptionMode

When writing a match expression against JobBookmarksEncryptionMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

JobMode

When writing a match expression against JobMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

JobRunState

When writing a match expression against JobRunState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

JoinType

When writing a match expression against JoinType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Language

When writing a match expression against Language, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LastCrawlStatus

When writing a match expression against LastCrawlStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Logical

When writing a match expression against Logical, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LogicalOperator

When writing a match expression against LogicalOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MetadataOperation

When writing a match expression against MetadataOperation, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MlUserDataEncryptionModeString

When writing a match expression against MlUserDataEncryptionModeString, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

NodeType

When writing a match expression against NodeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

OAuth2GrantType

When writing a match expression against OAuth2GrantType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ParamType

When writing a match expression against ParamType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ParquetCompressionType

When writing a match expression against ParquetCompressionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PartitionIndexStatus

When writing a match expression against PartitionIndexStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Permission

When writing a match expression against Permission, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PermissionType

When writing a match expression against PermissionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PiiType

When writing a match expression against PiiType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PrincipalType

When writing a match expression against PrincipalType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PropertyType

When writing a match expression against PropertyType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

QuoteChar

When writing a match expression against QuoteChar, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RecrawlBehavior

When writing a match expression against RecrawlBehavior, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RegistryStatus

When writing a match expression against RegistryStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ResourceAction

When writing a match expression against ResourceAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ResourceShareType

When writing a match expression against ResourceShareType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ResourceState

When writing a match expression against ResourceState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ResourceType

When writing a match expression against ResourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

S3EncryptionMode

When writing a match expression against S3EncryptionMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ScheduleState

When writing a match expression against ScheduleState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ScheduleType

When writing a match expression against ScheduleType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SchemaDiffType

When writing a match expression against SchemaDiffType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SchemaStatus

When writing a match expression against SchemaStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SchemaVersionStatus

When writing a match expression against SchemaVersionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Separator

When writing a match expression against Separator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SessionStatus

When writing a match expression against SessionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SettingSource

When writing a match expression against SettingSource, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Sort

When writing a match expression against Sort, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SortDirectionType

When writing a match expression against SortDirectionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SourceControlAuthStrategy

When writing a match expression against SourceControlAuthStrategy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SourceControlProvider

When writing a match expression against SourceControlProvider, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StartingPosition

When writing a match expression against StartingPosition, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StatementState

When writing a match expression against StatementState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StatisticEvaluationLevel

When writing a match expression against StatisticEvaluationLevel, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TableAttributes

When writing a match expression against TableAttributes, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TableOptimizerEventType

When writing a match expression against TableOptimizerEventType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TableOptimizerType

When writing a match expression against TableOptimizerType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TableOptimizerVpcConfiguration

An object that describes the VPC configuration for a table optimizer.

This configuration is necessary to perform optimization on tables that are in a customer VPC.

TargetFormat

When writing a match expression against TargetFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TaskRunSortColumnType

When writing a match expression against TaskRunSortColumnType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TaskStatusType

When writing a match expression against TaskStatusType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TaskType

When writing a match expression against TaskType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TransformSortColumnType

When writing a match expression against TransformSortColumnType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TransformStatusType

When writing a match expression against TransformStatusType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TransformType

When writing a match expression against TransformType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TriggerState

When writing a match expression against TriggerState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TriggerType

When writing a match expression against TriggerType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

UnionType

When writing a match expression against UnionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

UnnestSpec

When writing a match expression against UnnestSpec, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

UpdateBehavior

When writing a match expression against UpdateBehavior, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

UpdateCatalogBehavior

When writing a match expression against UpdateCatalogBehavior, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ViewDialect

When writing a match expression against ViewDialect, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ViewUpdateAction

When writing a match expression against ViewUpdateAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

WorkerType

When writing a match expression against WorkerType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

WorkflowRunStatus

When writing a match expression against WorkflowRunStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Module typesCopy item path

Modules§

Structs§

Enums§

Module types