%% WARNING: DO NOT EDIT, AUTO-GENERATED CODE! %% See https://github.com/aws-beam/aws-codegen for more details. %% @doc Amazon DynamoDB %% %% Amazon DynamoDB is a fully managed NoSQL database service that provides %% fast and predictable performance with seamless scalability. %% %% DynamoDB lets you offload the administrative burdens of operating and %% scaling a distributed database, so that you don't have to worry about %% hardware provisioning, setup and configuration, replication, software %% patching, or cluster scaling. %% %% With DynamoDB, you can create database tables that can store and retrieve %% any amount of data, and serve any level of request traffic. You can scale %% up or scale down your tables' throughput capacity without downtime or %% performance degradation, and use the Amazon Web Services Management %% Console to monitor resource utilization and performance metrics. %% %% DynamoDB automatically spreads the data and traffic for your tables over a %% sufficient number of servers to handle your throughput and storage %% requirements, while maintaining consistent and fast performance. All of %% your data is stored on solid state disks (SSDs) and automatically %% replicated across multiple Availability Zones in an Amazon Web Services %% Region, providing built-in high availability and data durability. -module(aws_dynamodb). -export([batch_execute_statement/2, batch_execute_statement/3, batch_get_item/2, batch_get_item/3, batch_write_item/2, batch_write_item/3, create_backup/2, create_backup/3, create_global_table/2, create_global_table/3, create_table/2, create_table/3, delete_backup/2, delete_backup/3, delete_item/2, delete_item/3, delete_table/2, delete_table/3, describe_backup/2, describe_backup/3, describe_continuous_backups/2, describe_continuous_backups/3, describe_contributor_insights/2, describe_contributor_insights/3, describe_endpoints/2, describe_endpoints/3, describe_export/2, describe_export/3, describe_global_table/2, describe_global_table/3, describe_global_table_settings/2, describe_global_table_settings/3, describe_import/2, describe_import/3, describe_kinesis_streaming_destination/2, describe_kinesis_streaming_destination/3, describe_limits/2, describe_limits/3, describe_table/2, describe_table/3, describe_table_replica_auto_scaling/2, describe_table_replica_auto_scaling/3, describe_time_to_live/2, describe_time_to_live/3, disable_kinesis_streaming_destination/2, disable_kinesis_streaming_destination/3, enable_kinesis_streaming_destination/2, enable_kinesis_streaming_destination/3, execute_statement/2, execute_statement/3, execute_transaction/2, execute_transaction/3, export_table_to_point_in_time/2, export_table_to_point_in_time/3, get_item/2, get_item/3, import_table/2, import_table/3, list_backups/2, list_backups/3, list_contributor_insights/2, list_contributor_insights/3, list_exports/2, list_exports/3, list_global_tables/2, list_global_tables/3, list_imports/2, list_imports/3, list_tables/2, list_tables/3, list_tags_of_resource/2, list_tags_of_resource/3, put_item/2, put_item/3, query/2, query/3, restore_table_from_backup/2, restore_table_from_backup/3, restore_table_to_point_in_time/2, restore_table_to_point_in_time/3, scan/2, scan/3, tag_resource/2, tag_resource/3, transact_get_items/2, transact_get_items/3, transact_write_items/2, transact_write_items/3, untag_resource/2, untag_resource/3, update_continuous_backups/2, update_continuous_backups/3, update_contributor_insights/2, update_contributor_insights/3, update_global_table/2, update_global_table/3, update_global_table_settings/2, update_global_table_settings/3, update_item/2, update_item/3, update_table/2, update_table/3, update_table_replica_auto_scaling/2, update_table_replica_auto_scaling/3, update_time_to_live/2, update_time_to_live/3]). -include_lib("hackney/include/hackney_lib.hrl"). %%==================================================================== %% API %%==================================================================== %% @doc This operation allows you to perform batch reads or writes on data %% stored in DynamoDB, using PartiQL. %% %% Each read statement in a `BatchExecuteStatement' must specify an equality %% condition on all key attributes. This enforces that each `SELECT' %% statement in a batch returns at most a single item. %% %% The entire batch must consist of either read statements or write %% statements, you cannot mix both in one batch. %% %% A HTTP 200 response does not mean that all statements in the %% BatchExecuteStatement succeeded. Error details for individual statements %% can be found under the Error field of the `BatchStatementResponse' for %% each statement. batch_execute_statement(Client, Input) when is_map(Client), is_map(Input) -> batch_execute_statement(Client, Input, []). batch_execute_statement(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"BatchExecuteStatement">>, Input, Options). %% @doc The `BatchGetItem' operation returns the attributes of one or more %% items from one or more tables. %% %% You identify requested items by primary key. %% %% A single operation can retrieve up to 16 MB of data, which can contain as %% many as 100 items. `BatchGetItem' returns a partial result if the response %% size limit is exceeded, the table's provisioned throughput is exceeded, or %% an internal processing failure occurs. If a partial result is returned, %% the operation returns a value for `UnprocessedKeys'. You can use this %% value to retry the operation starting with the next item to get. %% %% If you request more than 100 items, `BatchGetItem' returns a %% `ValidationException' with the message "Too many items requested for the %% BatchGetItem call." %% %% For example, if you ask to retrieve 100 items, but each individual item is %% 300 KB in size, the system returns 52 items (so as not to exceed the 16 MB %% limit). It also returns an appropriate `UnprocessedKeys' value so you can %% get the next page of results. If desired, your application can include its %% own logic to assemble the pages of results into one dataset. %% %% If none of the items can be processed due to insufficient provisioned %% throughput on all of the tables in the request, then `BatchGetItem' %% returns a `ProvisionedThroughputExceededException'. If at least one of the %% items is successfully processed, then `BatchGetItem' completes %% successfully, while returning the keys of the unread items in %% `UnprocessedKeys'. %% %% If DynamoDB returns any unprocessed items, you should retry the batch %% operation on those items. However, we strongly recommend that you use an %% exponential backoff algorithm. If you retry the batch operation %% immediately, the underlying read or write requests can still fail due to %% throttling on the individual tables. If you delay the batch operation %% using exponential backoff, the individual requests in the batch are much %% more likely to succeed. %% %% For more information, see Batch Operations and Error Handling in the %% Amazon DynamoDB Developer Guide. %% %% By default, `BatchGetItem' performs eventually consistent reads on every %% table in the request. If you want strongly consistent reads instead, you %% can set `ConsistentRead' to `true' for any or all tables. %% %% In order to minimize response latency, `BatchGetItem' retrieves items in %% parallel. %% %% When designing your application, keep in mind that DynamoDB does not %% return items in any particular order. To help parse the response by item, %% include the primary key values for the items in your request in the %% `ProjectionExpression' parameter. %% %% If a requested item does not exist, it is not returned in the result. %% Requests for nonexistent items consume the minimum read capacity units %% according to the type of read. For more information, see Working with %% Tables in the Amazon DynamoDB Developer Guide. batch_get_item(Client, Input) when is_map(Client), is_map(Input) -> batch_get_item(Client, Input, []). batch_get_item(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"BatchGetItem">>, Input, Options). %% @doc The `BatchWriteItem' operation puts or deletes multiple items in one %% or more tables. %% %% A single call to `BatchWriteItem' can transmit up to 16MB of data over the %% network, consisting of up to 25 item put or delete operations. While %% individual items can be up to 400 KB once stored, it's important to note %% that an item's representation might be greater than 400KB while being sent %% in DynamoDB's JSON format for the API call. For more details on this %% distinction, see Naming Rules and Data Types. %% %% `BatchWriteItem' cannot update items. If you perform a `BatchWriteItem' %% operation on an existing item, that item's values will be overwritten by %% the operation and it will appear like it was updated. To update items, we %% recommend you use the `UpdateItem' action. %% %% The individual `PutItem' and `DeleteItem' operations specified in %% `BatchWriteItem' are atomic; however `BatchWriteItem' as a whole is not. %% If any requested operations fail because the table's provisioned %% throughput is exceeded or an internal processing failure occurs, the %% failed operations are returned in the `UnprocessedItems' response %% parameter. You can investigate and optionally resend the requests. %% Typically, you would call `BatchWriteItem' in a loop. Each iteration would %% check for unprocessed items and submit a new `BatchWriteItem' request with %% those unprocessed items until all items have been processed. %% %% If none of the items can be processed due to insufficient provisioned %% throughput on all of the tables in the request, then `BatchWriteItem' %% returns a `ProvisionedThroughputExceededException'. %% %% If DynamoDB returns any unprocessed items, you should retry the batch %% operation on those items. However, we strongly recommend that you use an %% exponential backoff algorithm. If you retry the batch operation %% immediately, the underlying read or write requests can still fail due to %% throttling on the individual tables. If you delay the batch operation %% using exponential backoff, the individual requests in the batch are much %% more likely to succeed. %% %% For more information, see Batch Operations and Error Handling in the %% Amazon DynamoDB Developer Guide. %% %% With `BatchWriteItem', you can efficiently write or delete large amounts %% of data, such as from Amazon EMR, or copy data from another database into %% DynamoDB. In order to improve performance with these large-scale %% operations, `BatchWriteItem' does not behave in the same way as individual %% `PutItem' and `DeleteItem' calls would. For example, you cannot specify %% conditions on individual put and delete requests, and `BatchWriteItem' %% does not return deleted items in the response. %% %% If you use a programming language that supports concurrency, you can use %% threads to write items in parallel. Your application must include the %% necessary logic to manage the threads. With languages that don't support %% threading, you must update or delete the specified items one at a time. In %% both situations, `BatchWriteItem' performs the specified put and delete %% operations in parallel, giving you the power of the thread pool approach %% without having to introduce complexity into your application. %% %% Parallel processing reduces latency, but each specified put and delete %% request consumes the same number of write capacity units whether it is %% processed in parallel or not. Delete operations on nonexistent items %% consume one write capacity unit. %% %% If one or more of the following is true, DynamoDB rejects the entire batch %% write operation: %% %% batch_write_item(Client, Input) when is_map(Client), is_map(Input) -> batch_write_item(Client, Input, []). batch_write_item(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"BatchWriteItem">>, Input, Options). %% @doc Creates a backup for an existing table. %% %% Each time you create an on-demand backup, the entire table data is backed %% up. There is no limit to the number of on-demand backups that can be %% taken. %% %% When you create an on-demand backup, a time marker of the request is %% cataloged, and the backup is created asynchronously, by applying all %% changes until the time of the request to the last full table snapshot. %% Backup requests are processed instantaneously and become available for %% restore within minutes. %% %% You can call `CreateBackup' at a maximum rate of 50 times per second. %% %% All backups in DynamoDB work without consuming any provisioned throughput %% on the table. %% %% If you submit a backup request on 2018-12-14 at 14:25:00, the backup is %% guaranteed to contain all data committed to the table up to 14:24:00, and %% data committed after 14:26:00 will not be. The backup might contain data %% modifications made between 14:24:00 and 14:26:00. On-demand backup does %% not support causal consistency. %% %% Along with data, the following are also included on the backups: %% %% create_backup(Client, Input) when is_map(Client), is_map(Input) -> create_backup(Client, Input, []). create_backup(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"CreateBackup">>, Input, Options). %% @doc Creates a global table from an existing table. %% %% A global table creates a replication relationship between two or more %% DynamoDB tables with the same table name in the provided Regions. %% %% This operation only applies to Version 2017.11.29 of global tables. %% %% If you want to add a new replica table to a global table, each of the %% following conditions must be true: %% %% If global secondary indexes are specified, then the following %% conditions must also be met: %% %% If local secondary indexes are specified, then the following %% conditions must also be met: %% %% Write capacity settings should be set consistently across your %% replica tables and secondary indexes. DynamoDB strongly recommends %% enabling auto scaling to manage the write capacity settings for all of %% your global tables replicas and indexes. %% %% If you prefer to manage write capacity settings manually, you should %% provision equal replicated write capacity units to your replica tables. %% You should also provision equal replicated write capacity units to %% matching secondary indexes across your global table. create_global_table(Client, Input) when is_map(Client), is_map(Input) -> create_global_table(Client, Input, []). create_global_table(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"CreateGlobalTable">>, Input, Options). %% @doc The `CreateTable' operation adds a new table to your account. %% %% In an Amazon Web Services account, table names must be unique within each %% Region. That is, you can have two tables with same name if you create the %% tables in different Regions. %% %% `CreateTable' is an asynchronous operation. Upon receiving a `CreateTable' %% request, DynamoDB immediately returns a response with a `TableStatus' of %% `CREATING'. After the table is created, DynamoDB sets the `TableStatus' to %% `ACTIVE'. You can perform read and write operations only on an `ACTIVE' %% table. %% %% You can optionally define secondary indexes on the new table, as part of %% the `CreateTable' operation. If you want to create multiple tables with %% secondary indexes on them, you must create the tables sequentially. Only %% one table with secondary indexes can be in the `CREATING' state at any %% given time. %% %% You can use the `DescribeTable' action to check the table status. create_table(Client, Input) when is_map(Client), is_map(Input) -> create_table(Client, Input, []). create_table(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"CreateTable">>, Input, Options). %% @doc Deletes an existing backup of a table. %% %% You can call `DeleteBackup' at a maximum rate of 10 times per second. delete_backup(Client, Input) when is_map(Client), is_map(Input) -> delete_backup(Client, Input, []). delete_backup(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DeleteBackup">>, Input, Options). %% @doc Deletes a single item in a table by primary key. %% %% You can perform a conditional delete operation that deletes the item if it %% exists, or if it has an expected attribute value. %% %% In addition to deleting an item, you can also return the item's attribute %% values in the same operation, using the `ReturnValues' parameter. %% %% Unless you specify conditions, the `DeleteItem' is an idempotent %% operation; running it multiple times on the same item or attribute does %% not result in an error response. %% %% Conditional deletes are useful for deleting items only if specific %% conditions are met. If those conditions are met, DynamoDB performs the %% delete. Otherwise, the item is not deleted. delete_item(Client, Input) when is_map(Client), is_map(Input) -> delete_item(Client, Input, []). delete_item(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DeleteItem">>, Input, Options). %% @doc The `DeleteTable' operation deletes a table and all of its items. %% %% After a `DeleteTable' request, the specified table is in the `DELETING' %% state until DynamoDB completes the deletion. If the table is in the %% `ACTIVE' state, you can delete it. If a table is in `CREATING' or %% `UPDATING' states, then DynamoDB returns a `ResourceInUseException'. If %% the specified table does not exist, DynamoDB returns a %% `ResourceNotFoundException'. If table is already in the `DELETING' state, %% no error is returned. %% %% DynamoDB might continue to accept data read and write operations, such as %% `GetItem' and `PutItem', on a table in the `DELETING' state until the %% table deletion is complete. %% %% When you delete a table, any indexes on that table are also deleted. %% %% If you have DynamoDB Streams enabled on the table, then the corresponding %% stream on that table goes into the `DISABLED' state, and the stream is %% automatically deleted after 24 hours. %% %% Use the `DescribeTable' action to check the status of the table. delete_table(Client, Input) when is_map(Client), is_map(Input) -> delete_table(Client, Input, []). delete_table(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DeleteTable">>, Input, Options). %% @doc Describes an existing backup of a table. %% %% You can call `DescribeBackup' at a maximum rate of 10 times per second. describe_backup(Client, Input) when is_map(Client), is_map(Input) -> describe_backup(Client, Input, []). describe_backup(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeBackup">>, Input, Options). %% @doc Checks the status of continuous backups and point in time recovery on %% the specified table. %% %% Continuous backups are `ENABLED' on all tables at table creation. If point %% in time recovery is enabled, `PointInTimeRecoveryStatus' will be set to %% ENABLED. %% %% After continuous backups and point in time recovery are enabled, you can %% restore to any point in time within `EarliestRestorableDateTime' and %% `LatestRestorableDateTime'. %% %% `LatestRestorableDateTime' is typically 5 minutes before the current time. %% You can restore your table to any point in time during the last 35 days. %% %% You can call `DescribeContinuousBackups' at a maximum rate of 10 times per %% second. describe_continuous_backups(Client, Input) when is_map(Client), is_map(Input) -> describe_continuous_backups(Client, Input, []). describe_continuous_backups(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeContinuousBackups">>, Input, Options). %% @doc Returns information about contributor insights, for a given table or %% global secondary index. describe_contributor_insights(Client, Input) when is_map(Client), is_map(Input) -> describe_contributor_insights(Client, Input, []). describe_contributor_insights(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeContributorInsights">>, Input, Options). %% @doc Returns the regional endpoint information. describe_endpoints(Client, Input) when is_map(Client), is_map(Input) -> describe_endpoints(Client, Input, []). describe_endpoints(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeEndpoints">>, Input, Options). %% @doc Describes an existing table export. describe_export(Client, Input) when is_map(Client), is_map(Input) -> describe_export(Client, Input, []). describe_export(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeExport">>, Input, Options). %% @doc Returns information about the specified global table. %% %% This operation only applies to Version 2017.11.29 of global tables. If you %% are using global tables Version 2019.11.21 you can use DescribeTable %% instead. describe_global_table(Client, Input) when is_map(Client), is_map(Input) -> describe_global_table(Client, Input, []). describe_global_table(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeGlobalTable">>, Input, Options). %% @doc Describes Region-specific settings for a global table. %% %% This operation only applies to Version 2017.11.29 of global tables. describe_global_table_settings(Client, Input) when is_map(Client), is_map(Input) -> describe_global_table_settings(Client, Input, []). describe_global_table_settings(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeGlobalTableSettings">>, Input, Options). %% @doc Represents the properties of the import. describe_import(Client, Input) when is_map(Client), is_map(Input) -> describe_import(Client, Input, []). describe_import(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeImport">>, Input, Options). %% @doc Returns information about the status of Kinesis streaming. describe_kinesis_streaming_destination(Client, Input) when is_map(Client), is_map(Input) -> describe_kinesis_streaming_destination(Client, Input, []). describe_kinesis_streaming_destination(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeKinesisStreamingDestination">>, Input, Options). %% @doc Returns the current provisioned-capacity quotas for your Amazon Web %% Services account in a Region, both for the Region as a whole and for any %% one DynamoDB table that you create there. %% %% When you establish an Amazon Web Services account, the account has initial %% quotas on the maximum read capacity units and write capacity units that %% you can provision across all of your DynamoDB tables in a given Region. %% Also, there are per-table quotas that apply when you create a table there. %% For more information, see Service, Account, and Table Quotas page in the %% Amazon DynamoDB Developer Guide. %% %% Although you can increase these quotas by filing a case at Amazon Web %% Services Support Center, obtaining the increase is not instantaneous. The %% `DescribeLimits' action lets you write code to compare the capacity you %% are currently using to those quotas imposed by your account so that you %% have enough time to apply for an increase before you hit a quota. %% %% For example, you could use one of the Amazon Web Services SDKs to do the %% following: %% %%
  1. Call `DescribeLimits' for a particular Region to obtain your %% current account quotas on provisioned capacity there. %% %%
  2. Create a variable to hold the aggregate read capacity units %% provisioned for all your tables in that Region, and one to hold the %% aggregate write capacity units. Zero them both. %% %%
  3. Call `ListTables' to obtain a list of all your DynamoDB tables. %% %%
  4. For each table name listed by `ListTables', do the following: %% %%
  5. Report the account quotas for that Region returned %% by `DescribeLimits', along with the total current provisioned capacity %% levels you have calculated. %% %%
