DynamoDB2 — boto v2.25.0

### Navigation

- index
- modules |
- next |
- previous |
- boto v2.25.0 »

# DynamoDB2

## High-Level API

### boto.dynamodb2.fields

class `boto.dynamodb2.fields.` `AllIndex`(name, parts)

  An index signifying all fields should be in the index.

  Example:

      >>> AllIndex('MostRecentlyJoined', parts=[
      ...     HashKey('username'),
      ...     RangeKey('date_joined')
      ... ])

  `projection_type` = 'ALL'

class `boto.dynamodb2.fields.` `BaseIndexField`(name, parts)

  An abstract class for defining schema indexes.

  Contains most of the core functionality for the index. Subclasses must define a `projection_type` to pass to DynamoDB.

  `definition`()

    Returns the attribute definition structure DynamoDB expects.

    Example:

        >>> index.definition()
        {
            'AttributeName': 'username',
            'AttributeType': 'S',
        }

  `schema`()

    Returns the schema structure DynamoDB expects.

    Example:

        >>> index.schema()
        {
            'IndexName': 'LastNameIndex',
            'KeySchema': [
                {
                    'AttributeName': 'username',
                    'KeyType': 'HASH',
                },
            ],
            'Projection': {
                'ProjectionType': 'KEYS_ONLY',
            }
        }

class `boto.dynamodb2.fields.` `BaseSchemaField`(name, data_type='S')

  An abstract class for defining schema fields.

  Contains most of the core functionality for the field. Subclasses must define an `attr_type` to pass to DynamoDB.

  Creates a Python schema field, to represent the data to pass to DynamoDB.

  Requires a `name` parameter, which should be a string name of the field.

  Optionally accepts a `data_type` parameter, which should be a constant from `boto.dynamodb2.types`. (Default: `STRING`)

  `attr_type` = None
  `definition`()

    Returns the attribute definition structure DynamoDB expects.

    Example:

        >>> field.definition()
        {
            'AttributeName': 'username',
            'AttributeType': 'S',
        }

  `schema`()

    Returns the schema structure DynamoDB expects.

    Example:

        >>> field.schema()
        {
            'AttributeName': 'username',
            'KeyType': 'HASH',
        }

class `boto.dynamodb2.fields.` `GlobalAllIndex`(*args, **kwargs)

  An index signifying all fields should be in the index.

  Example:

      >>> GlobalAllIndex('MostRecentlyJoined', parts=[
      ...     HashKey('username'),
      ...     RangeKey('date_joined')
      ... ],
      ... throughput={
      ...     'read': 2,
      ...     'write': 1,
      ... })

  `projection_type` = 'ALL'

class `boto.dynamodb2.fields.` `GlobalBaseIndexField`(*args, **kwargs)

  An abstract class for defining global indexes.

  Contains most of the core functionality for the index. Subclasses must define a `projection_type` to pass to DynamoDB.

  `schema`()

    Returns the schema structure DynamoDB expects.

    Example:

        >>> index.schema()
        {
            'IndexName': 'LastNameIndex',
            'KeySchema': [
                {
                    'AttributeName': 'username',
                    'KeyType': 'HASH',
                },
            ],
            'Projection': {
                'ProjectionType': 'KEYS_ONLY',
            },
            'ProvisionedThroughput': {
                'ReadCapacityUnits': 5,
                'WriteCapacityUnits': 5
            }
        }

  `throughput` = {'read': 5, 'write': 5}

class `boto.dynamodb2.fields.` `GlobalIncludeIndex`(*args, **kwargs)

  An index signifying only certain fields should be in the index.

  Example:

      >>> GlobalIncludeIndex('GenderIndex', parts=[
      ...     HashKey('username'),
      ...     RangeKey('date_joined')
      ... ],
      ... includes=['gender'],
      ... throughput={
      ...     'read': 2,
      ...     'write': 1,
      ... })

  `projection_type` = 'INCLUDE'
  `schema`()

class `boto.dynamodb2.fields.` `GlobalKeysOnlyIndex`(*args, **kwargs)

  An index signifying only key fields should be in the index.

  Example:

      >>> GlobalKeysOnlyIndex('MostRecentlyJoined', parts=[
      ...     HashKey('username'),
      ...     RangeKey('date_joined')
      ... ],
      ... throughput={
      ...     'read': 2,
      ...     'write': 1,
      ... })

  `projection_type` = 'KEYS_ONLY'

class `boto.dynamodb2.fields.` `HashKey`(name, data_type='S')

  An field representing a hash key.

  Example:

      >>> from boto.dynamodb2.types import NUMBER
      >>> HashKey('username')
      >>> HashKey('date_joined', data_type=NUMBER)

  Creates a Python schema field, to represent the data to pass to DynamoDB.

  Requires a `name` parameter, which should be a string name of the field.

  Optionally accepts a `data_type` parameter, which should be a constant from `boto.dynamodb2.types`. (Default: `STRING`)

  `attr_type` = 'HASH'

class `boto.dynamodb2.fields.` `IncludeIndex`(*args, **kwargs)

  An index signifying only certain fields should be in the index.

  Example:

      >>> IncludeIndex('GenderIndex', parts=[
      ...     HashKey('username'),
      ...     RangeKey('date_joined')
      ... ], includes=['gender'])

  `projection_type` = 'INCLUDE'
  `schema`()

class `boto.dynamodb2.fields.` `KeysOnlyIndex`(name, parts)

  An index signifying only key fields should be in the index.

  Example:

      >>> KeysOnlyIndex('MostRecentlyJoined', parts=[
      ...     HashKey('username'),
      ...     RangeKey('date_joined')
      ... ])

  `projection_type` = 'KEYS_ONLY'

class `boto.dynamodb2.fields.` `RangeKey`(name, data_type='S')

  An field representing a range key.

  Example:

      >>> from boto.dynamodb2.types import NUMBER
      >>> HashKey('username')
      >>> HashKey('date_joined', data_type=NUMBER)

  Creates a Python schema field, to represent the data to pass to DynamoDB.

  Requires a `name` parameter, which should be a string name of the field.

  Optionally accepts a `data_type` parameter, which should be a constant from `boto.dynamodb2.types`. (Default: `STRING`)

  `attr_type` = 'RANGE'

### boto.dynamodb2.items

