Module aws_sdk_dynamodb::types

Data structures used by operation inputs/outputs.

Modules

• builders
  Builders
• error
  Error types that Amazon DynamoDB can respond with.

Structs

• ArchivalSummary

  Contains details of a table archival operation.

• AttributeDefinition

  Represents an attribute for describing the schema for the table and indexes.

• AttributeValueUpdate

  For the UpdateItem operation, represents the attributes to be modified, the action to perform on each, and the new value for each.

• AutoScalingPolicyDescription

  Represents the properties of the scaling policy.

• AutoScalingPolicyUpdate

  Represents the auto scaling policy to be modified.

• AutoScalingSettingsDescription

  Represents the auto scaling settings for a global table or global secondary index.

• AutoScalingSettingsUpdate

  Represents the auto scaling settings to be modified for a global table or global secondary index.

• AutoScalingTargetTrackingScalingPolicyConfigurationDescription

  Represents the properties of a target tracking scaling policy.

• AutoScalingTargetTrackingScalingPolicyConfigurationUpdate

  Represents the settings of a target tracking scaling policy that will be modified.

• BackupDescription

  Contains the description of the backup created for the table.

• BackupDetails

  Contains the details of the backup created for the table.

• BackupSummary

  Contains details for the backup.

• BatchStatementError

  An error associated with a statement in a PartiQL batch that was run.

• BatchStatementRequest

  A PartiQL batch statement request.

• BatchStatementResponse

  A PartiQL batch statement response..

• BillingModeSummary

  Contains the details for the read/write capacity mode. This page talks about PROVISIONED and PAY_PER_REQUEST billing modes. For more information about these modes, see Read/write capacity mode.

• CancellationReason

  An ordered list of errors for each item in the request which caused the transaction to get cancelled. The values of the list are ordered according to the ordering of the TransactWriteItems request parameter. If no error occurred for the associated item an error with a Null code and Null message will be present.

• Capacity

  Represents the amount of provisioned throughput capacity consumed on a table or an index.

• Condition

  Represents the selection criteria for a Query or Scan operation:

• ConditionCheck

  Represents a request to perform a check that an item exists or to check the condition of specific attributes of the item.

• ConsumedCapacity

  The capacity units consumed by an operation. The data returned includes the total provisioned throughput consumed, along with statistics for the table and any indexes involved in the operation. ConsumedCapacity is only returned if the request asked for it. For more information, see Provisioned capacity mode in the Amazon DynamoDB Developer Guide.

• ContinuousBackupsDescription

  Represents the continuous backups and point in time recovery settings on the table.

• ContributorInsightsSummary

  Represents a Contributor Insights summary entry.

• CreateGlobalSecondaryIndexAction

  Represents a new global secondary index to be added to an existing table.

• CreateReplicaAction

  Represents a replica to be added.

• CreateReplicationGroupMemberAction

  Represents a replica to be created.

• CsvOptions

  Processing options for the CSV file being imported.

• Delete

  Represents a request to perform a DeleteItem operation.

• DeleteGlobalSecondaryIndexAction

  Represents a global secondary index to be deleted from an existing table.

• DeleteReplicaAction

  Represents a replica to be removed.

• DeleteReplicationGroupMemberAction

  Represents a replica to be deleted.

• DeleteRequest

  Represents a request to perform a DeleteItem operation on an item.

• EnableKinesisStreamingConfiguration

  Enables setting the configuration for Kinesis Streaming.

• Endpoint

  An endpoint information details.

• ExpectedAttributeValue

  Represents a condition to be compared with an attribute value. This condition can be used with DeleteItem, PutItem, or UpdateItem operations; if the comparison evaluates to true, the operation succeeds; if not, the operation fails. You can use ExpectedAttributeValue in one of two different ways:

• ExportDescription

  Represents the properties of the exported table.

• ExportSummary

  Summary information about an export task.

• FailureException

  Represents a failure a contributor insights operation.

• Get

  Specifies an item and related attribute values to retrieve in a TransactGetItem object.

• GlobalSecondaryIndex

  Represents the properties of a global secondary index.

• GlobalSecondaryIndexAutoScalingUpdate

  Represents the auto scaling settings of a global secondary index for a global table that will be modified.

• GlobalSecondaryIndexDescription

  Represents the properties of a global secondary index.

• GlobalSecondaryIndexInfo

  Represents the properties of a global secondary index for the table when the backup was created.

• GlobalSecondaryIndexUpdate

  Represents one of the following:

