Exemplo n.º 1
0
    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,)
Exemplo n.º 2
0
    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
Exemplo n.º 3
0
    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
Exemplo n.º 4
0
    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
Exemplo n.º 5
0
    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, )
Exemplo n.º 6
0
    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
Exemplo n.º 7
0
    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
Exemplo n.º 8
0
    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
Exemplo n.º 9
0
    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
Exemplo n.º 10
0
    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
Exemplo n.º 11
0
    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
Exemplo n.º 12
0
    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
Exemplo n.º 13
0
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
Exemplo n.º 14
0
    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
Exemplo n.º 15
0
    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
Exemplo n.º 16
0
    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
Exemplo n.º 17
0
    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
Exemplo n.º 18
0
    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
Exemplo n.º 19
0
    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
Exemplo n.º 20
0
    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
Exemplo n.º 21
0
    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