class `boto.dynamodb2.items.` `Item`(table, data=None, loaded=False)

  An object representing the item data within a DynamoDB table.

  An item is largely schema-free, meaning it can contain any data. The only limitation is that it must have data for the fields in the `Table`‘s schema.

  This object presents a dictionary-like interface for accessing/storing data. It also tries to intelligently track how data has changed throughout the life of the instance, to be as efficient as possible about updates.

  Empty items, or items that have no data, are considered falsey.

  Constructs an (unsaved) `Item` instance.

  To persist the data in DynamoDB, you’ll need to call the `Item.save` (or `Item.partial_save`) on the instance.

  Requires a `table` parameter, which should be a `Table` instance. This is required, as DynamoDB’s API is focus around all operations being table-level. It’s also for persisting schema around many objects.

  Optionally accepts a `data` parameter, which should be a dictionary of the fields & values of the item.

  Optionally accepts a `loaded` parameter, which should be a boolean. `True` if it was preexisting data loaded from DynamoDB, `False` if it’s new data from the user. Default is `False`.

  Example:

      >>> users = Table('users')
      >>> user = Item(users, data={
      ...     'username': 'johndoe',
      ...     'first_name': 'John',
      ...     'date_joined': 1248o61592,
      ... })

      # Change existing data.
      >>> user['first_name'] = 'Johann'
      # Add more data.
      >>> user['last_name'] = 'Doe'
      # Delete data.
      >>> del user['date_joined']

      # Iterate over all the data.
      >>> for field, val in user.items():
      ...     print "%s: %s" % (field, val)
      username: johndoe
      first_name: John
      date_joined: 1248o61592

  `build_expects`(fields=None)

    Builds up a list of expecations to hand off to DynamoDB on save.

    Largely internal.

  `delete`()

    Deletes the item’s data to DynamoDB.

    Returns `True` on success.

    Example:

        # Buh-bye now.
        >>> user.delete()

  `get`(key, default=None)
  `get_keys`()

    Returns a Python-style dict of the keys/values.

    Largely internal.

  `get_raw_keys`()

    Returns a DynamoDB-style dict of the keys/values.

    Largely internal.

  `items`()
  `keys`()
  `load`(data)

    This is only useful when being handed raw data from DynamoDB directly. If you have a Python datastructure already, use the `__init__` or manually set the data instead.

    Largely internal, unless you know what you’re doing or are trying to mix the low-level & high-level APIs.

  `mark_clean`()

    Marks an `Item` instance as no longer needing to be saved.

    Example:

        >>> user.needs_save()
        False
        >>> user['first_name'] = 'Johann'
        >>> user.needs_save()
        True
        >>> user.mark_clean()
        >>> user.needs_save()
        False

  `mark_dirty`()

    DEPRECATED: Marks an `Item` instance as needing to be saved.

    This method is no longer necessary, as the state tracking on `Item` has been improved to automatically detect proper state.

  `needs_save`(data=None)

    Returns whether or not the data has changed on the `Item`.

    Optionally accepts a `data` argument, which accepts the output from `self._determine_alterations()` if you’ve already called it. Typically unnecessary to do. Default is `None`.

    Example:

        >>> user.needs_save()
        False
        >>> user['first_name'] = 'Johann'
        >>> user.needs_save()
        True

  `partial_save`()

    Saves only the changed data to DynamoDB.

    Extremely useful for high-volume/high-write data sets, this allows you to update only a handful of fields rather than having to push entire items. This prevents many accidental overwrite situations as well as saves on the amount of data to transfer over the wire.

    Returns `True` on success, `False` if no save was performed or the write failed.

    Example:

        >>> user['last_name'] = 'Doh!'
        # Only the last name field will be sent to DynamoDB.
        >>> user.partial_save()

  `prepare_full`()

    Runs through all fields & encodes them to be handed off to DynamoDB as part of an `save` (`put_item`) call.

    Largely internal.

  `prepare_partial`()

    Runs through ONLY the changed/deleted fields & encodes them to be handed off to DynamoDB as part of an `partial_save` (`update_item`) call.

    Largely internal.

  `save`(overwrite=False)

    Saves all data to DynamoDB.

    By default, this attempts to ensure that none of the underlying data has changed. If any fields have changed in between when the `Item` was constructed & when it is saved, this call will fail so as not to cause any data loss.

    If you’re sure possibly overwriting data is acceptable, you can pass an `overwrite=True`. If that’s not acceptable, you may be able to use `Item.partial_save` to only write the changed field data.

    Optionally accepts an `overwrite` parameter, which should be a boolean. If you provide `True`, the item will be forcibly overwritten within DynamoDB, even if another process changed the data in the meantime. (Default: `False`)

    Returns `True` on success, `False` if no save was performed.

    Example:

        >>> user['last_name'] = 'Doh!'
        # All data on the Item is sent to DynamoDB.
        >>> user.save()

        # If it fails, you can overwrite.
        >>> user.save(overwrite=True)

  `values`()

class `boto.dynamodb2.items.` `NEWVALUE`

### boto.dynamodb2.results

class `boto.dynamodb2.results.` `BatchGetResultSet`(*args, **kwargs)
  `fetch_more`()

class `boto.dynamodb2.results.` `ResultSet`(max_page_size=None)

  A class used to lazily handle page-to-page navigation through a set of results.

  It presents a transparent iterator interface, so that all the user has to do is use it in a typical `for` loop (or list comprehension, etc.) to fetch results, even if they weren’t present in the current page of results.

  This is used by the `Table.query` & `Table.scan` methods.

  Example:

      >>> users = Table('users')
      >>> results = ResultSet()
      >>> results.to_call(users.query, username__gte='johndoe')
      # Now iterate. When it runs out of results, it'll fetch the next page.
      >>> for res in results:
      ...     print res['username']

  `fetch_more`()

    When the iterator runs out of results, this method is run to re-execute the callable (& arguments) to fetch the next page.

    Largely internal.

  `first_key`
  `next`()
  `to_call`(the_callable, *args, **kwargs)

    Sets up the callable & any arguments to run it with.

    This is stored for subsequent calls so that those queries can be run without requiring user intervention.

    Example:

        # Just an example callable.
        >>> def squares_to(y):
        ...     for x in range(1, y):
        ...         yield x**2
        >>> rs = ResultSet()
        # Set up what to call & arguments.
        >>> rs.to_call(squares_to, y=3)

### boto.dynamodb2.table

class `boto.dynamodb2.table.` `BatchTable`(table)

  Used by `Table` as the context manager for batch writes.

  You likely don’t want to try to use this object directly.

  `delete_item`(**kwargs)
  `flush`()
  `handle_unprocessed`(resp)
  `put_item`(data, overwrite=False)
  `resend_unprocessed`()
  `should_flush`()