• GlobalTable

  Represents the properties of a global table.

• GlobalTableDescription

  Contains details about the global table.

• GlobalTableGlobalSecondaryIndexSettingsUpdate

  Represents the settings of a global secondary index for a global table that will be modified.

• ImportSummary

  Summary information about the source file for the import.

• ImportTableDescription

  Represents the properties of the table being imported into.

• IncrementalExportSpecification

  Optional object containing the parameters specific to an incremental export.

• InputFormatOptions

  The format options for the data that was imported into the target table. There is one value, CsvOption.

• ItemCollectionMetrics

  Information about item collections, if any, that were affected by the operation. ItemCollectionMetrics is only returned if the request asked for it. If the table does not have any local secondary indexes, this information is not returned in the response.

• ItemResponse

  Details for the requested item.

• KeySchemaElement

  Represents a single element of a key schema. A key schema specifies the attributes that make up the primary key of a table, or the key attributes of an index.

• KeysAndAttributes

  Represents a set of primary keys and, for each key, the attributes to retrieve from the table.

• KinesisDataStreamDestination

  Describes a Kinesis data stream destination.

• LocalSecondaryIndex

  Represents the properties of a local secondary index.

• LocalSecondaryIndexDescription

  Represents the properties of a local secondary index.

• LocalSecondaryIndexInfo

  Represents the properties of a local secondary index for the table when the backup was created.

• OnDemandThroughput

  Sets the maximum number of read and write units for the specified on-demand table. If you use this parameter, you must specify MaxReadRequestUnits, MaxWriteRequestUnits, or both.

• OnDemandThroughputOverride

  Overrides the on-demand throughput settings for this replica table. If you don't specify a value for this parameter, it uses the source table's on-demand throughput settings.

• ParameterizedStatement

  Represents a PartiQL statement that uses parameters.

• PointInTimeRecoveryDescription

  The description of the point in time settings applied to the table.

• PointInTimeRecoverySpecification

  Represents the settings used to enable point in time recovery.

• Projection

  Represents attributes that are copied (projected) from the table into an index. These are in addition to the primary key attributes and index key attributes, which are automatically projected.

• ProvisionedThroughput

  Represents the provisioned throughput settings for a specified table or index. The settings can be modified using the UpdateTable operation.

• ProvisionedThroughputDescription

  Represents the provisioned throughput settings for the table, consisting of read and write capacity units, along with data about increases and decreases.

• ProvisionedThroughputOverride

  Replica-specific provisioned throughput settings. If not specified, uses the source table's provisioned throughput settings.

• Put

  Represents a request to perform a PutItem operation.

• PutRequest

  Represents a request to perform a PutItem operation on an item.

• Replica

  Represents the properties of a replica.

• ReplicaAutoScalingDescription

  Represents the auto scaling settings of the replica.

• ReplicaAutoScalingUpdate

  Represents the auto scaling settings of a replica that will be modified.

• ReplicaDescription

  Contains the details of the replica.

• ReplicaGlobalSecondaryIndex

  Represents the properties of a replica global secondary index.

• ReplicaGlobalSecondaryIndexAutoScalingDescription

  Represents the auto scaling configuration for a replica global secondary index.

• ReplicaGlobalSecondaryIndexAutoScalingUpdate

  Represents the auto scaling settings of a global secondary index for a replica that will be modified.

• ReplicaGlobalSecondaryIndexDescription

  Represents the properties of a replica global secondary index.

• ReplicaGlobalSecondaryIndexSettingsDescription

  Represents the properties of a global secondary index.

• ReplicaGlobalSecondaryIndexSettingsUpdate

  Represents the settings of a global secondary index for a global table that will be modified.

• ReplicaSettingsDescription

  Represents the properties of a replica.

• ReplicaSettingsUpdate

  Represents the settings for a global table in a Region that will be modified.

• ReplicaUpdate

  Represents one of the following:

• ReplicationGroupUpdate

  Represents one of the following:

• RestoreSummary

  Contains details for the restore.

• S3BucketSource

  The S3 bucket that is being imported from.

• SourceTableDetails

  Contains the details of the table when the backup was created.

• SourceTableFeatureDetails

  Contains the details of the features enabled on the table when the backup was created. For example, LSIs, GSIs, streams, TTL.

• SseDescription

  The description of the server-side encryption status on the specified table.

• SseSpecification

  Represents the settings used to enable server-side encryption.

• StreamSpecification

  Represents the DynamoDB Streams configuration for a table in DynamoDB.

