third_party/boto/boto/dynamodb2/layer1.py - Issue 698893003: Update checked in version of gsutil to version 4.6

Unified Diff: third_party/boto/boto/dynamodb2/layer1.py

Issue 698893003: Update checked in version of gsutil to version 4.6 (Closed) Base URL: http://dart.googlecode.com/svn/third_party/gsutil/

Patch Set: Created 6 years, 1 month ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: third_party/boto/boto/dynamodb2/layer1.py

===================================================================

--- third_party/boto/boto/dynamodb2/layer1.py (revision 33376)

+++ third_party/boto/boto/dynamodb2/layer1.py (working copy)

@@ -1,4 +1,4 @@

# Permission is hereby granted, free of charge, to any person obtaining a

# copy of this software and associated documentation files (the

@@ -37,7 +37,112 @@

"""

Amazon DynamoDB **Overview**

This is the Amazon DynamoDB API Reference. This guide provides

- descriptions and samples of the Amazon DynamoDB API.

+ descriptions and samples of the low-level DynamoDB API. For

+ information about DynamoDB application development, go to the

+ `Amazon DynamoDB Developer Guide`_.

+ Instead of making the requests to the low-level DynamoDB API

+ directly from your application, we recommend that you use the AWS

+ Software Development Kits (SDKs). The easy-to-use libraries in the

+ AWS SDKs make it unnecessary to call the low-level DynamoDB API

+ directly from your application. The libraries take care of request

+ authentication, serialization, and connection management. For more

+ information, go to `Using the AWS SDKs with DynamoDB`_ in the

+ Amazon DynamoDB Developer Guide .

+ If you decide to code against the low-level DynamoDB API directly,

+ you will need to write the necessary code to authenticate your

+ requests. For more information on signing your requests, go to

+ `Using the DynamoDB API`_ in the Amazon DynamoDB Developer Guide .

+ The following are short descriptions of each low-level API action,

+ organized by function.

+ **Managing Tables**

+ + CreateTable - Creates a table with user-specified provisioned

+ throughput settings. You must designate one attribute as the hash

+ primary key for the table; you can optionally designate a second

+ attribute as the range primary key. DynamoDB creates indexes on

+ these key attributes for fast data access. Optionally, you can

+ create one or more secondary indexes, which provide fast data

+ access using non-key attributes.

+ + DescribeTable - Returns metadata for a table, such as table

+ size, status, and index information.

+ + UpdateTable - Modifies the provisioned throughput settings for a

+ table. Optionally, you can modify the provisioned throughput

+ settings for global secondary indexes on the table.

+ + ListTables - Returns a list of all tables associated with the

+ current AWS account and endpoint.

+ + DeleteTable - Deletes a table and all of its indexes.

+ For conceptual information about managing tables, go to `Working

+ with Tables`_ in the Amazon DynamoDB Developer Guide .

+ **Reading Data**

+ + GetItem - Returns a set of attributes for the item that has a

+ given primary key. By default, GetItem performs an eventually

+ consistent read; however, applications can specify a strongly

+ consistent read instead.

+ + BatchGetItem - Performs multiple GetItem requests for data items

+ using their primary keys, from one table or multiple tables. The

+ response from BatchGetItem has a size limit of 1 MB and returns a

+ maximum of 100 items. Both eventually consistent and strongly

+ consistent reads can be used.

+ + Query - Returns one or more items from a table or a secondary

+ index. You must provide a specific hash key value. You can narrow

+ the scope of the query using comparison operators against a range

+ key value, or on the index key. Query supports either eventual or

+ strong consistency. A single response has a size limit of 1 MB.

+ + Scan - Reads every item in a table; the result set is eventually

+ consistent. You can limit the number of items returned by

+ filtering the data attributes, using conditional expressions. Scan

+ can be used to enable ad-hoc querying of a table against non-key

+ attributes; however, since this is a full table scan without using

+ an index, Scan should not be used for any application query use

+ case that requires predictable performance.

+ For conceptual information about reading data, go to `Working with

+ Items`_ and `Query and Scan Operations`_ in the Amazon DynamoDB

+ Developer Guide .

+ **Modifying Data**

+ + PutItem - Creates a new item, or replaces an existing item with

+ a new item (including all the attributes). By default, if an item

+ in the table already exists with the same primary key, the new

+ item completely replaces the existing item. You can use

+ conditional operators to replace an item only if its attribute

+ values match certain conditions, or to insert a new item only if

+ that item doesn't already exist.

+ + UpdateItem - Modifies the attributes of an existing item. You

+ can also use conditional operators to perform an update only if

+ the item's attribute values match certain conditions.

+ + DeleteItem - Deletes an item in a table by primary key. You can

+ use conditional operators to perform a delete an item only if the

+ item's attribute values match certain conditions.

+ + BatchWriteItem - Performs multiple PutItem and DeleteItem

+ requests across multiple tables in a single request. A failure of

+ any request(s) in the batch will not cause the entire

+ BatchWriteItem operation to fail. Supports batches of up to 25

+ items to put or delete, with a maximum total request size of 1 MB.

+ For conceptual information about modifying data, go to `Working

+ with Items`_ and `Query and Scan Operations`_ in the Amazon

+ DynamoDB Developer Guide .

"""

