417 lines
14 KiB
Python
417 lines
14 KiB
Python
# Copyright 2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"). You
|
|
# may not use this file except in compliance with the License. A copy of
|
|
# the License is located at
|
|
#
|
|
# http://aws.amazon.com/apache2.0/
|
|
#
|
|
# or in the "license" file accompanying this file. This file is
|
|
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
|
|
# ANY KIND, either express or implied. See the License for the specific
|
|
# language governing permissions and limitations under the License.
|
|
from collections import namedtuple
|
|
import functools
|
|
import re
|
|
|
|
from boto3.exceptions import DynamoDBOperationNotSupportedError
|
|
from boto3.exceptions import DynamoDBNeedsConditionError
|
|
from boto3.exceptions import DynamoDBNeedsKeyConditionError
|
|
|
|
|
|
ATTR_NAME_REGEX = re.compile(r'[^.\[\]]+(?![^\[]*\])')
|
|
|
|
|
|
class ConditionBase(object):
|
|
|
|
expression_format = ''
|
|
expression_operator = ''
|
|
has_grouped_values = False
|
|
|
|
def __init__(self, *values):
|
|
self._values = values
|
|
|
|
def __and__(self, other):
|
|
if not isinstance(other, ConditionBase):
|
|
raise DynamoDBOperationNotSupportedError('AND', other)
|
|
return And(self, other)
|
|
|
|
def __or__(self, other):
|
|
if not isinstance(other, ConditionBase):
|
|
raise DynamoDBOperationNotSupportedError('OR', other)
|
|
return Or(self, other)
|
|
|
|
def __invert__(self):
|
|
return Not(self)
|
|
|
|
def get_expression(self):
|
|
return {'format': self.expression_format,
|
|
'operator': self.expression_operator,
|
|
'values': self._values}
|
|
|
|
def __eq__(self, other):
|
|
if isinstance(other, type(self)):
|
|
if self._values == other._values:
|
|
return True
|
|
return False
|
|
|
|
def __ne__(self, other):
|
|
return not self.__eq__(other)
|
|
|
|
|
|
class AttributeBase(object):
|
|
def __init__(self, name):
|
|
self.name = name
|
|
|
|
def __and__(self, value):
|
|
raise DynamoDBOperationNotSupportedError('AND', self)
|
|
|
|
def __or__(self, value):
|
|
raise DynamoDBOperationNotSupportedError('OR', self)
|
|
|
|
def __invert__(self):
|
|
raise DynamoDBOperationNotSupportedError('NOT', self)
|
|
|
|
def eq(self, value):
|
|
"""Creates a condtion where the attribute is equal to the value.
|
|
|
|
:param value: The value that the attribute is equal to.
|
|
"""
|
|
return Equals(self, value)
|
|
|
|
def lt(self, value):
|
|
"""Creates a condtion where the attribute is less than the value.
|
|
|
|
:param value: The value that the attribute is less than.
|
|
"""
|
|
return LessThan(self, value)
|
|
|
|
def lte(self, value):
|
|
"""Creates a condtion where the attribute is less than or equal to the
|
|
value.
|
|
|
|
:param value: The value that the attribute is less than or equal to.
|
|
"""
|
|
return LessThanEquals(self, value)
|
|
|
|
def gt(self, value):
|
|
"""Creates a condtion where the attribute is greater than the value.
|
|
|
|
:param value: The value that the attribute is greater than.
|
|
"""
|
|
return GreaterThan(self, value)
|
|
|
|
def gte(self, value):
|
|
"""Creates a condtion where the attribute is greater than or equal to
|
|
the value.
|
|
|
|
:param value: The value that the attribute is greater than or equal to.
|
|
"""
|
|
return GreaterThanEquals(self, value)
|
|
|
|
def begins_with(self, value):
|
|
"""Creates a condtion where the attribute begins with the value.
|
|
|
|
:param value: The value that the attribute begins with.
|
|
"""
|
|
return BeginsWith(self, value)
|
|
|
|
def between(self, low_value, high_value):
|
|
"""Creates a condtion where the attribute is between the low value and
|
|
the high value.
|
|
|
|
:param low_value: The value that the attribute is greater than.
|
|
:param high_value: The value that the attribute is less than.
|
|
"""
|
|
return Between(self, low_value, high_value)
|
|
|
|
|
|
class ConditionAttributeBase(ConditionBase, AttributeBase):
|
|
"""This base class is for conditions that can have attribute methods.
|
|
|
|
One example is the Size condition. To complete a condition, you need
|
|
to apply another AttributeBase method like eq().
|
|
"""
|
|
def __init__(self, *values):
|
|
ConditionBase.__init__(self, *values)
|
|
# This is assuming the first value to the condition is the attribute
|
|
# in which can be used to generate its attribute base.
|
|
AttributeBase.__init__(self, values[0].name)
|
|
|
|
|
|
class ComparisonCondition(ConditionBase):
|
|
expression_format = '{0} {operator} {1}'
|
|
|
|
|
|
class Equals(ComparisonCondition):
|
|
expression_operator = '='
|
|
|
|
|
|
class NotEquals(ComparisonCondition):
|
|
expression_operator = '<>'
|
|
|
|
|
|
class LessThan(ComparisonCondition):
|
|
expression_operator = '<'
|
|
|
|
|
|
class LessThanEquals(ComparisonCondition):
|
|
expression_operator = '<='
|
|
|
|
|
|
class GreaterThan(ComparisonCondition):
|
|
expression_operator = '>'
|
|
|
|
|
|
class GreaterThanEquals(ComparisonCondition):
|
|
expression_operator = '>='
|
|
|
|
|
|
class In(ComparisonCondition):
|
|
expression_operator = 'IN'
|
|
has_grouped_values = True
|
|
|
|
|
|
class Between(ConditionBase):
|
|
expression_operator = 'BETWEEN'
|
|
expression_format = '{0} {operator} {1} AND {2}'
|
|
|
|
|
|
class BeginsWith(ConditionBase):
|
|
expression_operator = 'begins_with'
|
|
expression_format = '{operator}({0}, {1})'
|
|
|
|
|
|
class Contains(ConditionBase):
|
|
expression_operator = 'contains'
|
|
expression_format = '{operator}({0}, {1})'
|
|
|
|
|
|
class Size(ConditionAttributeBase):
|
|
expression_operator = 'size'
|
|
expression_format = '{operator}({0})'
|
|
|
|
|
|
class AttributeType(ConditionBase):
|
|
expression_operator = 'attribute_type'
|
|
expression_format = '{operator}({0}, {1})'
|
|
|
|
|
|
class AttributeExists(ConditionBase):
|
|
expression_operator = 'attribute_exists'
|
|
expression_format = '{operator}({0})'
|
|
|
|
|
|
class AttributeNotExists(ConditionBase):
|
|
expression_operator = 'attribute_not_exists'
|
|
expression_format = '{operator}({0})'
|
|
|
|
|
|
class And(ConditionBase):
|
|
expression_operator = 'AND'
|
|
expression_format = '({0} {operator} {1})'
|
|
|
|
|
|
class Or(ConditionBase):
|
|
expression_operator = 'OR'
|
|
expression_format = '({0} {operator} {1})'
|
|
|
|
|
|
class Not(ConditionBase):
|
|
expression_operator = 'NOT'
|
|
expression_format = '({operator} {0})'
|
|
|
|
|
|
class Key(AttributeBase):
|
|
pass
|
|
|
|
|
|
class Attr(AttributeBase):
|
|
"""Represents an DynamoDB item's attribute."""
|
|
def ne(self, value):
|
|
"""Creates a condtion where the attribute is not equal to the value
|
|
|
|
:param value: The value that the attribute is not equal to.
|
|
"""
|
|
return NotEquals(self, value)
|
|
|
|
def is_in(self, value):
|
|
"""Creates a condtion where the attribute is in the value,
|
|
|
|
:type value: list
|
|
:param value: The value that the attribute is in.
|
|
"""
|
|
return In(self, value)
|
|
|
|
def exists(self):
|
|
"""Creates a condtion where the attribute exists."""
|
|
return AttributeExists(self)
|
|
|
|
def not_exists(self):
|
|
"""Creates a condtion where the attribute does not exist."""
|
|
return AttributeNotExists(self)
|
|
|
|
def contains(self, value):
|
|
"""Creates a condition where the attribute contains the value.
|
|
|
|
:param value: The value the attribute contains.
|
|
"""
|
|
return Contains(self, value)
|
|
|
|
def size(self):
|
|
"""Creates a condition for the attribute size.
|
|
|
|
Note another AttributeBase method must be called on the returned
|
|
size condition to be a valid DynamoDB condition.
|
|
"""
|
|
return Size(self)
|
|
|
|
def attribute_type(self, value):
|
|
"""Creates a condition for the attribute type.
|
|
|
|
:param value: The type of the attribute.
|
|
"""
|
|
return AttributeType(self, value)
|
|
|
|
|
|
BuiltConditionExpression = namedtuple(
|
|
'BuiltConditionExpression',
|
|
['condition_expression', 'attribute_name_placeholders',
|
|
'attribute_value_placeholders']
|
|
)
|
|
|
|
|
|
class ConditionExpressionBuilder(object):
|
|
"""This class is used to build condition expressions with placeholders"""
|
|
def __init__(self):
|
|
self._name_count = 0
|
|
self._value_count = 0
|
|
self._name_placeholder = 'n'
|
|
self._value_placeholder = 'v'
|
|
|
|
def _get_name_placeholder(self):
|
|
return '#' + self._name_placeholder + str(self._name_count)
|
|
|
|
def _get_value_placeholder(self):
|
|
return ':' + self._value_placeholder + str(self._value_count)
|
|
|
|
def reset(self):
|
|
"""Resets the placeholder name and values"""
|
|
self._name_count = 0
|
|
self._value_count = 0
|
|
|
|
def build_expression(self, condition, is_key_condition=False):
|
|
"""Builds the condition expression and the dictionary of placeholders.
|
|
|
|
:type condition: ConditionBase
|
|
:param condition: A condition to be built into a condition expression
|
|
string with any necessary placeholders.
|
|
|
|
:type is_key_condition: Boolean
|
|
:param is_key_condition: True if the expression is for a
|
|
KeyConditionExpression. False otherwise.
|
|
|
|
:rtype: (string, dict, dict)
|
|
:returns: Will return a string representing the condition with
|
|
placeholders inserted where necessary, a dictionary of
|
|
placeholders for attribute names, and a dictionary of
|
|
placeholders for attribute values. Here is a sample return value:
|
|
|
|
('#n0 = :v0', {'#n0': 'myattribute'}, {':v1': 'myvalue'})
|
|
"""
|
|
if not isinstance(condition, ConditionBase):
|
|
raise DynamoDBNeedsConditionError(condition)
|
|
attribute_name_placeholders = {}
|
|
attribute_value_placeholders = {}
|
|
condition_expression = self._build_expression(
|
|
condition, attribute_name_placeholders,
|
|
attribute_value_placeholders, is_key_condition=is_key_condition)
|
|
return BuiltConditionExpression(
|
|
condition_expression=condition_expression,
|
|
attribute_name_placeholders=attribute_name_placeholders,
|
|
attribute_value_placeholders=attribute_value_placeholders
|
|
)
|
|
|
|
def _build_expression(self, condition, attribute_name_placeholders,
|
|
attribute_value_placeholders, is_key_condition):
|
|
expression_dict = condition.get_expression()
|
|
replaced_values = []
|
|
for value in expression_dict['values']:
|
|
# Build the necessary placeholders for that value.
|
|
# Placeholders are built for both attribute names and values.
|
|
replaced_value = self._build_expression_component(
|
|
value, attribute_name_placeholders,
|
|
attribute_value_placeholders, condition.has_grouped_values,
|
|
is_key_condition)
|
|
replaced_values.append(replaced_value)
|
|
# Fill out the expression using the operator and the
|
|
# values that have been replaced with placeholders.
|
|
return expression_dict['format'].format(
|
|
*replaced_values, operator=expression_dict['operator'])
|
|
|
|
def _build_expression_component(self, value, attribute_name_placeholders,
|
|
attribute_value_placeholders,
|
|
has_grouped_values, is_key_condition):
|
|
# Continue to recurse if the value is a ConditionBase in order
|
|
# to extract out all parts of the expression.
|
|
if isinstance(value, ConditionBase):
|
|
return self._build_expression(
|
|
value, attribute_name_placeholders,
|
|
attribute_value_placeholders, is_key_condition)
|
|
# If it is not a ConditionBase, we can recurse no further.
|
|
# So we check if it is an attribute and add placeholders for
|
|
# its name
|
|
elif isinstance(value, AttributeBase):
|
|
if is_key_condition and not isinstance(value, Key):
|
|
raise DynamoDBNeedsKeyConditionError(
|
|
'Attribute object %s is of type %s. '
|
|
'KeyConditionExpression only supports Attribute objects '
|
|
'of type Key' % (value.name, type(value)))
|
|
return self._build_name_placeholder(
|
|
value, attribute_name_placeholders)
|
|
# If it is anything else, we treat it as a value and thus placeholders
|
|
# are needed for the value.
|
|
else:
|
|
return self._build_value_placeholder(
|
|
value, attribute_value_placeholders, has_grouped_values)
|
|
|
|
def _build_name_placeholder(self, value, attribute_name_placeholders):
|
|
attribute_name = value.name
|
|
# Figure out which parts of the attribute name that needs replacement.
|
|
attribute_name_parts = ATTR_NAME_REGEX.findall(attribute_name)
|
|
|
|
# Add a temporary placeholder for each of these parts.
|
|
placeholder_format = ATTR_NAME_REGEX.sub('%s', attribute_name)
|
|
str_format_args = []
|
|
for part in attribute_name_parts:
|
|
name_placeholder = self._get_name_placeholder()
|
|
self._name_count += 1
|
|
str_format_args.append(name_placeholder)
|
|
# Add the placeholder and value to dictionary of name placeholders.
|
|
attribute_name_placeholders[name_placeholder] = part
|
|
# Replace the temporary placeholders with the designated placeholders.
|
|
return placeholder_format % tuple(str_format_args)
|
|
|
|
def _build_value_placeholder(self, value, attribute_value_placeholders,
|
|
has_grouped_values=False):
|
|
# If the values are grouped, we need to add a placeholder for
|
|
# each element inside of the actual value.
|
|
if has_grouped_values:
|
|
placeholder_list = []
|
|
for v in value:
|
|
value_placeholder = self._get_value_placeholder()
|
|
self._value_count += 1
|
|
placeholder_list.append(value_placeholder)
|
|
attribute_value_placeholders[value_placeholder] = v
|
|
# Assuming the values are grouped by parenthesis.
|
|
# IN is the currently the only one that uses this so it maybe
|
|
# needed to be changed in future.
|
|
return '(' + ', '.join(placeholder_list) + ')'
|
|
# Otherwise, treat the value as a single value that needs only
|
|
# one placeholder.
|
|
else:
|
|
value_placeholder = self._get_value_placeholder()
|
|
self._value_count += 1
|
|
attribute_value_placeholders[value_placeholder] = value
|
|
return value_placeholder
|