• TableAutoScalingDescription

  Represents the auto scaling configuration for a global table.

• TableClassSummary

  Contains details of the table class.

• TableCreationParameters

  The parameters for the table created as part of the import operation.

• TableDescription

  Represents the properties of a table.

• Tag

  Describes a tag. A tag is a key-value pair. You can add up to 50 tags to a single DynamoDB table.

• TimeToLiveDescription

  The description of the Time to Live (TTL) status on the specified table.

• TimeToLiveSpecification

  Represents the settings used to enable or disable Time to Live (TTL) for the specified table.

• TransactGetItem

  Specifies an item to be retrieved as part of the transaction.

• TransactWriteItem

  A list of requests that can perform update, put, delete, or check operations on multiple items in one or more tables atomically.

• Update

  Represents a request to perform an UpdateItem operation.

• UpdateGlobalSecondaryIndexAction

  Represents the new provisioned throughput settings to be applied to a global secondary index.

• UpdateKinesisStreamingConfiguration

  Enables updating the configuration for Kinesis Streaming.

• UpdateReplicationGroupMemberAction

  Represents a replica to be modified.

• WriteRequest

  Represents an operation to perform - either DeleteItem or PutItem. You can only request one of these operations, not both, in a single WriteRequest. If you do need to perform both of these operations, you need to provide two separate WriteRequest objects.

Enums

• ApproximateCreationDateTimePrecision
  When writing a match expression against ApproximateCreationDateTimePrecision, 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.
• AttributeAction
  When writing a match expression against AttributeAction, 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.
• AttributeValue

  Represents the data for an attribute.

• BackupStatus
  When writing a match expression against BackupStatus, 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.
• BackupType
  When writing a match expression against BackupType, 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.
• BackupTypeFilter
  When writing a match expression against BackupTypeFilter, 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.
• BatchStatementErrorCodeEnum
  When writing a match expression against BatchStatementErrorCodeEnum, 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.
• BillingMode
  When writing a match expression against BillingMode, 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.
• ComparisonOperator
  When writing a match expression against ComparisonOperator, 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.
• ConditionalOperator
  When writing a match expression against ConditionalOperator, 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.
• ContinuousBackupsStatus
  When writing a match expression against ContinuousBackupsStatus, 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.
• ContributorInsightsAction
  When writing a match expression against ContributorInsightsAction, 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.
• ContributorInsightsStatus
  When writing a match expression against ContributorInsightsStatus, 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.
• DestinationStatus
  When writing a match expression against DestinationStatus, 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.
• ExportFormat
  When writing a match expression against ExportFormat, 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.
• ExportStatus
  When writing a match expression against ExportStatus, 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.
• ExportType
  When writing a match expression against ExportType, 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.
• ExportViewType
  When writing a match expression against ExportViewType, 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.
• GlobalTableStatus
  When writing a match expression against GlobalTableStatus, 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.
• ImportStatus
  When writing a match expression against ImportStatus, 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.
• IndexStatus
  When writing a match expression against IndexStatus, 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.
• InputCompressionType
  When writing a match expression against InputCompressionType, 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.
• InputFormat
  When writing a match expression against InputFormat, 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.
• KeyType
  When writing a match expression against KeyType, 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.
• PointInTimeRecoveryStatus
  When writing a match expression against PointInTimeRecoveryStatus, 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.
• ProjectionType
  When writing a match expression against ProjectionType, 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.
• ReplicaStatus
  When writing a match expression against ReplicaStatus, 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.
• ReturnConsumedCapacity
  When writing a match expression against ReturnConsumedCapacity, 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.
• ReturnItemCollectionMetrics
  When writing a match expression against ReturnItemCollectionMetrics, 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.
• ReturnValue
  When writing a match expression against ReturnValue, 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.
• ReturnValuesOnConditionCheckFailure
  When writing a match expression against ReturnValuesOnConditionCheckFailure, 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.
• S3SseAlgorithm
  When writing a match expression against S3SseAlgorithm, 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.
• ScalarAttributeType
  When writing a match expression against ScalarAttributeType, 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.
• Select
  When writing a match expression against Select, 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.
• SseStatus
  When writing a match expression against SseStatus, 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.
• SseType
  When writing a match expression against SseType, 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.
• StreamViewType
  When writing a match expression against StreamViewType, 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.
• TableClass
  When writing a match expression against TableClass, 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.
• TableStatus
  When writing a match expression against TableStatus, 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.
• TimeToLiveStatus
  When writing a match expression against TimeToLiveStatus, 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.