/usr/lib/python2.6/site-packages/boto/dynamodb2
Edit: /usr/lib/python2.6/site-packages/boto/dynamodb2/layer1.pyc (136163B)
̓5Tc
@ s d d k l Z d d k Z d d k l Z d d k l Z d d k l Z d d k l
Z
d d k l Z d e f d YZ
d S(
i( t crc32N( t json( t AWSQueryConnection( t
RegionInfo( t JSONResponseError( t
exceptionst DynamoDBConnectionc B s e Z d Z d Z d Z d Z d Z d Z e Z h e
i d 6e
i d 6e
i
d 6e
i d 6e
i d
6e
i d 6e
i d 6Z d
Z d Z d Z e d Z e e d Z e e d Z e e e e e e e e d Z d Z d Z e e e e e d Z e e d Z e e e e e e e e d Z e e e e e e e e e e e e e e d Z e e e e e e e e e e e e e d
Z! e e e e e e e e e e d
Z" e e d Z# d Z$ d Z% d Z& RS( s`
Amazon DynamoDB **Overview**
This is the Amazon DynamoDB API Reference. This guide provides
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 16 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 16
MB.
For conceptual information about modifying data, go to `Working
with Items`_ and `Query and Scan Operations`_ in the Amazon
DynamoDB Developer Guide .
s
2012-08-10s us-east-1s dynamodb.us-east-1.amazonaws.comt DynamoDBt DynamoDB_20120810t& ProvisionedThroughputExceededExceptiont LimitExceededExceptiont ConditionalCheckFailedExceptiont ResourceInUseExceptiont ResourceNotFoundExceptiont InternalServerErrort( ItemCollectionSizeLimitExceededExceptioni
c K s | i d d } | i d t } | pT t i i d d | i } x6 t i i D]! } | i | j o | } PqV qV Wn d | j o | i
| d
+ `NE` : Not equal. `NE` is supported for all datatypes, including
lists and maps. 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"]}`. >
+ `LE` : Less than or equal. AttributeValueList can contain only one
AttributeValue element of type String, Number, or Binary (not a set
type). If an item contains an AttributeValue element 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"]}`. >
+ `LT` : Less than. AttributeValueList can contain only one
AttributeValue of type String, Number, or Binary (not a set type).
If an item contains an AttributeValue element 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"]}`. >
+ `GE` : Greater than or equal. AttributeValueList can contain only one
AttributeValue element of type String, Number, or Binary (not a set
type). If an item contains an AttributeValue element 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"]}`. >
+ `GT` : Greater than. AttributeValueList can contain only one
AttributeValue element of type String, Number, or Binary (not a set
type). If an item contains an AttributeValue element 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"]}`. >
+ `NOT_NULL` : The attribute exists. `NOT_NULL` is supported for all
datatypes, including lists and maps.
+ `NULL` : The attribute does not exist. `NULL` is supported for all
datatypes, including lists and maps.
+ `CONTAINS` : Checks for a subsequence, or value in a set.
AttributeValueList can contain only one AttributeValue element of
type String, Number, or Binary (not a set type). If the target
attribute of the comparison is of type String, then the operator
checks for a substring match. If the target attribute of the
comparison is of type Binary, then the operator 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 operator evaluates to true if it finds an exact
match with any member of the set. CONTAINS is supported for lists:
When evaluating " `a CONTAINS b`", " `a`" can be a list; however, "
`b`" cannot be a set, a map, or a list.
+ `NOT_CONTAINS` : Checks for absence of a subsequence, or absence of a
value in a set. AttributeValueList can contain only one
AttributeValue element of type String, Number, or Binary (not a set
type). If the target attribute of the comparison is a String, then
the operator checks for the absence of a substring match. If the
target attribute of the comparison is Binary, then the operator
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 operator evaluates to true if
it does not find an exact match with any member of the set.
NOT_CONTAINS is supported for lists: When evaluating " `a NOT
CONTAINS b`", " `a`" can be a list; however, " `b`" cannot be a
set, a map, or a list.
+ `BEGINS_WITH` : Checks for a prefix. AttributeValueList can contain
only one AttributeValue of type String or Binary (not a Number or a
set type). The target attribute of the comparison must be of type
String or Binary (not a Number or a set type). >
+ `IN` : Checks for matching elements within two sets.
AttributeValueList can contain one or more AttributeValue elements
of type String, Number, or Binary (not a set type). These
attributes are compared against an existing set type attribute of
an item. If any elements of the input set are present in the item
attribute, the expression evaluates to true.
+ `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 type). 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 element 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"]}`
For usage examples of AttributeValueList and ComparisonOperator , see
`Legacy Conditional Parameters`_ 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 - A Boolean value that 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.
The Value and Exists parameters are incompatible with
AttributeValueList and ComparisonOperator . Note that if you use
both sets of parameters at once, DynamoDB will return a
ValidationException exception.
:type conditional_operator: string
:param conditional_operator:
There is a newer parameter available. Use ConditionExpression instead.
Note that if you use ConditionalOperator and ConditionExpression at
the same time, DynamoDB will return a ValidationException
exception.
This parameter does not support lists or maps.
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
appeared before they were deleted. For DeleteItem , the valid
values are:
+ `NONE` - If ReturnValues is not specified, or if its value is `NONE`,
then nothing is returned. (This setting is the default for
ReturnValues .)
+ `ALL_OLD` - The content of the old item is returned.
:type return_consumed_capacity: string
:param return_consumed_capacity: A value that 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: A value that if set to `SIZE`,
the response includes 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.
:type condition_expression: string
:param condition_expression:
A condition that must be satisfied in order for a conditional
DeleteItem to succeed.
An expression can contain any of the following:
+ Boolean functions: `ATTRIBUTE_EXIST | CONTAINS | BEGINS_WITH`
+ Comparison operators: ` = | <> | < | > | <=
| >= | BETWEEN | IN`
+ Logical operators: `NOT | AND | OR`
:type expression_attribute_names: map
:param expression_attribute_names:
One or more substitution tokens for simplifying complex expressions.
The following are some use cases for an ExpressionAttributeNames
value:
+ To shorten an attribute name that is very long or unwieldy in an
expression.
+ To create a placeholder for repeating occurrences of an attribute
name in an expression.
+ To prevent special characters in an attribute name from being
misinterpreted in an expression.
Use the **#** character in an expression to dereference an attribute
name. For example, consider the following expression:
+ `order.customerInfo.LastName = "Smith" OR order.customerInfo.LastName
= "Jones"`
Now suppose that you specified the following for
ExpressionAttributeNames :
+ `{"n":"order.customerInfo.LastName"}`
The expression can now be simplified as follows:
+ `#n = "Smith" OR #n = "Jones"`
:type expression_attribute_values: map
:param expression_attribute_values:
One or more values that can be substituted in an expression.
Use the **:** character in an expression to dereference an attribute
value. For example, consider the following expression:
+ `ProductStatus IN ("Available","Backordered","Discontinued")`
Now suppose that you specified the following for
ExpressionAttributeValues :
+ `{ "a":{"S":"Available"}, "b":{"S":"Backordered"},
"d":{"S":"Discontinued"} }`
The expression can now be simplified as follows:
+ `ProductStatus IN (:a,:b,:c)`
R8 t Keyt Expectedt ConditionalOperatort ReturnValuesR) R3 t ConditionExpressiont ExpressionAttributeNamest ExpressionAttributeValuesR* t
DeleteItemR, ( R R- R R. ( R# R? t keyt expectedt conditional_operatort
return_valuesR0 R5 t condition_expressiont expression_attribute_namest expression_attribute_valuesR1 ( ( s9 /usr/lib/python2.6/site-packages/boto/dynamodb2/layer1.pyt delete_item5 s( H
c C s, h | d 6} | i d d d t i | S( s4
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.
When you delete a table, any indexes on that table are also
deleted.
Use the DescribeTable API to check the status of the table.
:type table_name: string
:param table_name: The name of the table to delete.
R8 R* t DeleteTableR, ( R- R R. ( R# R? R1 ( ( s9 /usr/lib/python2.6/site-packages/boto/dynamodb2/layer1.pyt delete_table s
c C s, h | d 6} | i d d d t i | S( s
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.
:type table_name: string
:param table_name: The name of the table to describe.
R8 R* t
DescribeTableR, ( R- R R. ( R# R? R1 ( ( s9 /usr/lib/python2.6/site-packages/boto/dynamodb2/layer1.pyt describe_table s
c C s h | d 6| d 6} | d j o | | d
+ `NE` : Not equal. `NE` is supported for all datatypes, including
lists and maps. 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"]}`. >
+ `LE` : Less than or equal. AttributeValueList can contain only one
AttributeValue element of type String, Number, or Binary (not a set
type). If an item contains an AttributeValue element 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"]}`. >
+ `LT` : Less than. AttributeValueList can contain only one
AttributeValue of type String, Number, or Binary (not a set type).
If an item contains an AttributeValue element 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"]}`. >
+ `GE` : Greater than or equal. AttributeValueList can contain only one
AttributeValue element of type String, Number, or Binary (not a set
type). If an item contains an AttributeValue element 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"]}`. >
+ `GT` : Greater than. AttributeValueList can contain only one
AttributeValue element of type String, Number, or Binary (not a set
type). If an item contains an AttributeValue element 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"]}`. >
+ `NOT_NULL` : The attribute exists. `NOT_NULL` is supported for all
datatypes, including lists and maps.
+ `NULL` : The attribute does not exist. `NULL` is supported for all
datatypes, including lists and maps.
+ `CONTAINS` : Checks for a subsequence, or value in a set.
AttributeValueList can contain only one AttributeValue element of
type String, Number, or Binary (not a set type). If the target
attribute of the comparison is of type String, then the operator
checks for a substring match. If the target attribute of the
comparison is of type Binary, then the operator 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 operator evaluates to true if it finds an exact
match with any member of the set. CONTAINS is supported for lists:
When evaluating " `a CONTAINS b`", " `a`" can be a list; however, "
`b`" cannot be a set, a map, or a list.
+ `NOT_CONTAINS` : Checks for absence of a subsequence, or absence of a
value in a set. AttributeValueList can contain only one
AttributeValue element of type String, Number, or Binary (not a set
type). If the target attribute of the comparison is a String, then
the operator checks for the absence of a substring match. If the
target attribute of the comparison is Binary, then the operator
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 operator evaluates to true if
it does not find an exact match with any member of the set.
NOT_CONTAINS is supported for lists: When evaluating " `a NOT
CONTAINS b`", " `a`" can be a list; however, " `b`" cannot be a
set, a map, or a list.
+ `BEGINS_WITH` : Checks for a prefix. AttributeValueList can contain
only one AttributeValue of type String or Binary (not a Number or a
set type). The target attribute of the comparison must be of type
String or Binary (not a Number or a set type). >
+ `IN` : Checks for matching elements within two sets.
AttributeValueList can contain one or more AttributeValue elements
of type String, Number, or Binary (not a set type). These
attributes are compared against an existing set type attribute of
an item. If any elements of the input set are present in the item
attribute, the expression evaluates to true.
+ `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 type). 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 element 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"]}`
For usage examples of AttributeValueList and ComparisonOperator , see
`Legacy Conditional Parameters`_ 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 - A Boolean value that 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.
The Value and Exists parameters are incompatible with
AttributeValueList and ComparisonOperator . Note that if you use
both sets of parameters at once, DynamoDB will return a
ValidationException exception.
:type return_values: string
:param return_values:
Use ReturnValues if you want to get the item attributes as they
appeared before they were updated with the PutItem request. For
PutItem , the valid values are:
+ `NONE` - If ReturnValues is not specified, or if its value is `NONE`,
then nothing is returned. (This setting is the default for
ReturnValues .)
+ `ALL_OLD` - If PutItem overwrote an attribute name-value pair, then
the content of the old item is returned.
:type return_consumed_capacity: string
:param return_consumed_capacity: A value that 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: A value that if set to `SIZE`,
the response includes 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.
:type conditional_operator: string
:param conditional_operator:
There is a newer parameter available. Use ConditionExpression instead.
Note that if you use ConditionalOperator and ConditionExpression at
the same time, DynamoDB will return a ValidationException
exception.
This parameter does not support lists or maps.
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 condition_expression: string
:param condition_expression:
A condition that must be satisfied in order for a conditional PutItem
operation to succeed.
An expression can contain any of the following:
+ Boolean functions: `ATTRIBUTE_EXIST | CONTAINS | BEGINS_WITH`
+ Comparison operators: ` = | <> | < | > | <=
| >= | BETWEEN | IN`
+ Logical operators: `NOT | AND | OR`
:type expression_attribute_names: map
:param expression_attribute_names:
One or more substitution tokens for simplifying complex expressions.
The following are some use cases for an ExpressionAttributeNames
value:
+ To shorten an attribute name that is very long or unwieldy in an
expression.
+ To create a placeholder for repeating occurrences of an attribute
name in an expression.
+ To prevent special characters in an attribute name from being
misinterpreted in an expression.
Use the **#** character in an expression to dereference an attribute
name. For example, consider the following expression:
+ `order.customerInfo.LastName = "Smith" OR order.customerInfo.LastName
= "Jones"`
Now suppose that you specified the following for
ExpressionAttributeNames :
+ `{"n":"order.customerInfo.LastName"}`
The expression can now be simplified as follows:
+ `#n = "Smith" OR #n = "Jones"`
:type expression_attribute_values: map
:param expression_attribute_values:
One or more values that can be substituted in an expression.
Use the **:** character in an expression to dereference an attribute
value. For example, consider the following expression:
+ `ProductStatus IN ("Available","Backordered","Discontinued")`
Now suppose that you specified the following for
ExpressionAttributeValues :
+ `{ "a":{"S":"Available"}, "b":{"S":"Backordered"},
"d":{"S":"Discontinued"} }`
The expression can now be simplified as follows:
+ `ProductStatus IN (:a,:b,:c)`
R8 t ItemRF RH R) R3 RG RI RJ RK R* t PutItemR, ( R R- R R. ( R# R? t itemRN RP R0 R5 RO RQ RR RS R1 ( ( s9 /usr/lib/python2.6/site-packages/boto/dynamodb2/layer1.pyt put_itemD s( \
c C s h | d 6| d 6} | t j o | | d
+ `LT` : Less than. AttributeValueList can contain only one
AttributeValue of type String, Number, or Binary (not a set type).
If an item contains an AttributeValue element 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"]}`. >
+ `GE` : Greater than or equal. AttributeValueList can contain only one
AttributeValue element of type String, Number, or Binary (not a set
type). If an item contains an AttributeValue element 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"]}`. >
+ `GT` : Greater than. AttributeValueList can contain only one
AttributeValue element of type String, Number, or Binary (not a set
type). If an item contains an AttributeValue element 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"]}`. >
+ `BEGINS_WITH` : Checks for a prefix. AttributeValueList can contain
only one AttributeValue of type String or Binary (not a Number or a
set type). The target attribute of the comparison must be of type
String or Binary (not a Number or a set type). >
+ `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 type). 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 element 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"]}`
For usage examples of AttributeValueList and ComparisonOperator , see
`Legacy Conditional Parameters`_ in the Amazon DynamoDB Developer
Guide .
:type query_filter: map
:param query_filter:
There is a newer parameter available. Use FilterExpression instead.
Note that if you use QueryFilter and FilterExpression at the same
time, DynamoDB will return a ValidationException exception.
This parameter does not support lists or maps.
A condition that evaluates the query results and returns only the
desired values.
If you specify more than one condition in the QueryFilter 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.)
Each QueryFilter element consists of an attribute name to compare,
along with the following:
+ AttributeValueList - One or more values to evaluate against the
supplied attribute. The number of values in the list depends on the
operator specified in ComparisonOperator . 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 type Binary, DynamoDB treats each byte of the binary data as
unsigned when it compares binary values, for example when
evaluating query expressions. For information on specifying data
types in JSON, see `JSON Data Format`_ in the Amazon DynamoDB
Developer Guide .
+ ComparisonOperator - A comparator for evaluating attributes. For
example, equals, greater than, less than, etc. The following
comparison operators are available: `EQ | NE | LE | LT | GE | GT |
NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN |
BETWEEN` For complete descriptions of all comparison operators, see
`API_Condition.html`_.
:type conditional_operator: string
:param conditional_operator:
There is a newer parameter available. Use ConditionExpression instead.
Note that if you use ConditionalOperator and ConditionExpression at
the same time, DynamoDB will return a ValidationException
exception.
This parameter does not support lists or maps.
A logical operator to apply to the conditions in the QueryFilter 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 scan_index_forward: boolean
:param scan_index_forward: A value that specifies ascending (true) or
descending (false) traversal of the index. DynamoDB returns results
reflecting the requested order determined by the range key. If the
data type is Number, the results are returned in numeric order. For
type String, the results are returned in order of ASCII character
code values. For type Binary, DynamoDB treats each byte of the
binary data as unsigned when it compares binary values.
If ScanIndexForward is not specified, the results are returned in
ascending order.
:type exclusive_start_key: map
:param exclusive_start_key: The primary key of the first item that this
operation will evaluate. Use the value that was returned for
LastEvaluatedKey in the previous operation.
The data type for ExclusiveStartKey must be String, Number or Binary.
No set data types are allowed.
:type return_consumed_capacity: string
:param return_consumed_capacity: A value that 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 projection_expression: string
:param projection_expression: One or more attributes to retrieve from
the table. These attributes can include scalars, sets, or elements
of a JSON document. The attributes in the expression must be
separated by commas.
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.
:type filter_expression: string
:param filter_expression: A condition that evaluates the query results
and returns only the desired values.
The condition you specify is applied to the items queried; any items
that do not match the expression are not returned.
:type expression_attribute_names: map
:param expression_attribute_names:
One or more substitution tokens for simplifying complex expressions.
The following are some use cases for an ExpressionAttributeNames
value:
+ To shorten an attribute name that is very long or unwieldy in an
expression.
+ To create a placeholder for repeating occurrences of an attribute
name in an expression.
+ To prevent special characters in an attribute name from being
misinterpreted in an expression.
Use the **#** character in an expression to dereference an attribute
name. For example, consider the following expression:
+ `order.customerInfo.LastName = "Smith" OR order.customerInfo.LastName
= "Jones"`
Now suppose that you specified the following for
ExpressionAttributeNames :
+ `{"n":"order.customerInfo.LastName"}`
The expression can now be simplified as follows:
+ `#n = "Smith" OR #n = "Jones"`
:type expression_attribute_values: map
:param expression_attribute_values:
One or more values that can be substituted in an expression.
Use the **:** character in an expression to dereference an attribute
value. For example, consider the following expression:
+ `ProductStatus IN ("Available","Backordered","Discontinued")`
Now suppose that you specified the following for
ExpressionAttributeValues :
+ `{ "a":{"S":"Available"}, "b":{"S":"Backordered"},
"d":{"S":"Discontinued"} }`
The expression can now be simplified as follows:
+ `ProductStatus IN (:a,:b,:c)`
R8 t
KeyConditionst IndexNamet SelectRY Rb RZ t QueryFilterRG t ScanIndexForwardt ExclusiveStartKeyR) R[ t FilterExpressionRJ RK R* t QueryR, ( R R- R R. ( R# R? t key_conditionst
index_namet selectR] Re R^ t query_filterRO t scan_index_forwardt exclusive_start_keyR0 R_ t filter_expressionRR RS R1 ( ( s9 /usr/lib/python2.6/site-packages/boto/dynamodb2/layer1.pyt query sD
c C s h | d 6} | t j o | | d
+ `NE` : Not equal. `NE` is supported for all datatypes, including
lists and maps. 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"]}`. >
+ `LE` : Less than or equal. AttributeValueList can contain only one
AttributeValue element of type String, Number, or Binary (not a set
type). If an item contains an AttributeValue element 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"]}`. >
+ `LT` : Less than. AttributeValueList can contain only one
AttributeValue of type String, Number, or Binary (not a set type).
If an item contains an AttributeValue element 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"]}`. >
+ `GE` : Greater than or equal. AttributeValueList can contain only one
AttributeValue element of type String, Number, or Binary (not a set
type). If an item contains an AttributeValue element 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"]}`. >
+ `GT` : Greater than. AttributeValueList can contain only one
AttributeValue element of type String, Number, or Binary (not a set
type). If an item contains an AttributeValue element 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"]}`. >
+ `NOT_NULL` : The attribute exists. `NOT_NULL` is supported for all
datatypes, including lists and maps.
+ `NULL` : The attribute does not exist. `NULL` is supported for all
datatypes, including lists and maps.
+ `CONTAINS` : Checks for a subsequence, or value in a set.
AttributeValueList can contain only one AttributeValue element of
type String, Number, or Binary (not a set type). If the target
attribute of the comparison is of type String, then the operator
checks for a substring match. If the target attribute of the
comparison is of type Binary, then the operator 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 operator evaluates to true if it finds an exact
match with any member of the set. CONTAINS is supported for lists:
When evaluating " `a CONTAINS b`", " `a`" can be a list; however, "
`b`" cannot be a set, a map, or a list.
+ `NOT_CONTAINS` : Checks for absence of a subsequence, or absence of a
value in a set. AttributeValueList can contain only one
AttributeValue element of type String, Number, or Binary (not a set
type). If the target attribute of the comparison is a String, then
the operator checks for the absence of a substring match. If the
target attribute of the comparison is Binary, then the operator
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 operator evaluates to true if
it does not find an exact match with any member of the set.
NOT_CONTAINS is supported for lists: When evaluating " `a NOT
CONTAINS b`", " `a`" can be a list; however, " `b`" cannot be a
set, a map, or a list.
+ `BEGINS_WITH` : Checks for a prefix. AttributeValueList can contain
only one AttributeValue of type String or Binary (not a Number or a
set type). The target attribute of the comparison must be of type
String or Binary (not a Number or a set type). >
+ `IN` : Checks for matching elements within two sets.
AttributeValueList can contain one or more AttributeValue elements
of type String, Number, or Binary (not a set type). These
attributes are compared against an existing set type attribute of
an item. If any elements of the input set are present in the item
attribute, the expression evaluates to true.
+ `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 type). 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 element 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"]}`
For usage examples of AttributeValueList and ComparisonOperator , see
`Legacy Conditional Parameters`_ 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 - A Boolean value that 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.
The Value and Exists parameters are incompatible with
AttributeValueList and ComparisonOperator . Note that if you use
both sets of parameters at once, DynamoDB will return a
ValidationException exception.
:type conditional_operator: string
:param conditional_operator:
There is a newer parameter available. Use ConditionExpression instead.
Note that if you use ConditionalOperator and ConditionExpression at
the same time, DynamoDB will return a ValidationException
exception.
This parameter does not support lists or maps.
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
appeared either before or after they were updated. For UpdateItem ,
the valid values are:
+ `NONE` - If ReturnValues is not specified, or if its value is `NONE`,
then nothing is returned. (This setting is the default for
ReturnValues .)
+ `ALL_OLD` - If UpdateItem overwrote an attribute name-value pair,
then the content of the old item is returned.
+ `UPDATED_OLD` - The old versions of only the updated attributes are
returned.
+ `ALL_NEW` - All of the attributes of the new version of the item are
returned.
+ `UPDATED_NEW` - The new versions of only the updated attributes are
returned.
:type return_consumed_capacity: string
:param return_consumed_capacity: A value that 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: A value that if set to `SIZE`,
the response includes 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.
:type update_expression: string
:param update_expression:
An expression that defines one or more attributes to be updated, the
action to be performed on them, and new value(s) for them.
The following action values are available for UpdateExpression .
+ `SET` - Adds one or more attributes and values to an item. If any of
these attribute already exist, they are replaced by the new values.
You can also use `SET` to add or subtract from an attribute that is
of type Number. `SET` supports the following functions:
+ `if_not_exists (path, operand)` - if the item does not contain an
attribute at the specified path, then `if_not_exists` evaluates to
operand; otherwise, it evaluates to path. You can use this function
to avoid overwriting an attribute that may already be present in
the item.
+ `list_append (operand, operand)` - evaluates to a list with a new
element added to it. You can append the new element to the start or
the end of the list by reversing the order of the operands.
These function names are case-sensitive.
+ `REMOVE` - Removes one or more attributes from an item.
+ `ADD` - Adds the specified value to the item, if the attribute does
not already exist. If the attribute does exist, then the behavior
of `ADD` depends on the data type of the attribute:
+ If the existing attribute is a number, and if Value is also a number,
then Value is mathematically added to the existing attribute. If
Value is a negative number, then it is subtracted from the existing
attribute.
+ If the existing data type is a set and if Value is also a set, then
Value is added to the existing set. For example, if the attribute
value is the set `[1,2]`, and the `ADD` action specified `[3]`,
then the final attribute value is `[1,2,3]`. An error occurs if an
`ADD` action is specified for a set attribute and the attribute
type specified does not match the existing set type. Both sets must
have the same primitive data type. For example, if the existing
data type is a set of strings, the Value must also be a set of
strings.
The `ADD` action only supports Number and set data types. In addition,
`ADD` can only be used on top-level attributes, not nested
attributes.
+ `DELETE` - Deletes an element from a set. If a set of values is
specified, then those values are subtracted from the old set. For
example, if the attribute value was the set `[a,b,c]` and the
`DELETE` action specifies `[a,c]`, then the final attribute value
is `[b]`. Specifying an empty set is an error. The `DELETE` action
only supports Number and set data types. In addition, `DELETE` can
only be used on top-level attributes, not nested attributes.
You can have many actions in a single expression, such as the
following: `SET a=:value1, b=:value2 DELETE :value3, :value4,
:value5`
An expression can contain any of the following:
+ Boolean functions: `ATTRIBUTE_EXIST | CONTAINS | BEGINS_WITH`
+ Comparison operators: ` = | <> | < | > | <=
| >= | BETWEEN | IN`
+ Logical operators: `NOT | AND | OR`
:type condition_expression: string
:param condition_expression:
A condition that must be satisfied in order for a conditional update to
succeed.
An expression can contain any of the following:
+ Boolean functions: `ATTRIBUTE_EXIST | CONTAINS | BEGINS_WITH`
+ Comparison operators: ` = | <> | < | > | <=
| >= | BETWEEN | IN`
+ Logical operators: `NOT | AND | OR`
:type expression_attribute_names: map
:param expression_attribute_names:
One or more substitution tokens for simplifying complex expressions.
The following are some use cases for an ExpressionAttributeNames
value:
+ To shorten an attribute name that is very long or unwieldy in an
expression.
+ To create a placeholder for repeating occurrences of an attribute
name in an expression.
+ To prevent special characters in an attribute name from being
misinterpreted in an expression.
Use the **#** character in an expression to dereference an attribute
name. For example, consider the following expression:
+ `order.customerInfo.LastName = "Smith" OR order.customerInfo.LastName
= "Jones"`
Now suppose that you specified the following for
ExpressionAttributeNames :
+ `{"n":"order.customerInfo.LastName"}`
The expression can now be simplified as follows:
+ `#n = "Smith" OR #n = "Jones"`
:type expression_attribute_values: map
:param expression_attribute_values:
One or more values that can be substituted in an expression.
Use the **:** character in an expression to dereference an attribute
value. For example, consider the following expression:
+ `ProductStatus IN ("Available","Backordered","Discontinued")`
Now suppose that you specified the following for
ExpressionAttributeValues :
+ `{ "a":{"S":"Available"}, "b":{"S":"Backordered"},
"d":{"S":"Discontinued"} }`
The expression can now be simplified as follows:
+ `ProductStatus IN (:a,:b,:c)`
R8 RE t AttributeUpdatesRF RG RH R) R3 t UpdateExpressionRI RJ RK R* t
UpdateItemR, ( R R- R R. ( R# R? RM t attribute_updatesRN RO RP R0 R5 t update_expressionRQ RR RS R1 ( ( s9 /usr/lib/python2.6/site-packages/boto/dynamodb2/layer1.pyt update_item s0
c C sb h | d 6} | d j o | | d s