APIVersion = "2012-08-10"

DefaultRegionName = "us-east-1"

@@ -91,7 +196,7 @@

items by primary key.

A single operation can retrieve up to 1 MB of data, which can

- comprise as many as 100 items. BatchGetItem will return a

+ contain as many as 100 items. BatchGetItem will return 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,

@@ -106,24 +211,38 @@

include its own logic to assemble the pages of results into

one dataset.

- If no items can be processed because of insufficient

- provisioned throughput on each of the tables involved in the

- request, BatchGetItem throws

- ProvisionedThroughputExceededException .

+ If none of the items can be processed due to insufficient

+ provisioned throughput on all of the tables in the request,

+ then BatchGetItem will throw 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, go to `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 fetches

+ In order to minimize response latency, BatchGetItem retrieves

items in parallel.

- When designing your application, keep in mind that Amazon

- DynamoDB does not return attributes in any particular order.

- To help parse the response by item, include the primary key

- values for the items in your request in the AttributesToGet

- parameter.

+ When designing your application, keep in mind that DynamoDB

+ does not return attributes in any particular order. To help

+ parse the response by item, include the primary key values for

+ the items in your request in the AttributesToGet parameter.

If a requested item does not exist, it is not returned in the

result. Requests for nonexistent items consume the minimum

@@ -141,17 +260,27 @@

+ Keys - An array of primary key attribute values that define specific

- items in the table.

+ items in the table. For each primary key, you must provide all of

+ the key attributes. For example, with a hash type primary key, you

+ only need to specify the hash attribute. For a hash-and-range type

+ primary key, you must specify both the hash attribute and the range

+ attribute.

+ AttributesToGet - One or more attributes to be retrieved from the

- table or index. By default, all attributes are returned. If a

- specified attribute is not found, it does not appear in the result.

+ table. By default, all attributes are returned. If a specified

+ attribute is not found, it does not appear in the result. Note that

+ AttributesToGet has no effect on provisioned throughput

+ consumption. DynamoDB determines capacity units consumed based on

+ item size, not on the amount of data that is returned to an

+ application.

+ ConsistentRead - If `True`, a strongly consistent read is used; if

`False` (the default), an eventually consistent read is used.

:type return_consumed_capacity: string

- :param return_consumed_capacity: If set to `TOTAL`, ConsumedCapacity is

- included in the response; if set to `NONE` (the default),

- ConsumedCapacity is not included.

+ :param return_consumed_capacity: If set to `TOTAL`, the response

+ includes ConsumedCapacity data for tables and indexes. If set to

+ `INDEXES`, the response includes ConsumedCapacity for indexes. If

+ set to `NONE` (the default), ConsumedCapacity is not included in

+ the response.

"""

params = {'RequestItems': request_items, }

@@ -183,27 +312,39 @@

unprocessed items and submit a new BatchWriteItem request with

those unprocessed items until all items have been processed.

- To write one item, you can use the PutItem operation; to

- delete one item, you can use the DeleteItem operation.

+ Note that if none of the items can be processed due to

+ insufficient provisioned throughput on all of the tables in

+ the request, then BatchGetItem will throw 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, go to `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 Elastic MapReduce