This will let you see whether you are getting close to your %% account-level quotas. %% %% The per-table quotas apply only when you are creating a new table. They %% restrict the sum of the provisioned capacity of the new table itself and %% all its global secondary indexes. %% %% For existing tables and their GSIs, DynamoDB doesn't let you increase %% provisioned capacity extremely rapidly, but the only quota that applies is %% that the aggregate provisioned capacity over all your tables and GSIs %% cannot exceed either of the per-account quotas. %% %% `DescribeLimits' should only be called periodically. You can expect %% throttling errors if you call it more than once in a minute. %% %% The `DescribeLimits' Request element has no content. describe_limits(Client, Input) when is_map(Client), is_map(Input) -> describe_limits(Client, Input, []). describe_limits(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeLimits">>, Input, Options). %% @doc Returns information about the table, including the current status of %% the table, when it was created, the primary key schema, and any indexes on %% the table. %% %% If you issue a `DescribeTable' request immediately after a `CreateTable' %% request, DynamoDB might return a `ResourceNotFoundException'. This is %% because `DescribeTable' uses an eventually consistent query, and the %% metadata for your table might not be available at that moment. Wait for a %% few seconds, and then try the `DescribeTable' request again. describe_table(Client, Input) when is_map(Client), is_map(Input) -> describe_table(Client, Input, []). describe_table(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeTable">>, Input, Options). %% @doc Describes auto scaling settings across replicas of the global table %% at once. %% %% This operation only applies to Version 2019.11.21 of global tables. describe_table_replica_auto_scaling(Client, Input) when is_map(Client), is_map(Input) -> describe_table_replica_auto_scaling(Client, Input, []). describe_table_replica_auto_scaling(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeTableReplicaAutoScaling">>, Input, Options). %% @doc Gives a description of the Time to Live (TTL) status on the specified %% table. describe_time_to_live(Client, Input) when is_map(Client), is_map(Input) -> describe_time_to_live(Client, Input, []). describe_time_to_live(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeTimeToLive">>, Input, Options). %% @doc Stops replication from the DynamoDB table to the Kinesis data stream. %% %% This is done without deleting either of the resources. disable_kinesis_streaming_destination(Client, Input) when is_map(Client), is_map(Input) -> disable_kinesis_streaming_destination(Client, Input, []). disable_kinesis_streaming_destination(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DisableKinesisStreamingDestination">>, Input, Options). %% @doc Starts table data replication to the specified Kinesis data stream at %% a timestamp chosen during the enable workflow. %% %% If this operation doesn't return results immediately, use %% DescribeKinesisStreamingDestination to check if streaming to the Kinesis %% data stream is ACTIVE. enable_kinesis_streaming_destination(Client, Input) when is_map(Client), is_map(Input) -> enable_kinesis_streaming_destination(Client, Input, []). enable_kinesis_streaming_destination(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"EnableKinesisStreamingDestination">>, Input, Options). %% @doc This operation allows you to perform reads and singleton writes on %% data stored in DynamoDB, using PartiQL. %% %% For PartiQL reads (`SELECT' statement), if the total number of processed %% items exceeds the maximum dataset size limit of 1 MB, the read stops and %% results are returned to the user as a `LastEvaluatedKey' value to continue %% the read in a subsequent operation. If the filter criteria in `WHERE' %% clause does not match any data, the read will return an empty result set. %% %% A single `SELECT' statement response can return up to the maximum number %% of items (if using the Limit parameter) or a maximum of 1 MB of data (and %% then apply any filtering to the results using `WHERE' clause). If %% `LastEvaluatedKey' is present in the response, you need to paginate the %% result set. execute_statement(Client, Input) when is_map(Client), is_map(Input) -> execute_statement(Client, Input, []). execute_statement(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ExecuteStatement">>, Input, Options). %% @doc This operation allows you to perform transactional reads or writes on %% data stored in DynamoDB, using PartiQL. %% %% The entire transaction must consist of either read statements or write %% statements, you cannot mix both in one transaction. The EXISTS function is %% an exception and can be used to check the condition of specific attributes %% of the item in a similar manner to `ConditionCheck' in the %% TransactWriteItems API. execute_transaction(Client, Input) when is_map(Client), is_map(Input) -> execute_transaction(Client, Input, []). execute_transaction(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ExecuteTransaction">>, Input, Options). %% @doc Exports table data to an S3 bucket. %% %% The table must have point in time recovery enabled, and you can export %% data from any time within the point in time recovery window. export_table_to_point_in_time(Client, Input) when is_map(Client), is_map(Input) -> export_table_to_point_in_time(Client, Input, []). export_table_to_point_in_time(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ExportTableToPointInTime">>, Input, Options). %% @doc The `GetItem' operation returns a set of attributes for the item with %% the given primary key. %% %% If there is no matching item, `GetItem' does not return any data and there %% will be no `Item' element in the response. %% %% `GetItem' provides an eventually consistent read by default. If your %% application requires a strongly consistent read, set `ConsistentRead' to %% `true'. Although a strongly consistent read might take more time than an %% eventually consistent read, it always returns the last updated value. get_item(Client, Input) when is_map(Client), is_map(Input) -> get_item(Client, Input, []). get_item(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"GetItem">>, Input, Options). %% @doc Imports table data from an S3 bucket. import_table(Client, Input) when is_map(Client), is_map(Input) -> import_table(Client, Input, []). import_table(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ImportTable">>, Input, Options). %% @doc List backups associated with an Amazon Web Services account. %% %% To list backups for a given table, specify `TableName'. `ListBackups' %% returns a paginated list of results with at most 1 MB worth of items in a %% page. You can also specify a maximum number of entries to be returned in a %% page. %% %% In the request, start time is inclusive, but end time is exclusive. Note %% that these boundaries are for the time at which the original backup was %% requested. %% %% You can call `ListBackups' a maximum of five times per second. list_backups(Client, Input) when is_map(Client), is_map(Input) -> list_backups(Client, Input, []). list_backups(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ListBackups">>, Input, Options). %% @doc Returns a list of ContributorInsightsSummary for a table and all its %% global secondary indexes. list_contributor_insights(Client, Input) when is_map(Client), is_map(Input) -> list_contributor_insights(Client, Input, []). list_contributor_insights(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ListContributorInsights">>, Input, Options). %% @doc Lists completed exports within the past 90 days. list_exports(Client, Input) when is_map(Client), is_map(Input) -> list_exports(Client, Input, []). list_exports(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ListExports">>, Input, Options). %% @doc Lists all global tables that have a replica in the specified Region. %% %% This operation only applies to Version 2017.11.29 of global tables. list_global_tables(Client, Input) when is_map(Client), is_map(Input) -> list_global_tables(Client, Input, []). list_global_tables(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ListGlobalTables">>, Input, Options). %% @doc Lists completed imports within the past 90 days. list_imports(Client, Input) when is_map(Client), is_map(Input) -> list_imports(Client, Input, []). list_imports(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ListImports">>, Input, Options). %% @doc Returns an array of table names associated with the current account %% and endpoint. %% %% The output from `ListTables' is paginated, with each page returning a %% maximum of 100 table names. list_tables(Client, Input) when is_map(Client), is_map(Input) -> list_tables(Client, Input, []). list_tables(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ListTables">>, Input, Options). %% @doc List all tags on an Amazon DynamoDB resource. %% %% You can call ListTagsOfResource up to 10 times per second, per account. %% %% For an overview on tagging DynamoDB resources, see Tagging for DynamoDB in %% the Amazon DynamoDB Developer Guide. list_tags_of_resource(Client, Input) when is_map(Client), is_map(Input) -> list_tags_of_resource(Client, Input, []). list_tags_of_resource(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ListTagsOfResource">>, Input, Options). %% @doc Creates a new item, or replaces an old item with a new item. %% %% If an item that has the same primary key as the new item already exists in %% the specified table, the new item completely replaces the existing item. %% You can perform a conditional put operation (add a new item if one with %% the specified primary key doesn't exist), or replace an existing item if %% it has certain attribute values. You can return the item's attribute %% values in the same operation, using the `ReturnValues' parameter. %% %% When you add an item, the primary key attributes are the only required %% attributes. %% %% Empty String and Binary attribute values are allowed. Attribute values of %% type String and Binary must have a length greater than zero if the %% attribute is used as a key attribute for a table or index. Set type %% attributes cannot be empty. %% %% Invalid Requests with empty values will be rejected with a %% `ValidationException' exception. %% %% To prevent a new item from replacing an existing item, use a conditional %% expression that contains the `attribute_not_exists' function with the name %% of the attribute being used as the partition key for the table. Since %% every record must contain that attribute, the `attribute_not_exists' %% function will only succeed if no matching item exists. %% %% For more information about `PutItem', see Working with Items in the Amazon %% DynamoDB Developer Guide. put_item(Client, Input) when is_map(Client), is_map(Input) -> put_item(Client, Input, []). put_item(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"PutItem">>, Input, Options). %% @doc You must provide the name of the partition key attribute and a single %% value for that attribute. %% %% `Query' returns all items with that partition key value. Optionally, you %% can provide a sort key attribute and use a comparison operator to refine %% the search results. %% %% Use the `KeyConditionExpression' parameter to provide a specific value for %% the partition key. The `Query' operation will return all of the items from %% the table or index with that partition key value. You can optionally %% narrow the scope of the `Query' operation by specifying a sort key value %% and a comparison operator in `KeyConditionExpression'. To further refine %% the `Query' results, you can optionally provide a `FilterExpression'. A %% `FilterExpression' determines which items within the results should be %% returned to you. All of the other results are discarded. %% %% A `Query' operation always returns a result set. If no matching items are %% found, the result set will be empty. Queries that do not return results %% consume the minimum number of read capacity units for that type of read %% operation. %% %% DynamoDB calculates the number of read capacity units consumed based on %% item size, not on the amount of data that is returned to an application. %% The number of capacity units consumed will be the same whether you request %% all of the attributes (the default behavior) or just some of them (using a %% projection expression). The number will also be the same whether or not %% you use a `FilterExpression'. %% %% `Query' results are always sorted by the sort key value. If the data type %% of the sort key is Number, the results are returned in numeric order; %% otherwise, the results are returned in order of UTF-8 bytes. By default, %% the sort order is ascending. To reverse the order, set the %% `ScanIndexForward' parameter to false. %% %% A single `Query' operation will read up to the maximum number of items set %% (if using the `Limit' parameter) or a maximum of 1 MB of data and then %% apply any filtering to the results using `FilterExpression'. If %% `LastEvaluatedKey' is present in the response, you will need to paginate %% the result set. For more information, see Paginating the Results in the %% Amazon DynamoDB Developer Guide. %% %% `FilterExpression' is applied after a `Query' finishes, but before the %% results are returned. A `FilterExpression' cannot contain partition key or %% sort key attributes. You need to specify those attributes in the %% `KeyConditionExpression'. %% %% A `Query' operation can return an empty result set and a %% `LastEvaluatedKey' if all the items read for the page of results are %% filtered out. %% %% You can query a table, a local secondary index, or a global secondary %% index. For a query on a table or on a local secondary index, you can set %% the `ConsistentRead' parameter to `true' and obtain a strongly consistent %% result. Global secondary indexes support eventually consistent reads only, %% so do not specify `ConsistentRead' when querying a global secondary index. query(Client, Input) when is_map(Client), is_map(Input) -> query(Client, Input, []). query(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"Query">>, Input, Options). %% @doc Creates a new table from an existing backup. %% %% Any number of users can execute up to 4 concurrent restores (any type of %% restore) in a given account. %% %% You can call `RestoreTableFromBackup' at a maximum rate of 10 times per %% second. %% %% You must manually set up the following on the restored table: %% %% restore_table_from_backup(Client, Input) when is_map(Client), is_map(Input) -> restore_table_from_backup(Client, Input, []). restore_table_from_backup(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"RestoreTableFromBackup">>, Input, Options). %% @doc Restores the specified table to the specified point in time within %% `EarliestRestorableDateTime' and `LatestRestorableDateTime'. %% %% You can restore your table to any point in time during the last 35 days. %% Any number of users can execute up to 4 concurrent restores (any type of %% restore) in a given account. %% %% When you restore using point in time recovery, DynamoDB restores your %% table data to the state based on the selected date and time %% (day:hour:minute:second) to a new table. %% %% Along with data, the following are also included on the new restored table %% using point in time recovery: %% %% You must manually set up the following on the restored table: %% %% restore_table_to_point_in_time(Client, Input) when is_map(Client), is_map(Input) -> restore_table_to_point_in_time(Client, Input, []). restore_table_to_point_in_time(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"RestoreTableToPointInTime">>, Input, Options). %% @doc The `Scan' operation returns one or more items and item attributes by %% accessing every item in a table or a secondary index. %% %% To have DynamoDB return fewer items, you can provide a `FilterExpression' %% operation. %% %% If the total number of scanned items exceeds the maximum dataset size %% limit of 1 MB, the scan stops and results are returned to the user as a %% `LastEvaluatedKey' value to continue the scan in a subsequent operation. %% The results also include the number of items exceeding the limit. A scan %% can result in no table data meeting the filter criteria. %% %% A single `Scan' operation reads up to the maximum number of items set (if %% using the `Limit' parameter) or a maximum of 1 MB of data and then apply %% any filtering to the results using `FilterExpression'. If %% `LastEvaluatedKey' is present in the response, you need to paginate the %% result set. For more information, see Paginating the Results in the Amazon %% DynamoDB Developer Guide. %% %% `Scan' operations proceed sequentially; however, for faster performance on %% a large table or secondary index, applications can request a parallel %% `Scan' operation by providing the `Segment' and `TotalSegments' %% parameters. For more information, see Parallel Scan in the Amazon DynamoDB %% Developer Guide. %% %% `Scan' uses eventually consistent reads when accessing the data in a %% table; therefore, the result set might not include the changes to data in %% the table immediately before the operation began. If you need a consistent %% copy of the data, as of the time that the `Scan' begins, you can set the %% `ConsistentRead' parameter to `true'. scan(Client, Input) when is_map(Client), is_map(Input) -> scan(Client, Input, []). scan(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"Scan">>, Input, Options). %% @doc Associate a set of tags with an Amazon DynamoDB resource. %% %% You can then activate these user-defined tags so that they appear on the %% Billing and Cost Management console for cost allocation tracking. You can %% call TagResource up to five times per second, per account. %% %% For an overview on tagging DynamoDB resources, see Tagging for DynamoDB in %% the Amazon DynamoDB Developer Guide. tag_resource(Client, Input) when is_map(Client), is_map(Input) -> tag_resource(Client, Input, []). tag_resource(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"TagResource">>, Input, Options). %% @doc `TransactGetItems' is a synchronous operation that atomically %% retrieves multiple items from one or more tables (but not from indexes) in %% a single account and Region. %% %% A `TransactGetItems' call can contain up to 100 `TransactGetItem' objects, %% each of which contains a `Get' structure that specifies an item to %% retrieve from a table in the account and Region. A call to %% `TransactGetItems' cannot retrieve items from tables in more than one %% Amazon Web Services account or Region. The aggregate size of the items in %% the transaction cannot exceed 4 MB. %% %% DynamoDB rejects the entire `TransactGetItems' request if any of the %% following is true: %% %% transact_get_items(Client, Input) when is_map(Client), is_map(Input) -> transact_get_items(Client, Input, []). transact_get_items(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"TransactGetItems">>, Input, Options). %% @doc `TransactWriteItems' is a synchronous write operation that groups up %% to 100 action requests. %% %% These actions can target items in different tables, but not in different %% Amazon Web Services accounts or Regions, and no two actions can target the %% same item. For example, you cannot both `ConditionCheck' and `Update' the %% same item. The aggregate size of the items in the transaction cannot %% exceed 4 MB. %% %% The actions are completed atomically so that either all of them succeed, %% or all of them fail. They are defined by the following objects: %% %% DynamoDB rejects the entire `TransactWriteItems' request if %% any of the following is true: %% %% transact_write_items(Client, Input) when is_map(Client), is_map(Input) -> transact_write_items(Client, Input, []). transact_write_items(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"TransactWriteItems">>, Input, Options). %% @doc Removes the association of tags from an Amazon DynamoDB resource. %% %% You can call `UntagResource' up to five times per second, per account. %% %% For an overview on tagging DynamoDB resources, see Tagging for DynamoDB in %% the Amazon DynamoDB Developer Guide. untag_resource(Client, Input) when is_map(Client), is_map(Input) -> untag_resource(Client, Input, []). untag_resource(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"UntagResource">>, Input, Options). %% @doc `UpdateContinuousBackups' enables or disables point in time recovery %% for the specified table. %% %% A successful `UpdateContinuousBackups' call returns the current %% `ContinuousBackupsDescription'. Continuous backups are `ENABLED' on all %% tables at table creation. If point in time recovery is enabled, %% `PointInTimeRecoveryStatus' will be set to ENABLED. %% %% Once continuous backups and point in time recovery are enabled, you can %% restore to any point in time within `EarliestRestorableDateTime' and %% `LatestRestorableDateTime'. %% %% `LatestRestorableDateTime' is typically 5 minutes before the current time. %% You can restore your table to any point in time during the last 35 days. update_continuous_backups(Client, Input) when is_map(Client), is_map(Input) -> update_continuous_backups(Client, Input, []). update_continuous_backups(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"UpdateContinuousBackups">>, Input, Options). %% @doc Updates the status for contributor insights for a specific table or %% index. %% %% CloudWatch Contributor Insights for DynamoDB graphs display the partition %% key and (if applicable) sort key of frequently accessed items and %% frequently throttled items in plaintext. If you require the use of Amazon %% Web Services Key Management Service (KMS) to encrypt this table’s %% partition key and sort key data with an Amazon Web Services managed key or %% customer managed key, you should not enable CloudWatch Contributor %% Insights for DynamoDB for this table. update_contributor_insights(Client, Input) when is_map(Client), is_map(Input) -> update_contributor_insights(Client, Input, []). update_contributor_insights(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"UpdateContributorInsights">>, Input, Options). %% @doc Adds or removes replicas in the specified global table. %% %% The global table must already exist to be able to use this operation. Any %% replica to be added must be empty, have the same name as the global table, %% have the same key schema, have DynamoDB Streams enabled, and have the same %% provisioned and maximum write capacity units. %% %% Although you can use `UpdateGlobalTable' to add replicas and remove %% replicas in a single request, for simplicity we recommend that you issue %% separate requests for adding or removing replicas. %% %% If global secondary indexes are specified, then the following conditions %% must also be met: %% %% update_global_table(Client, Input) when is_map(Client), is_map(Input) -> update_global_table(Client, Input, []). update_global_table(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"UpdateGlobalTable">>, Input, Options). %% @doc Updates settings for a global table. update_global_table_settings(Client, Input) when is_map(Client), is_map(Input) -> update_global_table_settings(Client, Input, []). update_global_table_settings(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"UpdateGlobalTableSettings">>, Input, Options). %% @doc Edits an existing item's attributes, or adds a new item to the table %% if it does not already exist. %% %% You can put, delete, or add attribute values. You can also perform a %% conditional update on an existing item (insert a new attribute name-value %% pair if it doesn't exist, or replace an existing name-value pair if it has %% certain expected attribute values). %% %% You can also return the item's attribute values in the same `UpdateItem' %% operation using the `ReturnValues' parameter. update_item(Client, Input) when is_map(Client), is_map(Input) -> update_item(Client, Input, []). update_item(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"UpdateItem">>, Input, Options). %% @doc Modifies the provisioned throughput settings, global secondary %% indexes, or DynamoDB Streams settings for a given table. %% %% You can only perform one of the following operations at once: %% %% `UpdateTable' is an asynchronous operation; while it is %% executing, the table status changes from `ACTIVE' to `UPDATING'. While it %% is `UPDATING', you cannot issue another `UpdateTable' request. When the %% table returns to the `ACTIVE' state, the `UpdateTable' operation is %% complete. update_table(Client, Input) when is_map(Client), is_map(Input) -> update_table(Client, Input, []). update_table(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"UpdateTable">>, Input, Options). %% @doc Updates auto scaling settings on your global tables at once. %% %% This operation only applies to Version 2019.11.21 of global tables. update_table_replica_auto_scaling(Client, Input) when is_map(Client), is_map(Input) -> update_table_replica_auto_scaling(Client, Input, []). update_table_replica_auto_scaling(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"UpdateTableReplicaAutoScaling">>, Input, Options). %% @doc The `UpdateTimeToLive' method enables or disables Time to Live (TTL) %% for the specified table. %% %% A successful `UpdateTimeToLive' call returns the current %% `TimeToLiveSpecification'. It can take up to one hour for the change to %% fully process. Any additional `UpdateTimeToLive' calls for the same table %% during this one hour duration result in a `ValidationException'. %% %% TTL compares the current time in epoch time format to the time stored in %% the TTL attribute of an item. If the epoch time value stored in the %% attribute is less than the current time, the item is marked as expired and %% subsequently deleted. %% %% The epoch time format is the number of seconds elapsed since 12:00:00 AM %% January 1, 1970 UTC. %% %% DynamoDB deletes expired items on a best-effort basis to ensure %% availability of throughput for other data operations. %% %% DynamoDB typically deletes expired items within two days of expiration. %% The exact duration within which an item gets deleted after expiration is %% specific to the nature of the workload. Items that have expired and not %% been deleted will still show up in reads, queries, and scans. %% %% As items are deleted, they are removed from any local secondary index and %% global secondary index immediately in the same eventually consistent way %% as a standard delete operation. %% %% For more information, see Time To Live in the Amazon DynamoDB Developer %% Guide. update_time_to_live(Client, Input) when is_map(Client), is_map(Input) -> update_time_to_live(Client, Input, []). update_time_to_live(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"UpdateTimeToLive">>, Input, Options). %%==================================================================== %% Internal functions %%==================================================================== -spec request(aws_client:aws_client(), binary(), map(), list()) -> {ok, Result, {integer(), list(), hackney:client()}} | {error, Error, {integer(), list(), hackney:client()}} | {error, term()} when Result :: map() | undefined, Error :: map(). request(Client, Action, Input, Options) -> RequestFun = fun() -> do_request(Client, Action, Input, Options) end, aws_request:request(RequestFun, Options). do_request(Client, Action, Input0, Options) -> Client1 = Client#{service => <<"dynamodb">>}, Host = build_host(<<"dynamodb">>, Client1), URL = build_url(Host, Client1), Headers = [ {<<"Host">>, Host}, {<<"Content-Type">>, <<"application/x-amz-json-1.0">>}, {<<"X-Amz-Target">>, <<"DynamoDB_20120810.", Action/binary>>} ], Input = Input0, Payload = jsx:encode(Input), SignedHeaders = aws_request:sign_request(Client1, <<"POST">>, URL, Headers, Payload), Response = hackney:request(post, URL, SignedHeaders, Payload, Options), handle_response(Response). handle_response({ok, 200, ResponseHeaders, Client}) -> case hackney:body(Client) of {ok, <<>>} -> {ok, undefined, {200, ResponseHeaders, Client}}; {ok, Body} -> Result = jsx:decode(Body), {ok, Result, {200, ResponseHeaders, Client}} end; handle_response({ok, StatusCode, ResponseHeaders, Client}) -> {ok, Body} = hackney:body(Client), Error = jsx:decode(Body), {error, Error, {StatusCode, ResponseHeaders, Client}}; handle_response({error, Reason}) -> {error, Reason}. build_host(_EndpointPrefix, #{region := <<"local">>, endpoint := Endpoint}) -> Endpoint; build_host(_EndpointPrefix, #{region := <<"local">>}) -> <<"localhost">>; build_host(EndpointPrefix, #{region := Region, endpoint := Endpoint}) -> aws_util:binary_join([EndpointPrefix, Region, Endpoint], <<".">>). build_url(Host, Client) -> Proto = maps:get(proto, Client), Port = maps:get(port, Client), aws_util:binary_join([Proto, <<"://">>, Host, <<":">>, Port, <<"/">>], <<"">>).