def _validate_vdict_type(self, translator):
        if self.KEY_COL not in translator:
            raise exception.InvalidParamException(
                "Param (%s) must be in translator" % self.KEY_COL)
        if self.VAL_COL not in translator:
            raise exception.InvalidParamException(
                "Param (%s) must be in translator" % self.VAL_COL)

        subtranslator = translator[self.TRANSLATOR]
        self._validate_translator(subtranslator)
    def _get_schema_vdict(self, translator, schema):
        tablename = translator[self.TABLE_NAME]
        parent_key = translator.get(self.PARENT_KEY, None)
        id_col = translator.get(self.ID_COL, None)
        key_col = translator[self.KEY_COL]
        value_col = translator[self.VAL_COL]
        subtrans = translator[self.TRANSLATOR]

        self._get_schema(subtrans, schema)
        if tablename in schema:
            raise exception.InvalidParamException(
                "table %s already in schema" % tablename)
        # Construct the schema for this table.
        new_schema = (key_col, )
        if id_col:
            new_schema = (id_col, ) + new_schema
        elif parent_key:
            parent_col_name = translator.get(self.PARENT_COL_NAME,
                                             self.PARENT_KEY_COL_NAME)
            new_schema = (parent_col_name, ) + new_schema
        if self.PARENT_KEY not in subtrans:
            new_schema = new_schema + (value_col, )

        schema[tablename] = new_schema
        return schema
    def _get_schema_hdict(self, translator, schema):
        tablename = translator[self.TABLE_NAME]
        parent_key = translator.get(self.PARENT_KEY, None)
        id_col = translator.get(self.ID_COL, None)
        field_translators = translator[self.FIELD_TRANSLATORS]

        columns = []
        if id_col is not None:
            columns.append(id_col)
        elif parent_key is not None:
            parent_col_name = translator.get(self.PARENT_COL_NAME,
                                             self.PARENT_KEY_COL_NAME)
            columns.append(parent_col_name)

        for field_translator in field_translators:
            col = field_translator.get(self.COL,
                                       field_translator[self.FIELDNAME])
            subtranslator = field_translator[self.TRANSLATOR]
            if self.PARENT_KEY not in subtranslator:
                columns.append(col)
            self._get_schema(subtranslator, schema)

        if tablename in schema:
            raise exception.InvalidParamException(
                "table %s already in schema" % tablename)
        schema[tablename] = tuple(columns)
        return schema
    def _validate_non_value_type_properties(self, translator):
        """HDICT, VDICT, and LIST types all share some common properties."""
        parent_key = translator.get(self.PARENT_KEY)
        id_col = translator.get(self.ID_COL)

        # Specifying both parent-key and id_col in a translator is not valid,
        # one should use one or the other but not both.
        if parent_key and id_col:
            raise exception.InvalidParamException(
                'Specify at most one of %s or %s' %
                (self.PARENT_KEY, self.ID_COL))
    def _validate_translator(self, translator):
        translation_type = translator.get(self.TRANSLATION_TYPE)

        if self.TRANSLATION_TYPE not in translator:
            raise exception.InvalidParamException(
                "Param (%s) must be in translator" % self.TRANSLATION_TYPE)

        # check that translation_type is valid
        if translation_type not in self.VALID_TRANSLATION_TYPES:
            msg = ("Translation Type %s not a valid transltion-type %s" %
                   (translation_type, self.VALID_TRANSLATION_TYPES))
            raise exception.InvalidTranslationType(msg)
        self._validate_by_translation_type(translator)
    def _get_schema_list(self, translator, schema):
        tablename = translator[self.TABLE_NAME]
        parent_key = translator.get(self.PARENT_KEY, None)
        id_col = translator.get(self.ID_COL, None)
        value_col = translator[self.VAL_COL]
        trans = translator[self.TRANSLATOR]

        self._get_schema(trans, schema)
        if tablename in schema:
            raise exception.InvalidParamException(
                "table %s already in schema" % tablename)
        if id_col:
            schema[tablename] = (id_col, value_col)
        elif parent_key:
            parent_col_name = translator.get(self.PARENT_COL_NAME,
                                             self.PARENT_KEY_COL_NAME)
            schema[tablename] = (parent_col_name, value_col)
        else:
            schema[tablename] = (value_col, )
        return schema
 def check_translation_type(cls, params):
     if cls.TRANSLATION_TYPE not in params:
         raise exception.InvalidParamException(
             "Param (%s) must be in translator" % cls.TRANSLATION_TYPE)
 def check_params(cls, params, valid_params):
     diff = sorted(set(params).difference(valid_params))
     if diff:
         err = ("Params (%s) are invalid.  Valid params: %s" %
                (', '.join(diff), str(valid_params)))
         raise exception.InvalidParamException(err)