- (EMR), or copy data from another database into Amazon

- 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.

+ (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,

such as Java, 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, such as PHP,

- BatchWriteItem will write or delete the specified items one at

- a time. In both situations, BatchWriteItem provides an

+ the threads. With languages that don't support threading, such

+ as PHP, you must update or delete the specified items one at a

+ time. In both situations, BatchWriteItem provides an

alternative where the API performs the specified put and

delete operations in parallel, giving you the power of the

thread pool approach without having to introduce complexity

@@ -215,8 +356,8 @@

operations on nonexistent items consume one write capacity

unit.

- If one or more of the following is true, Amazon DynamoDB

- rejects the entire batch write operation:

+ If one or more of the following is true, DynamoDB rejects the

+ entire batch write operation:

+ One or more tables specified in the BatchWriteItem request

@@ -241,8 +382,12 @@

The item to be deleted is identified by a Key subelement:

+ Key - A map of primary key attribute values that uniquely identify

- the item. Each entry in this map consists of an attribute name and

- an attribute value.

+ the ! item. Each entry in this map consists of an attribute name

+ and an attribute value. For each primary key, you must provide all

+ of the key attributes. For example, with a hash type primary key,

+ you only need to specify the hash attribute. For a hash-and-range

+ type primary key, you must specify both the hash attribute and the

+ range attribute.

+ PutRequest - Perform a PutItem operation on the specified item. The

item to be put is identified by an Item subelement:

@@ -257,15 +402,17 @@

match those of the schema in the table's attribute definition.

:type return_consumed_capacity: string

- :param return_consumed_capacity: If set to `TOTAL`, ConsumedCapacity is

- included in the response; if set to `NONE` (the default),

- ConsumedCapacity is not included.

+ :param return_consumed_capacity: If set to `TOTAL`, the response

+ includes ConsumedCapacity data for tables and indexes. If set to

+ `INDEXES`, the response includes ConsumedCapacity for indexes. If

+ set to `NONE` (the default), ConsumedCapacity is not included in

+ the response.

:type return_item_collection_metrics: string

:param return_item_collection_metrics: If set to `SIZE`, statistics

about item collections, if any, that were modified during the

operation are returned in the response. If set to `NONE` (the

- default), no statistics are returned..

+ default), no statistics are returned.

