def parse_key_schema(cls, key_def_list_json): hash_key_attr_name = None range_key_attr_name = None for key_def in key_def_list_json: key_attr_name_json = key_def.pop(Props.ATTRIBUTE_NAME, None) validation.validate_attr_name(key_attr_name_json) key_type_json = key_def.pop(Props.KEY_TYPE, None) if key_type_json == Values.KEY_TYPE_HASH: if hash_key_attr_name is not None: raise exception.ValidationError( _("Only one 'HASH' key is allowed")) hash_key_attr_name = key_attr_name_json elif key_type_json == Values.KEY_TYPE_RANGE: if range_key_attr_name is not None: raise exception.ValidationError( _("Only one 'RANGE' key is allowed")) range_key_attr_name = key_attr_name_json else: raise exception.ValidationError( _("Only 'RANGE' or 'HASH' key types are allowed, but " "'%(key_type)s' is found"), key_type=key_type_json) validation.validate_unexpected_props(key_def, "key_definition") if hash_key_attr_name is None: raise exception.ValidationError(_("HASH key is missing")) if range_key_attr_name: return (hash_key_attr_name, range_key_attr_name) return (hash_key_attr_name,)
def parse_attribute_conditions(cls, attribute_conditions_json, condition_class=models.IndexedCondition): attribute_conditions = {} for (attr_name, condition_json) in ( attribute_conditions_json.iteritems()): validation.validate_attr_name(attr_name) validation.validate_object(condition_json, attr_name) condition_type_json = ( condition_json.pop(Props.COMPARISON_OPERATOR, None) ) attribute_list = condition_json.pop(Props.ATTRIBUTE_VALUE_LIST, None) condition_args = [] if attribute_list: validation.validate_list_of_objects( attribute_list, Props.ATTRIBUTE_VALUE_LIST ) for typed_attribute_value in attribute_list: condition_args.append( cls.parse_typed_attr_value(typed_attribute_value) ) attribute_conditions[attr_name] = ( cls.parse_attribute_condition( condition_type_json, condition_args, condition_class ) ) validation.validate_unexpected_props(condition_json, attr_name) return attribute_conditions
def parse_attribute_updates(cls, attribute_updates_json): attribute_updates = {} for attr, attr_update_json in attribute_updates_json.iteritems(): validation.validate_attr_name(attr) validation.validate_object(attr_update_json, attr) action_type_json = attr_update_json.pop(Props.ACTION, None) validation.validate_string(action_type_json, Props.ACTION) value_json = attr_update_json.pop(Props.VALUE, None) if value_json: validation.validate_object(value_json, Props.VALUE) value = cls.parse_typed_attr_value(value_json) else: value = None update_action = models.UpdateItemAction(action_type_json, value) validation.validate_unexpected_props(attr_update_json, attr) attribute_updates[attr] = update_action return attribute_updates
def parse_batch_get_request_items(cls, request_items_json): request_list = [] for table_name, request_body in request_items_json.iteritems(): validation.validate_table_name(table_name) validation.validate_object(request_body, table_name) consistent = request_body.pop(Props.CONSISTENT_READ, False) validation.validate_boolean(consistent, Props.CONSISTENT_READ) attributes_to_get = request_body.pop(Props.ATTRIBUTES_TO_GET, None) if attributes_to_get is not None: attributes_to_get = validation.validate_set( attributes_to_get, Props.ATTRIBUTES_TO_GET) for attr_name in attributes_to_get: validation.validate_attr_name(attr_name) keys = request_body.pop(Props.KEYS, None) validation.validate_list(keys, Props.KEYS) validation.validate_unexpected_props(request_body, table_name) for key in keys: key_attribute_map = cls.parse_item_attributes(key) request_list.append( models.GetItemRequest(table_name, key_attribute_map, attributes_to_get, consistent=consistent)) return request_list
def parse_key_schema(cls, key_def_list_json): hash_key_attr_name = None range_key_attr_name = None for key_def in key_def_list_json: key_attr_name_json = key_def.pop(Props.ATTRIBUTE_NAME, None) validation.validate_attr_name(key_attr_name_json) key_type_json = key_def.pop(Props.KEY_TYPE, None) if key_type_json == Values.KEY_TYPE_HASH: if hash_key_attr_name is not None: raise exception.ValidationError( _("Only one 'HASH' key is allowed")) hash_key_attr_name = key_attr_name_json elif key_type_json == Values.KEY_TYPE_RANGE: if range_key_attr_name is not None: raise exception.ValidationError( _("Only one 'RANGE' key is allowed")) range_key_attr_name = key_attr_name_json else: raise exception.ValidationError(_( "Only 'RANGE' or 'HASH' key types are allowed, but " "'%(key_type)s' is found"), key_type=key_type_json) validation.validate_unexpected_props(key_def, "key_definition") if hash_key_attr_name is None: raise exception.ValidationError(_("HASH key is missing")) if range_key_attr_name: return (hash_key_attr_name, range_key_attr_name) return (hash_key_attr_name, )
def parse_attribute_conditions(cls, attribute_conditions_json, condition_class=models.IndexedCondition): attribute_conditions = {} for (attr_name, condition_json) in (attribute_conditions_json.iteritems()): validation.validate_attr_name(attr_name) validation.validate_object(condition_json, attr_name) condition_type_json = (condition_json.pop( Props.COMPARISON_OPERATOR, None)) attribute_list = condition_json.pop(Props.ATTRIBUTE_VALUE_LIST, None) condition_args = [] if attribute_list: validation.validate_list_of_objects(attribute_list, Props.ATTRIBUTE_VALUE_LIST) for typed_attribute_value in attribute_list: condition_args.append( cls.parse_typed_attr_value(typed_attribute_value)) attribute_conditions[attr_name] = (cls.parse_attribute_condition( condition_type_json, condition_args, condition_class)) validation.validate_unexpected_props(condition_json, attr_name) return attribute_conditions
def parse_item_attributes(cls, item_attributes_json): item = {} for (attr_name_json, typed_attr_value_json) in (item_attributes_json.iteritems()): validation.validate_attr_name(attr_name_json) validation.validate_object(typed_attr_value_json, attr_name_json) item[attr_name_json] = cls.parse_typed_attr_value( typed_attr_value_json) return item
def parse_item_attributes(cls, item_attributes_json): item = {} for (attr_name_json, typed_attr_value_json) in ( item_attributes_json.iteritems()): validation.validate_attr_name(attr_name_json) validation.validate_object(typed_attr_value_json, attr_name_json) item[attr_name_json] = cls.parse_typed_attr_value( typed_attr_value_json ) return item
def process_request(self, req, body, project_id, table_name): utils.check_project_id(req.context, project_id) req.context.tenant = project_id with probe.Probe(__name__ + '.validate'): validation.validate_object(body, "body") # get attributes_to_get attributes_to_get = body.pop(parser.Props.ATTRIBUTES_TO_GET, None) if attributes_to_get: attributes_to_get = validation.validate_set( attributes_to_get, parser.Props.ATTRIBUTES_TO_GET ) for attr_name in attributes_to_get: validation.validate_attr_name(attr_name) select_type = models.SelectType.specific_attributes( attributes_to_get ) else: select_type = models.SelectType.all() key = body.pop(parser.Props.KEY, None) validation.validate_object(key, parser.Props.KEY) # parse consistent_read consistent_read = body.pop(parser.Props.CONSISTENT_READ, False) validation.validate_boolean(consistent_read, parser.Props.CONSISTENT_READ) validation.validate_unexpected_props(body, "body") # parse key_attributes key_attributes = parser.Parser.parse_item_attributes(key) # format conditions to get item indexed_condition_map = { name: [models.IndexedCondition.eq(value)] for name, value in key_attributes.iteritems() } # get item result = storage.select_item( req.context, table_name, indexed_condition_map, select_type=select_type, limit=2, consistent=consistent_read) # format response if result.count == 0: return {} response = { parser.Props.ITEM: parser.Parser.format_item_attributes( result.items[0]) } return response
def parse_attribute_definition(cls, attr_def_json): attr_name_json = attr_def_json.pop(Props.ATTRIBUTE_NAME, None) attr_type_json = attr_def_json.pop(Props.ATTRIBUTE_TYPE, None) validation.validate_attr_name(attr_name_json) storage_type = models.AttributeType(attr_type_json) validation.validate_unexpected_props(attr_def_json, "attribute_definition") return attr_name_json, storage_type
def parse_attribute_definition(cls, attr_def_json): attr_name_json = attr_def_json.pop(Props.ATTRIBUTE_NAME, None) attr_type_json = attr_def_json.pop(Props.ATTRIBUTE_TYPE, None) validation.validate_attr_name(attr_name_json) storage_type = models.AttributeType(attr_type_json) validation.validate_unexpected_props( attr_def_json, "attribute_definition" ) return attr_name_json, storage_type
def get_item(req, project_id, table_name): """The Getitem operation returns an item with the given primary key. """ with probe.Probe(__name__ + '.validate'): body = req.json_body validation.validate_object(body, "body") # get attributes_to_get attributes_to_get = body.pop(parser.Props.ATTRIBUTES_TO_GET, None) if attributes_to_get: attributes_to_get = validation.validate_set( attributes_to_get, parser.Props.ATTRIBUTES_TO_GET ) for attr_name in attributes_to_get: validation.validate_attr_name(attr_name) select_type = models.SelectType.specific_attributes( attributes_to_get ) else: select_type = models.SelectType.all() key = body.pop(parser.Props.KEY, None) validation.validate_object(key, parser.Props.KEY) # parse consistent_read consistent_read = body.pop(parser.Props.CONSISTENT_READ, False) validation.validate_boolean(consistent_read, parser.Props.CONSISTENT_READ) validation.validate_unexpected_props(body, "body") # parse key_attributes key_attributes = parser.Parser.parse_item_attributes(key) # get item result = storage.get_item( project_id, table_name, key_attributes, select_type=select_type, consistent=consistent_read) # format response if result.count == 0: return {} response = { parser.Props.ITEM: parser.Parser.format_item_attributes( result.items[0]) } return response
def process_request(self, req, body, project_id, table_name): with probe.Probe(__name__ + '.validate'): validation.validate_object(body, "body") # get attributes_to_get attributes_to_get = body.pop(parser.Props.ATTRIBUTES_TO_GET, None) if attributes_to_get: attributes_to_get = validation.validate_set( attributes_to_get, parser.Props.ATTRIBUTES_TO_GET) for attr_name in attributes_to_get: validation.validate_attr_name(attr_name) select_type = models.SelectType.specific_attributes( attributes_to_get) else: select_type = models.SelectType.all() key = body.pop(parser.Props.KEY, None) validation.validate_object(key, parser.Props.KEY) # parse consistent_read consistent_read = body.pop(parser.Props.CONSISTENT_READ, False) validation.validate_boolean(consistent_read, parser.Props.CONSISTENT_READ) validation.validate_unexpected_props(body, "body") # parse key_attributes key_attributes = parser.Parser.parse_item_attributes(key) # get item result = storage.get_item(req.context, table_name, key_attributes, select_type=select_type, consistent=consistent_read) # format response if result.count == 0: return {} response = { parser.Props.ITEM: parser.Parser.format_item_attributes(result.items[0]) } return response
def parse_expected_attribute_conditions( cls, expected_attribute_conditions_json): expected_attribute_conditions = {} for (attr_name_json, condition_json) in ( expected_attribute_conditions_json.iteritems()): validation.validate_attr_name(attr_name_json) validation.validate_object(condition_json, attr_name_json) if len(condition_json) != 1: raise exception.ValidationError( _("Can't recognize attribute expected condition format: " "'%(attr)s'"), attr=json.dumps(condition_json) ) (condition_type, condition_value) = condition_json.popitem() validation.validate_string(condition_type, "condition type") if condition_type == Props.VALUE: validation.validate_object(condition_value, Props.VALUE) expected_attribute_conditions[attr_name_json] = [ models.ExpectedCondition.eq( cls.parse_typed_attr_value(condition_value) ) ] elif condition_type == Props.EXISTS: validation.validate_boolean(condition_value, Props.EXISTS) expected_attribute_conditions[attr_name_json] = [ models.ExpectedCondition.not_null() if condition_value else models.ExpectedCondition.null() ] else: raise exception.ValidationError( _("Unsupported condition type found: %(condition_type)s"), condition_type=condition_type ) return expected_attribute_conditions
def parse_expected_attribute_conditions( cls, expected_attribute_conditions_json): expected_attribute_conditions = {} for (attr_name_json, condition_json) in ( expected_attribute_conditions_json.iteritems()): validation.validate_attr_name(attr_name_json) validation.validate_object(condition_json, attr_name_json) if len(condition_json) != 1: raise ValidationError( _("Can't recognize attribute expected condition format: " "'%(attr)s'"), attr=json.dumps(condition_json) ) (condition_type, condition_value) = condition_json.popitem() validation.validate_string(condition_type, "condition type") if condition_type == Props.VALUE: validation.validate_object(condition_value, Props.VALUE) expected_attribute_conditions[attr_name_json] = [ ExpectedCondition.eq( cls.parse_typed_attr_value(condition_value) ) ] elif condition_type == Props.EXISTS: validation.validate_boolean(condition_value, Props.EXISTS) expected_attribute_conditions[attr_name_json] = [ ExpectedCondition.not_null() if condition_value else ExpectedCondition.null() ] else: raise ValidationError( _("Unsupported condition type found: %(condition_type)s"), condition_type=condition_type ) return expected_attribute_conditions
def parse_batch_get_request_items(cls, request_items_json): request_list = [] for table_name, request_body in request_items_json.iteritems(): validation.validate_table_name(table_name) validation.validate_object(request_body, table_name) consistent = request_body.pop(Props.CONSISTENT_READ, False) validation.validate_boolean(consistent, Props.CONSISTENT_READ) attributes_to_get = request_body.pop( Props.ATTRIBUTES_TO_GET, None ) if attributes_to_get is not None: attributes_to_get = validation.validate_set( attributes_to_get, Props.ATTRIBUTES_TO_GET ) for attr_name in attributes_to_get: validation.validate_attr_name(attr_name) keys = request_body.pop(Props.KEYS, None) validation.validate_list(keys, Props.KEYS) validation.validate_unexpected_props(request_body, table_name) for key in keys: key_attribute_map = cls.parse_item_attributes(key) request_list.append( models.GetItemRequest( table_name, key_attribute_map, attributes_to_get, consistent=consistent ) ) return request_list
def scan(self, req, body, project_id, table_name): utils.check_project_id(req.context, project_id) req.context.tenant = project_id with probe.Probe(__name__ + '.validation'): validation.validate_object(body, "body") # get attributes_to_get attributes_to_get = body.pop(parser.Props.ATTRIBUTES_TO_GET, None) if attributes_to_get: validation.validate_list(attributes_to_get, parser.Props.ATTRIBUTES_TO_GET) for attr_name in attributes_to_get: validation.validate_attr_name(attr_name) select = body.pop(parser.Props.SELECT, None) if select is None: if attributes_to_get: select = models.SelectType.SELECT_TYPE_SPECIFIC else: select = models.SelectType.SELECT_TYPE_ALL else: validation.validate_string(select, parser.Props.SELECT) select_type = models.SelectType(select, attributes_to_get) limit = body.pop(parser.Props.LIMIT, None) if limit is not None: limit = validation.validate_integer(limit, parser.Props.LIMIT, min_val=0) # parse exclusive_start_key_attributes exclusive_start_key_attributes_json = body.pop( parser.Props.EXCLUSIVE_START_KEY, None) if exclusive_start_key_attributes_json is not None: validation.validate_object(exclusive_start_key_attributes_json, parser.Props.EXCLUSIVE_START_KEY) exclusive_start_key_attributes = ( parser.Parser.parse_item_attributes( exclusive_start_key_attributes_json ) ) else: exclusive_start_key_attributes = None scan_filter_json = body.pop(parser.Props.SCAN_FILTER, None) if scan_filter_json: validation.validate_object(scan_filter_json, parser.Props.SCAN_FILTER) condition_map = parser.Parser.parse_attribute_conditions( scan_filter_json, condition_class=ScanCondition ) else: condition_map = None total_segments = body.pop(parser.Props.TOTAL_SEGMENTS, 1) total_segments = validation.validate_integer( total_segments, parser.Props.TOTAL_SEGMENTS, min_val=1, max_val=4096 ) segment = body.pop(parser.Props.SEGMENT, 0) segment = validation.validate_integer( segment, parser.Props.SEGMENT, min_val=0, max_val=total_segments ) validation.validate_unexpected_props(body, "body") result = storage.scan( req.context, table_name, condition_map, attributes_to_get=attributes_to_get, limit=limit, exclusive_start_key=exclusive_start_key_attributes) response = { parser.Props.COUNT: result.count, parser.Props.SCANNED_COUNT: result.scanned_count } if not select_type.is_count: response[parser.Props.ITEMS] = [ parser.Parser.format_item_attributes(row) for row in result.items] if result.last_evaluated_key: response[parser.Props.LAST_EVALUATED_KEY] = ( parser.Parser.format_item_attributes( result.last_evaluated_key ) ) return response
def scan(self, req, body, project_id, table_name): utils.check_project_id(req.context, project_id) req.context.tenant = project_id with probe.Probe(__name__ + '.validation'): validation.validate_object(body, "body") # get attributes_to_get attributes_to_get = body.pop(parser.Props.ATTRIBUTES_TO_GET, None) if attributes_to_get: validation.validate_list(attributes_to_get, parser.Props.ATTRIBUTES_TO_GET) for attr_name in attributes_to_get: validation.validate_attr_name(attr_name) select = body.pop(parser.Props.SELECT, None) if select is None: if attributes_to_get: select = models.SelectType.SELECT_TYPE_SPECIFIC else: select = models.SelectType.SELECT_TYPE_ALL else: validation.validate_string(select, parser.Props.SELECT) select_type = models.SelectType(select, attributes_to_get) limit = body.pop(parser.Props.LIMIT, None) if limit is not None: limit = validation.validate_integer(limit, parser.Props.LIMIT, min_val=0) # parse exclusive_start_key_attributes exclusive_start_key_attributes_json = body.pop( parser.Props.EXCLUSIVE_START_KEY, None) if exclusive_start_key_attributes_json is not None: validation.validate_object(exclusive_start_key_attributes_json, parser.Props.EXCLUSIVE_START_KEY) exclusive_start_key_attributes = ( parser.Parser.parse_item_attributes( exclusive_start_key_attributes_json)) else: exclusive_start_key_attributes = None scan_filter_json = body.pop(parser.Props.SCAN_FILTER, None) if scan_filter_json: validation.validate_object(scan_filter_json, parser.Props.SCAN_FILTER) condition_map = parser.Parser.parse_attribute_conditions( scan_filter_json, condition_class=ScanCondition) else: condition_map = None total_segments = body.pop(parser.Props.TOTAL_SEGMENTS, 1) total_segments = validation.validate_integer( total_segments, parser.Props.TOTAL_SEGMENTS, min_val=1, max_val=4096) segment = body.pop(parser.Props.SEGMENT, 0) segment = validation.validate_integer(segment, parser.Props.SEGMENT, min_val=0, max_val=total_segments) validation.validate_unexpected_props(body, "body") result = storage.scan( req.context, table_name, condition_map, attributes_to_get=attributes_to_get, limit=limit, exclusive_start_key=exclusive_start_key_attributes) response = { parser.Props.COUNT: result.count, parser.Props.SCANNED_COUNT: result.scanned_count } if not select_type.is_count: response[parser.Props.ITEMS] = [ parser.Parser.format_item_attributes(row) for row in result.items ] if result.last_evaluated_key: response[parser.Props.LAST_EVALUATED_KEY] = ( parser.Parser.format_item_attributes( result.last_evaluated_key)) return response
def query(self, req, body, project_id, table_name): with probe.Probe(__name__ + '.validation'): validation.validate_object(body, "body") # get attributes_to_get attributes_to_get = body.pop(parser.Props.ATTRIBUTES_TO_GET, None) if attributes_to_get is not None: validation.validate_list(attributes_to_get, parser.Props.ATTRIBUTES_TO_GET) for attr_name in attributes_to_get: validation.validate_attr_name(attr_name) index_name = body.pop(parser.Props.INDEX_NAME, None) if index_name is not None: validation.validate_index_name(index_name) select = body.pop(parser.Props.SELECT, None) if select is None: if attributes_to_get: select = models.SelectType.SELECT_TYPE_SPECIFIC else: if index_name is not None: select = models.SelectType.SELECT_TYPE_ALL_PROJECTED else: select = models.SelectType.SELECT_TYPE_ALL else: validation.validate_string(select, parser.Props.SELECT) select_type = models.SelectType(select, attributes_to_get) # parse exclusive_start_key_attributes exclusive_start_key_attributes_json = body.pop( parser.Props.EXCLUSIVE_START_KEY, None) if exclusive_start_key_attributes_json is not None: validation.validate_object(exclusive_start_key_attributes_json, parser.Props.EXCLUSIVE_START_KEY) exclusive_start_key_attributes = ( parser.Parser.parse_item_attributes( exclusive_start_key_attributes_json)) else: exclusive_start_key_attributes = None # parse indexed_condition_map key_conditions = body.pop(parser.Props.KEY_CONDITIONS, None) validation.validate_object(key_conditions, parser.Props.KEY_CONDITIONS) indexed_condition_map = parser.Parser.parse_attribute_conditions( key_conditions, condition_class=IndexedCondition) # TODO(dukhlov): # it would be nice to validate given table_name, key_attributes and # attributes_to_get to schema expectation consistent_read = body.pop(parser.Props.CONSISTENT_READ, False) validation.validate_boolean(consistent_read, parser.Props.CONSISTENT_READ) limit = body.pop(parser.Props.LIMIT, None) if limit is not None: limit = validation.validate_integer(limit, parser.Props.LIMIT, min_val=0) scan_forward = body.pop(parser.Props.SCAN_INDEX_FORWARD, None) if scan_forward is not None: validation.validate_boolean(scan_forward, parser.Props.SCAN_INDEX_FORWARD) order_type = (models.ORDER_TYPE_ASC if scan_forward else models.ORDER_TYPE_DESC) else: order_type = None validation.validate_unexpected_props(body, "body") # select item result = storage.query( req.context, table_name, indexed_condition_map, select_type=select_type, index_name=index_name, limit=limit, consistent=consistent_read, order_type=order_type, exclusive_start_key=exclusive_start_key_attributes) # format response if select_type.type == models.SelectType.SELECT_TYPE_COUNT: response = {parser.Props.COUNT: result.count} else: response = { parser.Props.COUNT: result.count, parser.Props.ITEMS: [ parser.Parser.format_item_attributes(row) for row in result.items ] } if limit == result.count: response[parser.Props.LAST_EVALUATED_KEY] = ( parser.Parser.format_item_attributes( result.last_evaluated_key)) return response
def query(self, req, body, project_id, table_name): utils.check_project_id(req.context, project_id) req.context.tenant = project_id with probe.Probe(__name__ + '.validation'): validation.validate_object(body, "body") # get attributes_to_get attributes_to_get = body.pop(parser.Props.ATTRIBUTES_TO_GET, None) if attributes_to_get: validation.validate_list(attributes_to_get, parser.Props.ATTRIBUTES_TO_GET) for attr_name in attributes_to_get: validation.validate_attr_name(attr_name) index_name = body.pop(parser.Props.INDEX_NAME, None) if index_name is not None: validation.validate_index_name(index_name) select = body.pop(parser.Props.SELECT, None) if select is None: if attributes_to_get: select = models.SelectType.SELECT_TYPE_SPECIFIC else: if index_name is not None: select = models.SelectType.SELECT_TYPE_ALL_PROJECTED else: select = models.SelectType.SELECT_TYPE_ALL else: validation.validate_string(select, parser.Props.SELECT) select_type = models.SelectType(select, attributes_to_get) # parse exclusive_start_key_attributes exclusive_start_key_attributes_json = body.pop( parser.Props.EXCLUSIVE_START_KEY, None) if exclusive_start_key_attributes_json is not None: validation.validate_object(exclusive_start_key_attributes_json, parser.Props.EXCLUSIVE_START_KEY) exclusive_start_key_attributes = ( parser.Parser.parse_item_attributes( exclusive_start_key_attributes_json ) ) else: exclusive_start_key_attributes = None # parse indexed_condition_map key_conditions = body.pop(parser.Props.KEY_CONDITIONS, None) validation.validate_object(key_conditions, parser.Props.KEY_CONDITIONS) indexed_condition_map = parser.Parser.parse_attribute_conditions( key_conditions, condition_class=IndexedCondition ) # TODO(dukhlov): # it would be nice to validate given table_name, key_attributes and # attributes_to_get to schema expectation consistent_read = body.pop(parser.Props.CONSISTENT_READ, False) validation.validate_boolean(consistent_read, parser.Props.CONSISTENT_READ) limit = body.pop(parser.Props.LIMIT, None) if limit is not None: limit = validation.validate_integer(limit, parser.Props.LIMIT, min_val=0) scan_forward = body.pop(parser.Props.SCAN_INDEX_FORWARD, None) if scan_forward is not None: validation.validate_boolean(scan_forward, parser.Props.SCAN_INDEX_FORWARD) order_type = ( models.ORDER_TYPE_ASC if scan_forward else models.ORDER_TYPE_DESC ) else: order_type = None validation.validate_unexpected_props(body, "body") # select item result = storage.select_item( req.context, table_name, indexed_condition_map, select_type=select_type, index_name=index_name, limit=limit, consistent=consistent_read, order_type=order_type, exclusive_start_key=exclusive_start_key_attributes ) # format response if select_type.type == models.SelectType.SELECT_TYPE_COUNT: response = { parser.Props.COUNT: result.count } else: response = { parser.Props.COUNT: result.count, parser.Props.ITEMS: [ parser.Parser.format_item_attributes(row) for row in result.items ] } if limit == result.count: response[parser.Props.LAST_EVALUATED_KEY] = ( parser.Parser.format_item_attributes( result.last_evaluated_key) ) return response