docs: def patch_relationship(self, session, json_data, api_type, obj_id,
                             rel_key):
          """
          Replacement of relationship values.
  
          :param session: SQLAlchemy session
          :param json_data: Request JSON Data
          :param api_type: Type of the resource
          :param obj_id: ID of the resource
          :param rel_key: Key of the relationship to fetch
          """
          model = self._fetch_model(api_type)
          resource = self._fetch_resource(session, api_type, obj_id,
                                          Permissions.EDIT)
          if rel_key not in resource.__jsonapi_map_to_py__.keys():
              raise RelationshipNotFoundError(resource, resource, rel_key)
          py_key = resource.__jsonapi_map_to_py__[rel_key]
          relationship = self._get_relationship(resource, py_key,
                                                Permissions.EDIT)
          self._check_json_data(json_data)
  
          session.add(resource)
          remote_side = relationship.back_populates
          try:
              if relationship.direction == MANYTOONE:
                  if not isinstance(json_data['data'], dict)\
                          and json_data['data'] is not None:
                      raise ValidationError('Provided data must be a hash.')
  
                  related = getattr(resource, relationship.key)
                  check_permission(related, None, Permissions.EDIT)
                  check_permission(related, remote_side, Permissions.EDIT)
  
                  setter = get_rel_desc(resource, relationship.key,
                                        RelationshipActions.SET)
  
                  if json_data['data'] is None:
                      setter(resource, None)
                  else:
                      to_relate = self._fetch_resource(
                          session, json_data['data']['type'],
                          json_data['data']['id'], Permissions.EDIT)
                      check_permission(to_relate, remote_side, Permissions.EDIT)
                      setter(resource, to_relate)
              else:
                  if not isinstance(json_data['data'], list):
                      raise ValidationError('Provided data must be an array.')
  
                  related = getattr(resource, relationship.key)
  
                  remover = get_rel_desc(resource, relationship.key,
                                         RelationshipActions.DELETE)
                  appender = get_rel_desc(resource, relationship.key,
                                          RelationshipActions.APPEND)
                  for item in related:
                      check_permission(item, None, Permissions.EDIT)
                      remote = item.__mapper__.relationships[remote_side]
                      if remote.direction == MANYTOONE:
                          check_permission(item, remote_side, Permissions.EDIT)
                      else:
                          check_permission(item, remote_side, Permissions.DELETE)
                      remover(resource, item)
  
                  for item in json_data['data']:
                      to_relate = self._fetch_resource(
                          session, item['type'], item['id'], Permissions.EDIT)
                      remote = to_relate.__mapper__.relationships[remote_side]
  
                      if remote.direction == MANYTOONE:
                          check_permission(to_relate, remote_side,
                                           Permissions.EDIT)
                      else:
                          check_permission(to_relate, remote_side,
                                           Permissions.CREATE)
                      appender(resource, to_relate)
              session.commit()
          except KeyError:
              raise ValidationError('Incompatible Type')
  
          return self.get_relationship(session, {}, model.__jsonapi_type__,
                                       resource.id, rel_key)