"""

params = {'RequestItems': request_items, }

@@ -286,16 +433,15 @@

the tables in different regions.

CreateTable is an asynchronous operation. Upon receiving a

- CreateTable request, Amazon DynamoDB immediately returns a

- response with a TableStatus of `CREATING`. After the table is

- created, Amazon DynamoDB sets the TableStatus to `ACTIVE`. You

- can perform read and write operations only on an `ACTIVE`

- table.

+ 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.

- If you want to create multiple tables with local secondary

- indexes on them, you must create them sequentially. Only one

- table with local secondary indexes can be in the `CREATING`

- state at any given time.

+ If you want to create multiple tables with secondary indexes

+ on them, you must create them sequentially. Only one table

+ with secondary indexes can be in the `CREATING` state at any

+ given time.

You can use the DescribeTable API to check the table status.

@@ -308,9 +454,9 @@

:type key_schema: list

:param key_schema: Specifies the attributes that make up the primary

- key for the table. The attributes in KeySchema must also be defined

- in the AttributeDefinitions array. For more information, see `Data

- Model`_ in the Amazon DynamoDB Developer Guide.

+ key for a table or an index. The attributes in KeySchema must also

+ be defined in the AttributeDefinitions array. For more information,

+ see `Data Model`_ in the Amazon DynamoDB Developer Guide.

Each KeySchemaElement in the array is composed of:

@@ -331,18 +477,19 @@

:type local_secondary_indexes: list

:param local_secondary_indexes:

- One or more secondary indexes (the maximum is five) to be created on

- the table. Each index is scoped to a given hash key value. There is

- a 10 gigabyte size limit per hash key; otherwise, the size of a

- local secondary index is unconstrained.

+ One or more local secondary indexes (the maximum is five) to be created

+ on the table. Each index is scoped to a given hash key value. There

+ is a 10 GB size limit per hash key; otherwise, the size of a local

+ secondary index is unconstrained.

- Each secondary index in the array includes the following:

+ Each local secondary index in the array includes the following:

- + IndexName - The name of the secondary index. Must be unique only for

- this table.

- + KeySchema - Specifies the key schema for the index. The key schema

- must begin with the same hash key attribute as the table.

+ + IndexName - The name of the local secondary index. Must be unique

+ only for this table.

+ + KeySchema - Specifies the key schema for the local secondary index.

+ The key schema must begin with the same hash key attribute as the

+ table.

+ Projection - Specifies attributes that are copied (projected) from

the table into the index. These are in addition to the primary key

attributes and index key attributes, which are automatically

@@ -358,19 +505,51 @@

+ `ALL` - All of the table attributes are projected into the index.

+ NonKeyAttributes - A list of one or more non-key attribute names that

- are projected into the index. The total count of attributes

- specified in NonKeyAttributes , summed across all of the local

+ are projected into the secondary index. The total count of

+ attributes specified in NonKeyAttributes , summed across all of the

secondary indexes, must not exceed 20. If you project the same

attribute into two different indexes, this counts as two distinct

attributes when determining the total.

:type global_secondary_indexes: list

:param global_secondary_indexes:

+ One or more global secondary indexes (the maximum is five) to be

+ created on the table. Each global secondary index in the array

+ includes the following:

+ + IndexName - The name of the global secondary index. Must be unique

+ only for this table.

+ + KeySchema - Specifies the key schema for the global secondary index.

+ + Projection - Specifies attributes that are copied (projected) from

+ the table into the index. These are in addition to the primary key

+ attributes and index key attributes, which are automatically

+ projected. Each attribute specification is composed of:

+ + ProjectionType - One of the following:

+ + `KEYS_ONLY` - Only the index and primary keys are projected into the

+ index.

+ + `INCLUDE` - Only the specified table attributes are projected into

+ the index. The list of projected attributes are in NonKeyAttributes

+ .

+ + `ALL` - All of the table attributes are projected into the index.

+ + NonKeyAttributes - A list of one or more non-key attribute names that

+ are projected into the secondary index. The total count of

+ attributes specified in NonKeyAttributes , summed across all of the

+ secondary indexes, must not exceed 20. If you project the same

+ attribute into two different indexes, this counts as two distinct

+ attributes when determining the total.

+ + ProvisionedThroughput - The provisioned throughput settings for the

+ global secondary index, consisting of read and write capacity

+ units.

:type provisioned_throughput: dict

- :param provisioned_throughput: The provisioned throughput settings for

- the specified table. The settings can be modified using the

- UpdateTable operation.

+ :param provisioned_throughput: Represents the provisioned throughput

+ settings for a specified table or index. The settings can be

+ modified using the UpdateTable operation.

For current minimum and maximum provisioned throughput values, see

`Limits`_ in the Amazon DynamoDB Developer Guide.

@@ -388,7 +567,8 @@

return self.make_request(action='CreateTable',

body=json.dumps(params))

- def delete_item(self, table_name, key, expected=None, return_values=None,

+ def delete_item(self, table_name, key, expected=None,

+ conditional_operator=None, return_values=None,

return_consumed_capacity=None,

return_item_collection_metrics=None):

"""

@@ -406,8 +586,8 @@

Conditional deletes are useful for only deleting items if

specific conditions are met. If those conditions are met,

- Amazon DynamoDB performs the delete. Otherwise, the item is

- not deleted.

+ DynamoDB performs the delete. Otherwise, the item is not

+ deleted.

:type table_name: string

:param table_name: The name of the table from which to delete the item.

@@ -415,51 +595,182 @@

