register_namespace async ¶

async def register_namespace(
    self,
    *,
    config_overrides: Optional[AsyncRedshiftClientConfig] = None,
    namespace_identifier: Optional[
        "capo_redshift.types.namespace_identifier_union.NamespaceIdentifierUnion"
    ] = None,
    consumer_identifiers: Optional[
        "capo_redshift.types.consumer_identifier_list.ConsumerIdentifierList"
    ] = None,
) -> "capo_redshift.types.register_namespace_output_message.RegisterNamespaceOutputMessage":
    """<p>Registers a cluster or serverless namespace to the Amazon Web Services Glue Data Catalog.</p>

    Args:
        namespace_identifier: <p>The unique identifier of the cluster or serverless namespace that you want to register. </p>
        consumer_identifiers: <p>An array containing the ID of the consumer account that you want to register the namespace to.</p>

    Raises:
        capo_redshift.errors.cluster_not_found_fault.ClusterNotFoundFault: <p>The <code>ClusterIdentifier</code> parameter does not refer to an existing cluster. </p>
        capo_redshift.errors.invalid_cluster_state_fault.InvalidClusterStateFault: <p>The specified cluster is not in the <code>available</code> state. </p>
        capo_redshift.errors.invalid_namespace_fault.InvalidNamespaceFault: <p>The namespace isn't valid because the namespace doesn't exist. Provide a valid namespace.</p>
        capo_redshift.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_redshift.types.register_namespace_input_message.RegisterNamespaceInputMessage]",
    ) -> AsyncOperationResponse[
        "capo_redshift.types.register_namespace_output_message.RegisterNamespaceOutputMessage"
    ]:
        import capo_redshift._operations.redshift_service_version20121201.register_namespace

        (
            output,
            http_response,
        ) = await capo_redshift._operations.redshift_service_version20121201.register_namespace.async_register_namespace(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("RegisterNamespace")
    )
    input_: capo_redshift.types.register_namespace_input_message.RegisterNamespaceInputMessage = {}
    if namespace_identifier is not None:
        input_["namespace_identifier"] = namespace_identifier
    if consumer_identifiers is not None:
        input_["consumer_identifiers"] = consumer_identifiers

    response = await aexecute_pipeline(
        AsyncOperationRequest(input=input_, options=options_),
        handler=_handler,
        interceptors=list(interceptors_),
    )
    await response.response.aclose()
    return response.output