class `boto.dynamodb2.table.` `Table`(table_name, schema=None, throughput=None, indexes=None, global_indexes=None, connection=None)

  Interacts & models the behavior of a DynamoDB table.

  The `Table` object represents a set (or rough categorization) of records within DynamoDB. The important part is that all records within the table, while largely-schema-free, share the same schema & are essentially namespaced for use in your application. For example, you might have a `users` table or a `forums` table.

  Sets up a new in-memory `Table`.

  This is useful if the table already exists within DynamoDB & you simply want to use it for additional interactions. The only required parameter is the `table_name`. However, under the hood, the object will call `describe_table` to determine the schema/indexes/throughput. You can avoid this extra call by passing in `schema` & `indexes`.

  IMPORTANT - If you’re creating a new `Table` for the first time, you should use the `Table.create` method instead, as it will persist the table structure to DynamoDB.

  Requires a `table_name` parameter, which should be a simple string of the name of the table.

  Optionally accepts a `schema` parameter, which should be a list of `BaseSchemaField` subclasses representing the desired schema.

  Optionally accepts a `throughput` parameter, which should be a dictionary. If provided, it should specify a `read` & `write` key, both of which should have an integer value associated with them.

  Optionally accepts a `indexes` parameter, which should be a list of `BaseIndexField` subclasses representing the desired indexes.

  Optionally accepts a `global_indexes` parameter, which should be a list of `GlobalBaseIndexField` subclasses representing the desired indexes.

  Optionally accepts a `connection` parameter, which should be a `DynamoDBConnection` instance (or subclass). This is primarily useful for specifying alternate connection parameters.

  Example:

      # The simple, it-already-exists case.
      >>> conn = Table('users')

      # The full, minimum-extra-calls case.
      >>> from boto import dynamodb2
      >>> users = Table('users', schema=[
      ...     HashKey('username'),
      ...     RangeKey('date_joined', data_type=NUMBER)
      ... ], throughput={
      ...     'read':20,
      ...     'write': 10,
      ... }, indexes=[
      ...     KeysOnlyIndex('MostRecentlyJoined', parts=[
      ...         HashKey('username')
      ...         RangeKey('date_joined')
      ...     ]),
      ... ], global_indexes=[
      ...     GlobalAllIndex('UsersByZipcode', parts=[
      ...         HashKey('zipcode'),
      ...         RangeKey('username'),
      ...     ],
      ...     throughput={
      ...       'read':10,
      ...       'write":10,
      ...     }),
      ... ], connection=dynamodb2.connect_to_region('us-west-2',
      ...     aws_access_key_id='key',
      ...     aws_secret_access_key='key',
      ... ))

  `batch_get`(keys, consistent=False)

    Fetches many specific items in batch from a table.

    Requires a `keys` parameter, which should be a list of dictionaries. Each dictionary should consist of the keys values to specify.

    Optionally accepts a `consistent` parameter, which should be a boolean. If you provide `True`, a strongly consistent read will be used. (Default: False)

    Returns a `ResultSet`, which transparently handles the pagination of results you get back.

    Example:

        >>> results = users.batch_get(keys=[
        ...     {
        ...         'username': 'johndoe',
        ...     },
        ...     {
        ...         'username': 'jane',
        ...     },
        ...     {
        ...         'username': 'fred',
        ...     },
        ... ])
        >>> for res in results:
        ...     print res['first_name']
        'John'
        'Jane'
        'Fred'

  `batch_write`()

    Allows the batching of writes to DynamoDB.

    Since each write/delete call to DynamoDB has a cost associated with it, when loading lots of data, it makes sense to batch them, creating as few calls as possible.

    This returns a context manager that will transparently handle creating these batches. The object you get back lightly-resembles a `Table` object, sharing just the `put_item` & `delete_item` methods (which are all that DynamoDB can batch in terms of writing data).

    DynamoDB’s maximum batch size is 25 items per request. If you attempt to put/delete more than that, the context manager will batch as many as it can up to that number, then flush them to DynamoDB & continue batching as more calls come in.

    Example:

        # Assuming a table with one record...
        >>> with users.batch_write() as batch:
        ...     batch.put_item(data={
        ...         'username': 'johndoe',
        ...         'first_name': 'John',
        ...         'last_name': 'Doe',
        ...         'owner': 1,
        ...     })
        ...     # Nothing across the wire yet.
        ...     batch.delete_item(username='bob')
        ...     # Still no requests sent.
        ...     batch.put_item(data={
        ...         'username': 'jane',
        ...         'first_name': 'Jane',
        ...         'last_name': 'Doe',
        ...         'date_joined': 127436192,
        ...     })
        ...     # Nothing yet, but once we leave the context, the
        ...     # put/deletes will be sent.

  `count`()

    Returns a (very) eventually consistent count of the number of items in a table.

    Lag time is about 6 hours, so don’t expect a high degree of accuracy.

    Example:

        >>> users.count()
        6

  classmethod `create`(table_name, schema, throughput=None, indexes=None, global_indexes=None, connection=None)

    Creates a new table in DynamoDB & returns an in-memory `Table` object.

    This will setup a brand new table within DynamoDB. The `table_name` must be unique for your AWS account. The `schema` is also required to define the key structure of the table.

    IMPORTANT - You should consider the usage pattern of your table up-front, as the schema & indexes can NOT be modified once the table is created, requiring the creation of a new table & migrating the data should you wish to revise it.

    IMPORTANT - If the table already exists in DynamoDB, additional calls to this method will result in an error. If you just need a `Table` object to interact with the existing table, you should just initialize a new `Table` object, which requires only the `table_name`.

    Requires a `table_name` parameter, which should be a simple string of the name of the table.

    Requires a `schema` parameter, which should be a list of `BaseSchemaField` subclasses representing the desired schema.

    Optionally accepts a `throughput` parameter, which should be a dictionary. If provided, it should specify a `read` & `write` key, both of which should have an integer value associated with them.

    Optionally accepts a `indexes` parameter, which should be a list of `BaseIndexField` subclasses representing the desired indexes.

    Optionally accepts a `global_indexes` parameter, which should be a list of `GlobalBaseIndexField` subclasses representing the desired indexes.

    Optionally accepts a `connection` parameter, which should be a `DynamoDBConnection` instance (or subclass). This is primarily useful for specifying alternate connection parameters.

    Example:

        >>> users = Table.create('users', schema=[
        ...     HashKey('username'),
        ...     RangeKey('date_joined', data_type=NUMBER)
        ... ], throughput={
        ...     'read':20,
        ...     'write': 10,
        ... }, indexes=[
        ...     KeysOnlyIndex('MostRecentlyJoined', parts=[
        ...         RangeKey('date_joined')
        ... ]), global_indexes=[
        ...     GlobalAllIndex('UsersByZipcode', parts=[
        ...         HashKey('zipcode'),
        ...         RangeKey('username'),
        ...     ],
        ...     throughput={
        ...       'read':10,
        ...       'write':10,
        ...     }),
        ... ])

  `delete`()

    Deletes a table in DynamoDB.

    IMPORTANT - Be careful when using this method, there is no undo.

    Returns `True` on success.

    Example:

        >>> users.delete()
        True

  `delete_item`(**kwargs)

    Deletes an item in DynamoDB.

    IMPORTANT - Be careful when using this method, there is no undo.

    To specify the key of the item you’d like to get, you can specify the key attributes as kwargs.

    Returns `True` on success.

    Example:

        # A simple hash key.
        >>> users.delete_item(username='johndoe')
        True

        # A complex hash+range key.
        >>> users.delete_item(username='jane', last_name='Doe')
        True

        # With a key that is an invalid variable name in Python.
        # Also, assumes a different schema than previous examples.
        >>> users.delete_item(**{
        ...     'date-joined': 127549192,
        ... })
        True

  `describe`()

    Describes the current structure of the table in DynamoDB.

    This information will be used to update the `schema`, `indexes` and `throughput` information on the `Table`. Some calls, such as those involving creating keys or querying, will require this information to be populated.

    It also returns the full raw datastructure from DynamoDB, in the event you’d like to parse out additional information (such as the `ItemCount` or usage information).

    Example:

        >>> users.describe()
        {
            # Lots of keys here...
        }
        >>> len(users.schema)
        2

  `get_item`(consistent=False, attributes=None, **kwargs)

    Fetches an item (record) from a table in DynamoDB.

    To specify the key of the item you’d like to get, you can specify the key attributes as kwargs.

    Optionally accepts a `consistent` parameter, which should be a boolean. If you provide `True`, it will perform a consistent (but more expensive) read from DynamoDB. (Default: `False`)

    Optionally accepts an `attributes` parameter, which should be a list of fieldname to fetch. (Default: `None`, which means all fields should be fetched)

    Returns an `Item` instance containing all the data for that record.

    Example:

        # A simple hash key.
        >>> john = users.get_item(username='johndoe')
        >>> john['first_name']
        'John'

        # A complex hash+range key.
        >>> john = users.get_item(username='johndoe', last_name='Doe')
        >>> john['first_name']
        'John'

        # A consistent read (assuming the data might have just changed).
        >>> john = users.get_item(username='johndoe', consistent=True)
        >>> john['first_name']
        'Johann'

        # With a key that is an invalid variable name in Python.
        # Also, assumes a different schema than previous examples.
        >>> john = users.get_item(**{
        ...     'date-joined': 127549192,
        ... })
        >>> john['first_name']
        'John'

  `get_key_fields`()

    Returns the fields necessary to make a key for a table.

    If the `Table` does not already have a populated `schema`, this will request it via a `Table.describe` call.

    Returns a list of fieldnames (strings).

    Example:

        # A simple hash key.
        >>> users.get_key_fields()
        ['username']

        # A complex hash+range key.
        >>> users.get_key_fields()
        ['username', 'last_name']

  `has_item`(**kwargs)

    Return whether an item (record) exists within a table in DynamoDB.

    To specify the key of the item you’d like to get, you can specify the key attributes as kwargs.

    Optionally accepts a `consistent` parameter, which should be a boolean. If you provide `True`, it will perform a consistent (but more expensive) read from DynamoDB. (Default: `False`)

    Optionally accepts an `attributes` parameter, which should be a list of fieldnames to fetch. (Default: `None`, which means all fields should be fetched)

    Returns `True` if an `Item` is present, `False` if not.

    Example:

        # Simple, just hash-key schema.
        >>> users.has_item(username='johndoe')
        True

        # Complex schema, item not present.
        >>> users.has_item(
        ...     username='johndoe',
        ...     date_joined='2014-01-07'
        ... )
        False

  `lookup`(*args, **kwargs)

    Look up an entry in DynamoDB. This is mostly backwards compatible with boto.dynamodb. Unlike get_item, it takes hash_key and range_key first, although you may still specify keyword arguments instead.

    Also unlike the get_item command, if the returned item has no keys (i.e., it does not exist in DynamoDB), a None result is returned, instead of an empty key object.

    Example::

          >>> user = users.lookup(username)
          >>> user = users.lookup(username, consistent=True)
          >>> app = apps.lookup('my_customer_id', 'my_app_id')

  `max_batch_get` = 100
  `new_item`(*args)

    Returns a new, blank item

    This is mostly for consistency with boto.dynamodb

  `put_item`(data, overwrite=False)

    Saves an entire item to DynamoDB.

    By default, if any part of the `Item`‘s original data doesn’t match what’s currently in DynamoDB, this request will fail. This prevents other processes from updating the data in between when you read the item & when your request to update the item’s data is processed, which would typically result in some data loss.

    Requires a `data` parameter, which should be a dictionary of the data you’d like to store in DynamoDB.

    Optionally accepts an `overwrite` parameter, which should be a boolean. If you provide `True`, this will tell DynamoDB to blindly overwrite whatever data is present, if any.

    Returns `True` on success.

    Example:

        >>> users.put_item(data={
        ...     'username': 'jane',
        ...     'first_name': 'Jane',
        ...     'last_name': 'Doe',
        ...     'date_joined': 126478915,
        ... })
        True

  `query`(limit=None, index=None, reverse=False, consistent=False, attributes=None, max_page_size=None, **filter_kwargs)

    Queries for a set of matching items in a DynamoDB table.

    Queries can be performed against a hash key, a hash+range key or against any data stored in your local secondary indexes.

    Note - You can not query against arbitrary fields within the data stored in DynamoDB.

    To specify the filters of the items you’d like to get, you can specify the filters as kwargs. Each filter kwarg should follow the pattern `<fieldname>__<filter_operation>=<value_to_look_for>`.

    Optionally accepts a `limit` parameter, which should be an integer count of the total number of items to return. (Default: `None` - all results)

    Optionally accepts an `index` parameter, which should be a string of name of the local secondary index you want to query against. (Default: `None`)

    Optionally accepts a `reverse` parameter, which will present the results in reverse order. (Default: `None` - normal order)

    Optionally accepts a `consistent` parameter, which should be a boolean. If you provide `True`, it will force a consistent read of the data (more expensive). (Default: `False` - use eventually consistent reads)

    Optionally accepts a `attributes` parameter, which should be a tuple. If you provide any attributes only these will be fetched from DynamoDB. This uses the `AttributesToGet` and set’s `Select` to `SPECIFIC_ATTRIBUTES` API.

    Optionally accepts a `max_page_size` parameter, which should be an integer count of the maximum number of items to retrieve per-request. This is useful in making faster requests & prevent the scan from drowning out other queries. (Default: `None` - fetch as many as DynamoDB will return)

    Returns a `ResultSet`, which transparently handles the pagination of results you get back.

    Example:

        # Look for last names equal to "Doe".
        >>> results = users.query(last_name__eq='Doe')
        >>> for res in results:
        ...     print res['first_name']
        'John'
        'Jane'

        # Look for last names beginning with "D", in reverse order, limit 3.
        >>> results = users.query(
        ...     last_name__beginswith='D',
        ...     reverse=True,
        ...     limit=3
        ... )
        >>> for res in results:
        ...     print res['first_name']
        'Alice'
        'Jane'
        'John'

        # Use an LSI & a consistent read.
        >>> results = users.query(
        ...     date_joined__gte=1236451000,
        ...     owner__eq=1,
        ...     index='DateJoinedIndex',
        ...     consistent=True
        ... )
        >>> for res in results:
        ...     print res['first_name']
        'Alice'
        'Bob'
        'John'
        'Fred'

  `query_count`(index=None, consistent=False, **filter_kwargs)

    Queries the exact count of matching items in a DynamoDB table.

    Queries can be performed against a hash key, a hash+range key or against any data stored in your local secondary indexes.

    To specify the filters of the items you’d like to get, you can specify the filters as kwargs. Each filter kwarg should follow the pattern `<fieldname>__<filter_operation>=<value_to_look_for>`.

    Optionally accepts an `index` parameter, which should be a string of name of the local secondary index you want to query against. (Default: `None`)

    Optionally accepts a `consistent` parameter, which should be a boolean. If you provide `True`, it will force a consistent read of the data (more expensive). (Default: `False` - use eventually consistent reads)

    Returns an integer which represents the exact amount of matched items.

    Example:

        # Look for last names equal to "Doe".
        >>> users.query_count(last_name__eq='Doe')
        5

        # Use an LSI & a consistent read.
        >>> users.query_count(
        ...     date_joined__gte=1236451000,
        ...     owner__eq=1,
        ...     index='DateJoinedIndex',
        ...     consistent=True
        ... )
        2

  `scan`(limit=None, segment=None, total_segments=None, max_page_size=None, attributes=None, **filter_kwargs)

    Scans across all items within a DynamoDB table.

    Scans can be performed against a hash key or a hash+range key. You can additionally filter the results after the table has been read but before the response is returned.

    To specify the filters of the items you’d like to get, you can specify the filters as kwargs. Each filter kwarg should follow the pattern `<fieldname>__<filter_operation>=<value_to_look_for>`.

    Optionally accepts a `limit` parameter, which should be an integer count of the total number of items to return. (Default: `None` - all results)

    Optionally accepts a `segment` parameter, which should be an integer of the segment to retrieve on. Please see the documentation about Parallel Scans (Default: `None` - no segments)

    Optionally accepts a `total_segments` parameter, which should be an integer count of number of segments to divide the table into. Please see the documentation about Parallel Scans (Default: `None` - no segments)

    Optionally accepts a `max_page_size` parameter, which should be an integer count of the maximum number of items to retrieve per-request. This is useful in making faster requests & prevent the scan from drowning out other queries. (Default: `None` - fetch as many as DynamoDB will return)

    Optionally accepts an `attributes` parameter, which should be a tuple. If you provide any attributes only these will be fetched from DynamoDB. This uses the `AttributesToGet` and set’s `Select` to `SPECIFIC_ATTRIBUTES` API.

    Returns a `ResultSet`, which transparently handles the pagination of results you get back.

    Example:

        # All results.
        >>> everything = users.scan()

        # Look for last names beginning with "D".
        >>> results = users.scan(last_name__beginswith='D')
        >>> for res in results:
        ...     print res['first_name']
        'Alice'
        'John'
        'Jane'

        # Use an ``IN`` filter & limit.
        >>> results = users.scan(
        ...     age__in=[25, 26, 27, 28, 29],
        ...     limit=1
        ... )
        >>> for res in results:
        ...     print res['first_name']
        'Alice'

  `update`(throughput, global_indexes=None)

    Updates table attributes in DynamoDB.

    Currently, the only thing you can modify about a table after it has been created is the throughput.

    Requires a `throughput` parameter, which should be a dictionary. If provided, it should specify a `read` & `write` key, both of which should have an integer value associated with them.

    Returns `True` on success.

    Example:

        # For a read-heavier application...
        >>> users.update(throughput={
        ...     'read': 20,
        ...     'write': 10,
        ... })
        True

        # To also update the global index(es) throughput.
        >>> users.update(throughput={
        ...     'read': 20,
        ...     'write': 10,
        ... },
        ... global_secondary_indexes={
        ...     'TheIndexNameHere': {
        ...         'read': 15,
        ...         'write': 5,
        ...     }
        ... })
        True

## Low-Level API

### boto.dynamodb2

`boto.dynamodb2.` `connect_to_region`(region_name, **kw_params)

`boto.dynamodb2.` `regions`()

  Get all available regions for the Amazon DynamoDB service.

  Return type: | list
  Returns: | A list of `boto.regioninfo.RegionInfo`

### boto.dynamodb2.layer1

class `boto.dynamodb2.layer1.` `DynamoDBConnection`(**kwargs)

  Amazon DynamoDB Overview This is the Amazon DynamoDB API Reference. This guide provides descriptions and samples of the Amazon DynamoDB API.

  `APIVersion` = '2012-08-10'
  `DefaultRegionEndpoint` = 'dynamodb.us-east-1.amazonaws.com'
  `DefaultRegionName` = 'us-east-1'
  `NumberRetries` = 10
  `ResponseError`

    alias of `JSONResponseError`

  `ServiceName` = 'DynamoDB'
  `TargetPrefix` = 'DynamoDB_20120810'
  `batch_get_item`(request_items, return_consumed_capacity=None)

    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 1 MB of data, which can comprise 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, the operation returns a value for UnprocessedKeys . You can use this value to retry the operation starting with the next item to get.

    For example, if you ask to retrieve 100 items, but each individual item is 50 KB in size, the system returns 20 items (1 MB) and 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 no items can be processed because of insufficient provisioned throughput on each of the tables involved in the request, BatchGetItem throws ProvisionedThroughputExceededException .

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

    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 `Capacity Units Calculations`_ in the Amazon DynamoDB Developer Guide.

    Parameters: | request_items (map) –

    A map of one or more table names and, for each table, the corresponding
      primary keys for the items to retrieve. Each table name can be invoked only once.

    Each element in the map consists of the following:

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

        items in the table.

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

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

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

    Parameters: | return_consumed_capacity (string) – If set to TOTAL, ConsumedCapacity is included in the response; if set to NONE (the default), ConsumedCapacity is not included.

  `batch_write_item`(request_items, return_consumed_capacity=None, return_item_collection_metrics=None)

    The BatchWriteItem operation puts or deletes multiple items in one or more tables. A single call to BatchWriteItem can write up to 1 MB of data, which can comprise as many as 25 put or delete requests. Individual items to be written can be as large as 64 KB.

    BatchWriteItem cannot update items. To update items, use the UpdateItem API.

    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.

    To write one item, you can use the PutItem operation; to delete one item, you can use the DeleteItem operation.

    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.

    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 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 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, Amazon DynamoDB rejects the entire batch write operation:

    - One or more tables specified in the BatchWriteItem request does not exist.
    - Primary key attributes specified on an item in the request do not match those in the corresponding table’s primary key schema.
    - You try to perform multiple operations on the same item in the same BatchWriteItem request. For example, you cannot put and delete the same item in the same BatchWriteItem request.
    - The total request size exceeds 1 MB.
    - Any individual item in a batch exceeds 64 KB.

    Parameters: | request_items (map) –

    A map of one or more table names and, for each table, a list of
      operations to be performed ( DeleteRequest or PutRequest ). Each element in the map consists of the following:
    - DeleteRequest - Perform a DeleteItem operation on the specified item.

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

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

        > item to be put is identified by an Item subelement:

        - Item - A map of attributes and their values. Each entry in this map

            consists of an attribute name and an attribute value. Attribute values must not be null; string and binary type attributes must have lengths greater than zero; and set type attributes must not be empty. Requests that contain empty values will be rejected with a ValidationException . 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.

    Parameters: | return_consumed_capacity (string) – If set to TOTAL, ConsumedCapacity is included in the response; if set to NONE (the default), ConsumedCapacity is not included. return_item_collection_metrics (string) – 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..

  `create_table`(attribute_definitions, table_name, key_schema, provisioned_throughput, local_secondary_indexes=None, global_secondary_indexes=None)

    The CreateTable operation adds a new table to your account. In an AWS 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, 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.

    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.

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

    Parameters: | attribute_definitions (list) – An array of attributes that describe the key schema for the table and indexes. table_name (string) – The name of the table to create. key_schema (list) – 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.

    Each KeySchemaElement in the array is composed of:

    - AttributeName - The name of this key attribute.
    - KeyType - Determines whether the key attribute is HASH or RANGE.
    For a primary key that consists of a hash attribute, you must specify
      exactly one element with a KeyType of HASH.
    For a primary key that consists of hash and range attributes, you must
      specify exactly two elements, in this order: The first element must have a KeyType of HASH, and the second element must have a KeyType of RANGE.
    For more information, see `Specifying the Primary Key`_ in the Amazon
      DynamoDB Developer Guide.

    Parameters: | local_secondary_indexes (list) –

    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.

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

    - 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 index. The total count of attributes specified in NonKeyAttributes , summed across all of the local 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.

    Parameters: | global_secondary_indexes (list) – provisioned_throughput (dict) – The provisioned throughput settings for the specified table. 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.
  `delete_item`(table_name, key, expected=None, return_values=None, return_consumed_capacity=None, return_item_collection_metrics=None)

    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 only deleting items if specific conditions are met. If those conditions are met, Amazon DynamoDB performs the delete. Otherwise, the item is not deleted.

    Parameters: | table_name (string) – The name of the table from which to delete the item. key (map) – A map of attribute names to AttributeValue objects, representing the primary key of the item to delete. expected (map) – 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.
    Each item in Expected represents an attribute name for Amazon DynamoDB
      to check, along with the following:

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

    - Exists - Causes Amazon DynamoDB to evaluate the value before

        > attempting a conditional operation:

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

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

    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.

    Parameters: | return_values (string) –

    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 is the default for ReturnValues .)

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

    Parameters: | return_consumed_capacity (string) – If set to TOTAL, ConsumedCapacity is included in the response; if set to NONE (the default), ConsumedCapacity is not included. return_item_collection_metrics (string) – 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..

  `delete_table`(table_name)

    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.

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

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

    Parameters: | table_name (string) – The name of the table to delete.

  `describe_table`(table_name)

    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.

    Parameters: | table_name (string) – The name of the table to describe.

  `get_item`(table_name, key, attributes_to_get=None, consistent_read=None, return_consumed_capacity=None)

    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.

    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.

    Parameters: | table_name (string) – The name of the table containing the requested item. key (map) – A map of attribute names to AttributeValue objects, representing the primary key of the item to retrieve. attributes_to_get (list) – 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. consistent_read (boolean) – If set to True, then the operation uses strongly consistent reads; otherwise, eventually consistent reads are used. return_consumed_capacity (string) – If set to TOTAL, ConsumedCapacity is included in the response; if set to NONE (the default), ConsumedCapacity is not included.

  `list_tables`(exclusive_start_table_name=None, limit=None)

    Returns an array of all the tables associated with the current account and endpoint.

    Parameters: | exclusive_start_table_name (string) – 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. limit (integer) – A maximum number of table names to return.

  `make_request`(action, body)
  `put_item`(table_name, item, expected=None, return_values=None, return_consumed_capacity=None, return_item_collection_metrics=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 primary key, the new item completely replaces the existing item. You can perform a conditional put (insert a new item if one with the specified primary key doesn’t exist), or replace an existing item if it has certain attribute values.

    In addition to putting an item, you can also return the item’s attribute values in the same operation, using the ReturnValues parameter.

    When you add an item, the primary key attribute(s) are the only required attributes. Attribute values cannot be null. String and binary type attributes must have lengths greater than zero. Set type attributes cannot be empty. Requests with empty values will be rejected with a ValidationException .

    You can request that PutItem return either a copy of the old item (before the update) or a copy of the new item (after the update). For more information, see the ReturnValues 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.

    For more information about using this API, see `Working with Items`_ in the Amazon DynamoDB Developer Guide.

    Parameters: | table_name (string) – The name of the table to contain the item. item (map) – 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.

    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.
    For more information about primary keys, see `Primary Key`_ in the
      Amazon DynamoDB Developer Guide.

    Each element in the Item map is an AttributeValue object.

    Parameters: | expected (map) – 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.
    Each item in Expected represents an attribute name for Amazon DynamoDB
      to check, along with the following:

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

    - Exists - Causes Amazon DynamoDB to evaluate the value before

        > attempting a conditional operation:

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

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

    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.

    Parameters: | return_values (string) –

    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 is the default for ReturnValues .)

    - ALL_OLD - If PutItem overwrote an attribute name-value pair, then

        the content of the old item is returned.

    Parameters: | return_consumed_capacity (string) – If set to TOTAL, ConsumedCapacity is included in the response; if set to NONE (the default), ConsumedCapacity is not included. return_item_collection_metrics (string) – 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..

  `query`(table_name, index_name=None, select=None, attributes_to_get=None, limit=None, consistent_read=None, key_conditions=None, scan_index_forward=None, exclusive_start_key=None, return_consumed_capacity=None)

    A Query operation directly accesses items from a table using the table primary key, or from an index using the index key. You must provide a specific hash key value. You can narrow the scope of the query by using comparison operators on the range key value, or on the index key. You can use the ScanIndexForward parameter to get results in forward or reverse order, by range key or by index key.

    Queries that do not return results consume the minimum read capacity units according to the type of read.

    If the total number of items meeting the query criteria exceeds the result set size limit of 1 MB, the query stops and results are returned to the user with a LastEvaluatedKey to continue the query in a subsequent operation. Unlike a Scan operation, a Query operation never returns an empty result set and a LastEvaluatedKey . The LastEvaluatedKey is only provided if the results exceed 1 MB, or if you have used Limit .

    To request a strongly consistent result, set ConsistentRead to true.

    Parameters: | table_name (string) – The name of the table containing the requested items. index_name (string) – The name of an index on the table to query. select (string) – The attributes to be returned in the result. You can retrieve all item attributes, specific item attributes, the count of matching items, or in the case of an index, some or all of the attributes projected into the index.

    - ALL_ATTRIBUTES: Returns all of the item attributes. For a table,

        this is the default. For an index, this mode causes Amazon DynamoDB to fetch the full item from the table for each matching item in the index. If the index is configured to project all item attributes, the matching items will not be fetched from the table. Fetching items from the table incurs additional throughput cost and latency.

    - ALL_PROJECTED_ATTRIBUTES: Allowed only when querying an index.

        Retrieves all attributes which have been projected into the index. If the index is configured to project all attributes, this is equivalent to specifying ALL_ATTRIBUTES .

    - COUNT: Returns the number of matching items, rather than the

        matching items themselves.

    - SPECIFIC_ATTRIBUTES : Returns only the attributes listed in

        AttributesToGet . This is equivalent to specifying AttributesToGet without specifying any value for Select . If you are querying an index and request only attributes that are projected into that index, the operation will read only the index and not the table. If any of the requested attributes are not projected into the index, Amazon DynamoDB will need to fetch each matching item from the table. This extra fetching incurs additional throughput cost and latency.

    When neither Select nor AttributesToGet are specified, Amazon DynamoDB
      defaults to ALL_ATTRIBUTES when accessing a table, and ALL_PROJECTED_ATTRIBUTES when accessing an index. You cannot use both Select and AttributesToGet together in a single request, unless the value for Select is SPECIFIC_ATTRIBUTES. (This usage is equivalent to specifying AttributesToGet without any value for Select .)

    Parameters: | attributes_to_get (list) – 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.

    If you are querying an index and request only attributes that are
      projected into that index, the operation will read only the index and not the table. If any of the requested attributes are not projected into the index, Amazon DynamoDB will need to fetch each matching item from the table. This extra fetching incurs additional throughput cost and latency.
    You cannot use both AttributesToGet and Select together in a Query
      request, unless the value for Select is SPECIFIC_ATTRIBUTES. (This usage is equivalent to specifying AttributesToGet without any value for Select .)

    Parameters: | limit (integer) – The maximum number of items to evaluate (not necessarily the number of matching items). If Amazon DynamoDB processes the number of items up to the limit while processing the results, it stops the operation and returns the matching values up to that point, and a LastEvaluatedKey to apply in a subsequent operation, so that you can pick up where you left off. Also, if the processed data set size exceeds 1 MB before Amazon DynamoDB reaches this limit, it stops the operation and returns the matching values up to the limit, and a LastEvaluatedKey to apply in a subsequent operation to continue the operation. For more information see `Query and Scan`_ in the Amazon DynamoDB Developer Guide. consistent_read (boolean) – If set to True, then the operation uses strongly consistent reads; otherwise, eventually consistent reads are used. key_conditions (map) –

    The selection criteria for the query.

    For a query on a table, you can only have conditions on the table
      primary key attributes. You must specify the hash key attribute name and value as an EQ condition. You can optionally specify a second condition, referring to the range key attribute.
    For a query on a secondary index, you can only have conditions on the
      index key attributes. You must specify the index hash attribute name and value as an EQ condition. You can optionally specify a second condition, referring to the index key range attribute.
    Multiple conditions are evaluated using “AND”; in other words, all of
      the conditions must be met in order for an item to appear in the results results.
    Each KeyConditions element consists of an attribute name to compare,
      along with the following:
    - AttributeValueList - One or more values to evaluate against the

        supplied attribute. This list contains exactly one value, except for a BETWEEN or IN comparison, in which case the list contains two values. 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, Amazon 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. For

        > example, equals, greater than, less than, etc. Valid comparison operators for Query: EQ | LE | LT | GE | GT | BEGINS_WITH | BETWEEN For information on specifying data types in JSON, see `JSON Data Format`_ in the Amazon DynamoDB Developer Guide. The following are descriptions of each comparison operator.

        - EQ : 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 equal {“NS”:[“6”, “2”, “1”]}.

        - 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”]}.

        - 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”]}.

        - 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”]}.

        - 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”]}.

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

        - 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”]}

    Parameters: | scan_index_forward (boolean) – Specifies ascending (true) or descending (false) traversal of the index. Amazon 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 String, the results are returned in order of ASCII character code values. For Binary, Amazon 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.

    Parameters: | exclusive_start_key (map) – 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.

    Parameters: | return_consumed_capacity (string) – If set to TOTAL, ConsumedCapacity is included in the response; if set to NONE (the default), ConsumedCapacity is not included.

  `scan`(table_name, attributes_to_get=None, limit=None, select=None, scan_filter=None, exclusive_start_key=None, return_consumed_capacity=None, total_segments=None, segment=None)

    The Scan operation returns one or more items and item attributes by accessing every item in the table. To have Amazon DynamoDB return fewer items, you can provide a ScanFilter .

    If the total number of scanned items exceeds the maximum data set size limit of 1 MB, the scan stops and results are returned to the user with a LastEvaluatedKey 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.

    The result set is eventually consistent.

    By default, Scan operations proceed sequentially; however, for faster performance on large tables, applications can request a parallel Scan by specifying the Segment and TotalSegments parameters. For more information, see `Parallel Scan`_ in the Amazon DynamoDB Developer Guide.

    Parameters: | table_name (string) – The name of the table containing the requested items. attributes_to_get (list) – 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. limit (integer) – The maximum number of items to evaluate (not necessarily the number of matching items). If Amazon DynamoDB processes the number of items up to the limit while processing the results, it stops the operation and returns the matching values up to that point, and a LastEvaluatedKey to apply in a subsequent operation, so that you can pick up where you left off. Also, if the processed data set size exceeds 1 MB before Amazon DynamoDB reaches this limit, it stops the operation and returns the matching values up to the limit, and a LastEvaluatedKey to apply in a subsequent operation to continue the operation. For more information see `Query and Scan`_ in the Amazon DynamoDB Developer Guide. select (string) – The attributes to be returned in the result. You can retrieve all item attributes, specific item attributes, the count of matching items, or in the case of an index, some or all of the attributes projected into the index.

    - ALL_ATTRIBUTES: Returns all of the item attributes. For a table,

        this is the default. For an index, this mode causes Amazon DynamoDB to fetch the full item from the table for each matching item in the index. If the index is configured to project all item attributes, the matching items will not be fetched from the table. Fetching items from the table incurs additional throughput cost and latency.

    - ALL_PROJECTED_ATTRIBUTES: Retrieves all attributes which have been

        projected into the index. If the index is configured to project all attributes, this is equivalent to specifying ALL_ATTRIBUTES .

    - COUNT: Returns the number of matching items, rather than the

        matching items themselves.

    - SPECIFIC_ATTRIBUTES : Returns only the attributes listed in

        AttributesToGet . This is equivalent to specifying AttributesToGet without specifying any value for Select . If you are querying an index and request only attributes that are projected into that index, the operation will read only the index and not the table. If any of the requested attributes are not projected into the index, Amazon DynamoDB will need to fetch each matching item from the table. This extra fetching incurs additional throughput cost and latency.

    When neither Select nor AttributesToGet are specified, Amazon DynamoDB
      defaults to ALL_ATTRIBUTES when accessing a table, and ALL_PROJECTED_ATTRIBUTES when accessing an index. You cannot use both Select and AttributesToGet together in a single request, unless the value for Select is SPECIFIC_ATTRIBUTES. (This usage is equivalent to specifying AttributesToGet without any value for Select .)

    Parameters: | scan_filter (map) –

    Evaluates the scan results and returns only the desired values.
      Multiple conditions are treated as “AND” operations: all conditions must be met to be included in the results.
    Each ScanConditions element consists of an attribute name to compare,
      along with the following:
    - AttributeValueList - One or more values to evaluate against the

        supplied attribute. This list contains exactly one value, except for a BETWEEN or IN comparison, in which case the list contains two values. 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, Amazon 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. For

        > example, equals, greater than, less than, etc. Valid comparison operators for Scan: EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN For information on specifying data types in JSON, see `JSON Data Format`_ in the Amazon DynamoDB Developer Guide. The following are descriptions of each comparison operator.

        - EQ : 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 equal {“NS”:[“6”, “2”, “1”]}.

        - NE : Not 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 equal {“NS”:[“6”, “2”, “1”]}.

        - 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”]}.

        - 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”]}.

        - 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”]}.

        - 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”]}.

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

        - 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”]}

    Parameters: | exclusive_start_key (map) – 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.
    In a parallel scan, a Scan request that includes ExclusiveStartKey must
      specify the same segment whose previous Scan returned the corresponding value of LastEvaluatedKey .

    Parameters: | return_consumed_capacity (string) – If set to TOTAL, ConsumedCapacity is included in the response; if set to NONE (the default), ConsumedCapacity is not included. total_segments (integer) – For a parallel Scan request, TotalSegments represents the total number of segments into which the Scan operation will be divided. The value of TotalSegments corresponds to the number of application workers that will perform the parallel scan. For example, if you want to scan a table using four application threads, you would specify a TotalSegments value of 4.

    The value for TotalSegments must be greater than or equal to 1, and
      less than or equal to 4096. If you specify a TotalSegments value of 1, the Scan will be sequential rather than parallel.

    If you specify TotalSegments , you must also specify Segment .

    Parameters: | segment (integer) – For a parallel Scan request, Segment identifies an individual segment to be scanned by an application worker.

    Segment IDs are zero-based, so the first segment is always 0. For
      example, if you want to scan a table using four application threads, the first thread would specify a Segment value of 0, the second thread would specify 1, and so on.
    The value of LastEvaluatedKey returned from a parallel Scan request
      must be used as ExclusiveStartKey with the same Segment ID in a subsequent Scan operation.
    The value for Segment must be greater than or equal to 0, and less than
      the value provided for TotalSegments .

    If you specify Segment , you must also specify TotalSegments .

  `update_item`(table_name, key, attribute_updates=None, expected=None, return_values=None, return_consumed_capacity=None, return_item_collection_metrics=None)

    Edits an existing item’s attributes, or inserts a new item if it does not already exist. You can put, delete, or add attribute values. You can also perform a conditional update (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).

    In addition to updating an item, you can also return the item’s attribute values in the same operation, using the ReturnValues parameter.

    Parameters: | table_name (string) – The name of the table containing the item to update. key (map) – The primary key that defines the item. Each element consists of an attribute name and a value for that attribute. attribute_updates (map) – The names of attributes to be modified, the action to perform on each, and the new value for each. If you are updating an attribute that is an index key attribute for any indexes on that table, the attribute type must match the index key type defined in the AttributesDefinition of the table description. You can use UpdateItem to update any non-key attributes.

    Attribute values cannot be null. String and binary type attributes must
      have lengths greater than zero. Set type attributes must not be empty. Requests with empty values will be rejected with a ValidationException .
    Each AttributeUpdates element consists of an attribute name to modify,
      along with the following:

    - Value - The new value, if applicable, for this attribute.

    - Action - Specifies how to perform the update. Valid values for Action

        > are PUT, DELETE, and ADD. The behavior depends on whether the specified primary key already exists in the table. If an item with the specified Key is found in the table:

        - PUT - Adds the specified attribute to the item. If the attribute

            already exists, it is replaced by the new value.

        - DELETE - If no value is specified, the attribute and its value are

            removed from the item. The data type of the specified value must match the existing value’s data type. 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 specified [a,c], then the final attribute value would be [b]. Specifying an empty set is an error.

        - ADD - If the attribute does not already exist, then the attribute

            > and its values are added to the item. 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 the Value is mathematically added to the existing attribute. If Value is a negative number, then it is subtracted from the existing attribute. If you use ADD to increment or decrement a number value for an item that doesn’t exist before the update, Amazon DynamoDB uses 0 as the initial value. In addition, if you use ADD to update an existing item, and intend to increment or decrement an attribute value which does not yet exist, Amazon DynamoDB uses 0 as the initial value. For example, suppose that the item you want to update does not yet have an attribute named itemcount , but you decide to ADD the number 3 to this attribute anyway, even though it currently does not exist. Amazon DynamoDB will create the itemcount attribute, set its initial value to 0, and finally add 3 to it. The result will be a new itemcount attribute in the item, with a value of 3.

            - If the existing data type is a set, and if the Value is also a set,

                then the Value is added to the existing set. (This is a set operation, not mathematical addition.) For example, if the attribute value was the set [1,2], and the ADD action specified [3], then the final attribute value would be [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 same holds true for number sets and binary sets.

          This action is only valid for an existing attribute whose data type is

            number or is a set. Do not use ADD for any other data types.

      If no item with the specified Key is found:

      > - PUT - Amazon DynamoDB creates a new item with the specified primary

      >     key, and then adds the attribute.

      > - DELETE - Nothing happens; there is no attribute to delete.

      > - ADD - Amazon DynamoDB creates an item with the supplied primary key

      >     and number (or set of numbers) for the attribute value. The only data types allowed are number and number set; no other data types can be specified.

    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.

    Parameters: | expected (map) – A map of attribute/condition pairs. This is the conditional block for the UpdateItem 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.
    Each item in Expected represents an attribute name for Amazon DynamoDB
      to check, along with the following:

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

    - Exists - Causes Amazon DynamoDB to evaluate the value before

        > attempting a conditional operation:

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

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

    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.

    Parameters: | return_values (string) –

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

    Parameters: | return_consumed_capacity (string) – If set to TOTAL, ConsumedCapacity is included in the response; if set to NONE (the default), ConsumedCapacity is not included. return_item_collection_metrics (string) – 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..

  `update_table`(table_name, provisioned_throughput=None, global_secondary_index_updates=None)

    Updates the provisioned throughput for the given table. Setting the throughput for a table helps you manage performance and is part of the provisioned throughput feature of Amazon DynamoDB.

    The provisioned throughput values can be upgraded or downgraded based on the maximums and minimums listed in the `Limits`_ section in the Amazon DynamoDB Developer Guide.

    The table must be in the ACTIVE state for this operation to succeed. UpdateTable is an asynchronous operation; while executing the operation, the table is in the UPDATING state. While the table is in the UPDATING state, the table still has the provisioned throughput from before the call. The new provisioned throughput setting is in effect only when the table returns to the ACTIVE state after the UpdateTable operation.

    You cannot add, modify or delete local secondary indexes using UpdateTable . Local secondary indexes can only be defined at table creation time.

    Parameters: | table_name (string) – The name of the table to be updated. provisioned_throughput (dict) – The provisioned throughput settings for the specified table. 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.

    Parameters: | global_secondary_index_updates (list) –

### boto.dynamodb2.exceptions

exception `boto.dynamodb2.exceptions.` `ConditionalCheckFailedException`(status, reason, body=None, *args)

exception `boto.dynamodb2.exceptions.` `DynamoDBError`

exception `boto.dynamodb2.exceptions.` `InternalServerError`(status, reason, body=None, *args)

exception `boto.dynamodb2.exceptions.` `ItemCollectionSizeLimitExceededException`(status, reason, body=None, *args)

exception `boto.dynamodb2.exceptions.` `ItemNotFound`

exception `boto.dynamodb2.exceptions.` `LimitExceededException`(status, reason, body=None, *args)

exception `boto.dynamodb2.exceptions.` `ProvisionedThroughputExceededException`(status, reason, body=None, *args)

exception `boto.dynamodb2.exceptions.` `QueryError`

exception `boto.dynamodb2.exceptions.` `ResourceInUseException`(status, reason, body=None, *args)

exception `boto.dynamodb2.exceptions.` `ResourceNotFoundException`(status, reason, body=None, *args)

exception `boto.dynamodb2.exceptions.` `UnknownFilterTypeError`

exception `boto.dynamodb2.exceptions.` `UnknownIndexFieldError`

exception `boto.dynamodb2.exceptions.` `UnknownSchemaFieldError`

exception `boto.dynamodb2.exceptions.` `ValidationException`(status, reason, body=None, *args)

### Navigation

- index
- modules |
- next |
- previous |
- boto v2.25.0 »