:type key: map

:param key: A map of attribute names to AttributeValue objects,

representing the primary key of the item to delete.

+ For the primary key, you must provide all of the attributes. For

+ example, with a hash type primary key, you only need to specify the

+ hash attribute. For a hash-and-range type primary key, you must

+ specify both the hash attribute and the range attribute.

:type expected: map

- :param expected: A map of attribute/condition pairs. This is the

- conditional block for the DeleteItem operation. All the conditions

- must be met for the operation to succeed.

- Expected allows you to provide an attribute name, and whether or not

- Amazon DynamoDB should check to see if the attribute value already

- exists; or if the attribute value exists and has a particular value

- before changing it.

+ :param expected:

+ A map of attribute/condition pairs. This is the conditional block for

+ the DeleteItem operation.

- Each item in Expected represents an attribute name for Amazon DynamoDB

- to check, along with the following:

+ Each element of Expected consists of an attribute name, a comparison

+ operator, and one or more values. DynamoDB compares the attribute

+ with the value(s) you supplied, using the comparison operator. For

+ each Expected element, the result of the evaluation is either true

+ or false.

+ If you specify more than one element in the Expected map, then by

+ default all of the conditions must evaluate to true. In other

+ words, the conditions are ANDed together. (You can use the

+ ConditionalOperator parameter to OR the conditions instead. If you

+ do this, then at least one of the conditions must evaluate to true,

+ rather than all of them.)

- + Value - The attribute value for Amazon DynamoDB to check.

- + Exists - Causes Amazon DynamoDB to evaluate the value before

- attempting a conditional operation:

+ If the Expected map evaluates to true, then the conditional operation

+ succeeds; otherwise, it fails.

- + If Exists is `True`, Amazon DynamoDB will check to see if that

- attribute value already exists in the table. If it is found, then

- the operation succeeds. If it is not found, the operation fails

- with a ConditionalCheckFailedException .

- + If Exists is `False`, Amazon DynamoDB assumes that the attribute

- value does not exist in the table. If in fact the value does not

- exist, then the assumption is valid and the operation succeeds. If

- the value is found, despite the assumption that it does not exist,

- the operation fails with a ConditionalCheckFailedException .

- The default setting for Exists is `True`. If you supply a Value all by

- itself, Amazon DynamoDB assumes the attribute exists: You don't

- have to set Exists to `True`, because it is implied. Amazon

- DynamoDB returns a ValidationException if:

+ Each item in Expected represents an attribute name for DynamoDB to

+ check, along with an AttributeValueList and a ComparisonOperator :

