def scan(self,
limit=None,
segment=None,
total_segments=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)
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'
"""
results = ResultSet()
kwargs = filter_kwargs.copy()
kwargs.update({
'limit': limit,
'segment': segment,
'total_segments': total_segments,
})
results.to_call(self._scan, **kwargs)
return results
def scan(self, limit=None, segment=None, total_segments=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)
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'
"""
results = ResultSet()
kwargs = filter_kwargs.copy()
kwargs.update({
'limit': limit,
'segment': segment,
'total_segments': total_segments,
})
results.to_call(self._scan, **kwargs)
return results
def query(self,
limit=None,
index=None,
reverse=False,
consistent=False,
attributes=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.
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'
"""
if self.schema:
if len(self.schema) == 1 and len(filter_kwargs) <= 1:
raise exceptions.QueryError(
"You must specify more than one key to filter on.")
if attributes is not None:
select = 'SPECIFIC_ATTRIBUTES'
else:
select = None
results = ResultSet()
kwargs = filter_kwargs.copy()
kwargs.update({
'limit': limit,
'index': index,
'reverse': reverse,
'consistent': consistent,
'select': select,
'attributes_to_get': attributes
})
results.to_call(self._query, **kwargs)
return results
def query(self, limit=None, index=None, reverse=False, consistent=False, attributes=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.
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'
"""
if self.schema:
if len(self.schema) == 1 and len(filter_kwargs) <= 1:
raise exceptions.QueryError("You must specify more than one key to filter on.")
if attributes is not None:
select = "SPECIFIC_ATTRIBUTES"
else:
select = None
results = ResultSet()
kwargs = filter_kwargs.copy()
kwargs.update(
{
"limit": limit,
"index": index,
"reverse": reverse,
"consistent": consistent,
"select": select,
"attributes_to_get": attributes,
}
)
results.to_call(self._query, **kwargs)
return results
def scan(self, 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'
"""
results = ResultSet(
max_page_size=max_page_size
)
kwargs = filter_kwargs.copy()
kwargs.update({
'limit': limit,
'segment': segment,
'total_segments': total_segments,
'attributes': attributes,
})
results.to_call(self._scan, **kwargs)
return results
def scan(self,
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'
"""
results = ResultSet(max_page_size=max_page_size)
kwargs = filter_kwargs.copy()
kwargs.update({
'limit': limit,
'segment': segment,
'total_segments': total_segments,
'attributes': attributes,
})
results.to_call(self._scan, **kwargs)
return results