- + Exists is `True` but there is no Value to check. (You expect a value

- to exist, but don't specify what that value is.)

- + Exists is `False` but you also specify a Value . (You cannot expect

- an attribute to have a value, while also expecting it not to

- exist.)

+ + AttributeValueList - One or more values to evaluate against the

+ supplied attribute. The number of values in the list depends on the

+ ComparisonOperator being used. For type Number, value comparisons

+ are numeric. String value comparisons for greater than, equals, or

+ less than are based on ASCII character code values. For example,

+ `a` is greater than `A`, and `aa` is greater than `B`. For a list

+ of code values, see

+ `http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters`_.

+ For Binary, DynamoDB treats each byte of the binary data as

+ unsigned when it compares binary values, for example when

+ evaluating query expressions.

+ + ComparisonOperator - A comparator for evaluating attributes in the

+ AttributeValueList . When performing the comparison, DynamoDB uses

+ strongly consistent reads. The following comparison operators are

+ available: `EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL |

+ CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN` The following

+ are descriptions of each comparison operator.

+ + `EQ` : Equal. AttributeValueList can contain only one AttributeValue

+ of type String, Number, Binary, String Set, Number Set, or Binary

+ Set. If an item contains an AttributeValue of a different type than

+ the one specified in the request, the value does not match. For

+ example, `{"S":"6"}` does not equal `{"N":"6"}`. Also, `{"N":"6"}`

+ does not equal `{"NS":["6", "2", "1"]}`. > <li>

+ + `NE` : Not equal. AttributeValueList can contain only one

+ AttributeValue of type String, Number, Binary, String Set, Number

+ Set, or Binary Set. If an item contains an AttributeValue of a

+ different type than the one specified in the request, the value

+ does not match. For example, `{"S":"6"}` does not equal

+ `{"N":"6"}`. Also, `{"N":"6"}` does not equal `{"NS":["6", "2",

+ "1"]}`. > <li>

+ + `LE` : Less than or equal. AttributeValueList can contain only one

+ AttributeValue of type String, Number, or Binary (not a set). If an

+ item contains an AttributeValue of a different type than the one

+ specified in the request, the value does not match. For example,

+ `{"S":"6"}` does not equal `{"N":"6"}`. Also, `{"N":"6"}` does not

+ compare to `{"NS":["6", "2", "1"]}`. > <li>

+ + `LT` : Less than. AttributeValueList can contain only one

+ AttributeValue of type String, Number, or Binary (not a set). If an

+ item contains an AttributeValue of a different type than the one

+ specified in the request, the value does not match. For example,

+ `{"S":"6"}` does not equal `{"N":"6"}`. Also, `{"N":"6"}` does not

+ compare to `{"NS":["6", "2", "1"]}`. > <li>

+ + `GE` : Greater than or equal. AttributeValueList can contain only one

+ AttributeValue of type String, Number, or Binary (not a set). If an

+ item contains an AttributeValue of a different type than the one

+ specified in the request, the value does not match. For example,

+ `{"S":"6"}` does not equal `{"N":"6"}`. Also, `{"N":"6"}` does not

+ compare to `{"NS":["6", "2", "1"]}`. > <li>

+ + `GT` : Greater than. AttributeValueList can contain only one

+ AttributeValue of type String, Number, or Binary (not a set). If an

+ item contains an AttributeValue of a different type than the one

+ specified in the request, the value does not match. For example,

+ `{"S":"6"}` does not equal `{"N":"6"}`. Also, `{"N":"6"}` does not

+ compare to `{"NS":["6", "2", "1"]}`. > <li>

+ + `NOT_NULL` : The attribute exists.

+ + `NULL` : The attribute does not exist.

+ + `CONTAINS` : checks for a subsequence, or value in a set.

+ AttributeValueList can contain only one AttributeValue of type

+ String, Number, or Binary (not a set). If the target attribute of

+ the comparison is a String, then the operation checks for a

+ substring match. If the target attribute of the comparison is

+ Binary, then the operation looks for a subsequence of the target

+ that matches the input. If the target attribute of the comparison

+ is a set ("SS", "NS", or "BS"), then the operation checks for a

+ member of the set (not as a substring).

+ + `NOT_CONTAINS` : checks for absence of a subsequence, or absence of a

+ value in a set. AttributeValueList can contain only one

+ AttributeValue of type String, Number, or Binary (not a set). If

+ the target attribute of the comparison is a String, then the

+ operation checks for the absence of a substring match. If the

+ target attribute of the comparison is Binary, then the operation

+ checks for the absence of a subsequence of the target that matches

+ the input. If the target attribute of the comparison is a set

+ ("SS", "NS", or "BS"), then the operation checks for the absence of

+ a member of the set (not as a substring).

+ + `BEGINS_WITH` : checks for a prefix. AttributeValueList can contain

+ only one AttributeValue of type String or Binary (not a Number or a

+ set). The target attribute of the comparison must be a String or

+ Binary (not a Number or a set). > <li>

+ + `IN` : checks for exact matches. AttributeValueList can contain more

+ than one AttributeValue of type String, Number, or Binary (not a

+ set). The target attribute of the comparison must be of the same

+ type and exact value to match. A String never matches a String set.

+ + `BETWEEN` : Greater than or equal to the first value, and less than

+ or equal to the second value. AttributeValueList must contain two

+ AttributeValue elements of the same type, either String, Number, or

+ Binary (not a set). A target attribute matches if the target value

+ is greater than, or equal to, the first element and less than, or

+ equal to, the second element. If an item contains an AttributeValue

+ of a different type than the one specified in the request, the

+ value does not match. For example, `{"S":"6"}` does not compare to

+ `{"N":"6"}`. Also, `{"N":"6"}` does not compare to `{"NS":["6",

+ "2", "1"]}`

- If you specify more than one condition for Exists , then all of the

- conditions must evaluate to true. (In other words, the conditions

- are ANDed together.) Otherwise, the conditional operation will

- fail.

+ For usage examples of AttributeValueList and ComparisonOperator , see

+ `Conditional Expressions`_ in the Amazon DynamoDB Developer Guide.

+ For backward compatibility with previous DynamoDB releases, the

+ following parameters can be used instead of AttributeValueList and

+ ComparisonOperator :

+ + Value - A value for DynamoDB to compare with an attribute.

+ + Exists - Causes DynamoDB to evaluate the value before attempting the

+ conditional operation:

+ + If Exists is `True`, DynamoDB will check to see if that attribute

+ value already exists in the table. If it is found, then the

+ condition evaluates to true; otherwise the condition evaluate to

+ false.

+ + If Exists is `False`, DynamoDB assumes that the attribute value does

+ not exist in the table. If in fact the value does not exist, then

+ the assumption is valid and the condition evaluates to true. If the

+ value is found, despite the assumption that it does not exist, the

+ condition evaluates to false.

+ Even though DynamoDB continues to accept the Value and Exists

+ parameters, they are now deprecated. We recommend that you use

+ AttributeValueList and ComparisonOperator instead, since they allow

+ you to construct a much wider range of conditions.

+ The Value and Exists parameters are incompatible with

+ AttributeValueList and ComparisonOperator . If you attempt to use

+ both sets of parameters at once, DynamoDB will throw a

+ ValidationException .

+ :type conditional_operator: string

+ :param conditional_operator: A logical operator to apply to the

+ conditions in the Expected map:

+ + `AND` - If all of the conditions evaluate to true, then the entire

+ map evaluates to true.

+ + `OR` - If at least one of the conditions evaluate to true, then the

+ entire map evaluates to true.

+ If you omit ConditionalOperator , then `AND` is the default.

+ The operation will succeed only if the entire map evaluates to true.

:type return_values: string

:param return_values:

Use ReturnValues if you want to get the item attributes as they

@@ -472,20 +783,24 @@

+ `ALL_OLD` - The content of the old item is returned.

:type return_consumed_capacity: string

- :param return_consumed_capacity: If set to `TOTAL`, ConsumedCapacity is

- included in the response; if set to `NONE` (the default),

- ConsumedCapacity is not included.

+ :param return_consumed_capacity: If set to `TOTAL`, the response

+ includes ConsumedCapacity data for tables and indexes. If set to

+ `INDEXES`, the response includes ConsumedCapacity for indexes. If

+ set to `NONE` (the default), ConsumedCapacity is not included in

+ the response.

:type return_item_collection_metrics: string

:param return_item_collection_metrics: If set to `SIZE`, statistics

about item collections, if any, that were modified during the

operation are returned in the response. If set to `NONE` (the

- default), no statistics are returned..

+ default), no statistics are returned.

"""

params = {'TableName': table_name, 'Key': key, }

if expected is not None:

params['Expected'] = expected

+ if conditional_operator is not None:

+ params['ConditionalOperator'] = conditional_operator

if return_values is not None:

params['ReturnValues'] = return_values

if return_consumed_capacity is not None:

@@ -499,20 +814,20 @@

"""

The DeleteTable operation deletes a table and all of its

items. After a DeleteTable request, the specified table is in

- the `DELETING` state until Amazon 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 Amazon DynamoDB returns a ResourceInUseException . If the

- specified table does not exist, Amazon DynamoDB returns a

- ResourceNotFoundException . If table is already in the

- `DELETING` state, no error is returned.

+ 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.

- Amazon DynamoDB might continue to accept data read and write

+ 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 local secondary indexes on that

- table are also deleted.

+ When you delete a table, any indexes on that table are also

+ deleted.

Use the DescribeTable API to check the status of the table.

@@ -557,12 +872,20 @@

:type key: map

:param key: A map of attribute names to AttributeValue objects,

representing the primary key of the item to retrieve.

+ For the primary key, you must provide all of the attributes. For

+ example, with a hash type primary key, you only need to specify the

+ hash attribute. For a hash-and-range type primary key, you must

+ specify both the hash attribute and the range attribute.

:type attributes_to_get: list

:param attributes_to_get: The names of one or more attributes to

retrieve. If no attribute names are specified, then all attributes

will be returned. If any of the requested attributes are not found,

they will not appear in the result.

+ Note that AttributesToGet has no effect on provisioned throughput

+ consumption. DynamoDB determines capacity units consumed based on

+ item size, not on the amount of data that is returned to an

+ application.

:type consistent_read: boolean

:param consistent_read: If set to `True`, then the operation uses

@@ -570,9 +893,11 @@

are used.

:type return_consumed_capacity: string

- :param return_consumed_capacity: If set to `TOTAL`, ConsumedCapacity is

- included in the response; if set to `NONE` (the default),

- ConsumedCapacity is not included.

+ :param return_consumed_capacity: If set to `TOTAL`, the response

+ includes ConsumedCapacity data for tables and indexes. If set to

+ `INDEXES`, the response includes ConsumedCapacity for indexes. If

+ set to `NONE` (the default), ConsumedCapacity is not included in

+ the response.

"""

params = {'TableName': table_name, 'Key': key, }

@@ -587,17 +912,19 @@

def list_tables(self, exclusive_start_table_name=None, limit=None):

"""

- Returns an array of all the tables associated with the current

- account and endpoint.

+ 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.

:type exclusive_start_table_name: string

- :param exclusive_start_table_name: The name of the table that starts

- the list. If you already ran a ListTables operation and received a

- LastEvaluatedTableName value in the response, use that value here

- to continue the list.

+ :param exclusive_start_table_name: The first table name that this

+ operation will evaluate. Use the value that was returned for

+ LastEvaluatedTableName in a previous operation, so that you can

+ obtain the next page of results.

:type limit: integer

- :param limit: A maximum number of table names to return.

+ :param limit: A maximum number of table names to return. If this

+ parameter is not specified, the limit is 100.

"""

params = {}

@@ -610,7 +937,8 @@

def put_item(self, table_name, item, expected=None, return_values=None,

return_consumed_capacity=None,

- return_item_collection_metrics=None):

+ return_item_collection_metrics=None,

+ conditional_operator=None):

"""

Creates a new item, or replaces an old item with a new item.

If an item already exists in the specified table with the same

@@ -635,8 +963,8 @@

description.

To prevent a new item from replacing an existing item, use a

- conditional put operation with Exists set to `False` for the

- primary key attribute, or attributes.

+ conditional put operation with ComparisonOperator set to

+ `NULL` for the primary key attribute, or attributes.

For more information about using this API, see `Working with

Items`_ in the Amazon DynamoDB Developer Guide.

@@ -648,6 +976,11 @@

:param item: A map of attribute name/value pairs, one for each

attribute. Only the primary key attributes are required; you can

optionally provide other attribute name-value pairs for the item.

+ You must provide all of the attributes for the primary key. For

+ example, with a hash type primary key, you only need to specify the

+ hash attribute. For a hash-and-range type primary key, you must

+ specify both the hash attribute and the range attribute.

If you specify any attributes that are part of an index key, then the

data types for those attributes must match those of the schema in

the table's attribute definition.

@@ -658,49 +991,162 @@

Each element in the Item map is an AttributeValue object.

:type expected: map

- :param expected: A map of attribute/condition pairs. This is the

- conditional block for the PutItem operation. All the conditions

- must be met for the operation to succeed.

- Expected allows you to provide an attribute name, and whether or not

- Amazon DynamoDB should check to see if the attribute value already

- exists; or if the attribute value exists and has a particular value

- before changing it.

+ :param expected:

+ A map of attribute/condition pairs. This is the conditional block for

+ the PutItem operation.