snowflake.core.cortex.search_service.CortexSearchServiceApi¶

class snowflake.core.cortex.search_service.CortexSearchServiceApi(root, resource_class, sproc_client)¶

Bases: object

NOTE: This class is auto generated by OpenAPI Generator.

Do not edit the class manually.

Attributes

api_client¶

Methods

create_cortex_search_service(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], create_cortex_search_service_request: CreateCortexSearchServiceRequest, create_mode: Annotated[StrictStr | None, Field(description='Parameter allowing support for different modes of resource creation. Possible values include: - `errorIfExists`: Throws an error if you try to create a resource that already exists. - `orReplace`: Automatically replaces the existing resource with the current one. - `ifNotExists`: Creates a new resource when an alter is requested for a non-existent resource.')] = None, async_req: Literal[False] = False, **kwargs) → SuccessResponse¶

create_cortex_search_service(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], create_cortex_search_service_request: CreateCortexSearchServiceRequest, create_mode: Annotated[StrictStr | None, Field(description='Parameter allowing support for different modes of resource creation. Possible values include: - `errorIfExists`: Throws an error if you try to create a resource that already exists. - `orReplace`: Automatically replaces the existing resource with the current one. - `ifNotExists`: Creates a new resource when an alter is requested for a non-existent resource.')] = None, async_req: bool = False, **kwargs) → SuccessResponse | Future[SuccessResponse]

Create a cortex search service # noqa: E501

Create a cortex search service, with standard create modifiers as query parameters. See the Cortex Search Service component definition for what is required to be provided in the request body. # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> future = api.create_cortex_search_service(
...     database, var_schema, create_cortex_search_service_request, create_mode, async_req=True
... )
>>> result = future.result()
:param database: Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases. (required)
:type database: str
:param var_schema: Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database. (required)
:type var_schema: str
:param create_cortex_search_service_request: (required)
:type create_cortex_search_service_request: CreateCortexSearchServiceRequest
:param create_mode: Parameter allowing support for different modes of resource creation. Possible values include: - `errorIfExists`: Throws an error if you try to create a resource that already exists. - `orReplace`: Automatically replaces the existing resource with the current one. - `ifNotExists`: Creates a new resource when an alter is requested for a non-existent resource.
:type create_mode: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
                         be returned without reading/decoding response
                         data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
                         number provided, it will be total request
                         timeout. It can also be a pair (tuple) of
                         (connection, read) timeouts.
:return: Returns the result object.
         If the method is called asynchronously,
         returns a Future object representing the execution of the method.
:rtype: Union[SuccessResponse, Future[SuccessResponse]]

create_cortex_search_service_with_http_info(database: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.', metadata=[Strict(strict=True)])], var_schema: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.', metadata=[Strict(strict=True)])], create_cortex_search_service_request: CreateCortexSearchServiceRequest, create_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Parameter allowing support for different modes of resource creation. Possible values include: - `errorIfExists`: Throws an error if you try to create a resource that already exists. - `orReplace`: Automatically replaces the existing resource with the current one. - `ifNotExists`: Creates a new resource when an alter is requested for a non-existent resource.')] = None, **kwargs)¶

Create a cortex search service # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> future = api.create_cortex_search_service_with_http_info(
...     database, var_schema, create_cortex_search_service_request, create_mode, async_req=True
... )
>>> result = future.result()
:param database: Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases. (required)
:type database: str
:param var_schema: Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database. (required)
:type var_schema: str
:param create_cortex_search_service_request: (required)
:type create_cortex_search_service_request: CreateCortexSearchServiceRequest
:param create_mode: Parameter allowing support for different modes of resource creation. Possible values include: - `errorIfExists`: Throws an error if you try to create a resource that already exists. - `orReplace`: Automatically replaces the existing resource with the current one. - `ifNotExists`: Creates a new resource when an alter is requested for a non-existent resource.
:type create_mode: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
                               and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
                         be returned without reading/decoding response
                         data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
                         number provided, it will be total request
                         timeout. It can also be a pair (tuple) of
                         (connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
                      request; this effectively ignores the authentication
                      in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
         If the method is called asynchronously,
         returns a Future object representing the execution of the method.
:rtype: tuple(Union[SuccessResponse, Future[SuccessResponse]], status_code(int), headers(HTTPHeaderDict))

delete_cortex_search_service(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], name: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the resource.')], if_exists: Annotated[StrictBool | None, Field(description="Parameter that specifies how to handle the request for a resource that does not exist: - `true`: The endpoint does not throw an error if the resource does not exist. It returns a 200 success response, but does not take any action on the resource. - `false`: The endpoint throws an error if the resource doesn't exist.")] = None, async_req: Literal[False] = False, **kwargs) → SuccessResponse¶

delete_cortex_search_service(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], name: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the resource.')], if_exists: Annotated[StrictBool | None, Field(description="Parameter that specifies how to handle the request for a resource that does not exist: - `true`: The endpoint does not throw an error if the resource does not exist. It returns a 200 success response, but does not take any action on the resource. - `false`: The endpoint throws an error if the resource doesn't exist.")] = None, async_req: bool = False, **kwargs) → SuccessResponse | Future[SuccessResponse]

Delete a cortex search service # noqa: E501

Delete a cortex search service with the given name. If ifExists is used, the operation will succeed even if the object does not exist. Otherwise, there will be a failure if the drop is unsuccessful. # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> future = api.delete_cortex_search_service(database, var_schema, name, if_exists, async_req=True)
>>> result = future.result()
:param database: Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases. (required)
:type database: str
:param var_schema: Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database. (required)
:type var_schema: str
:param name: Identifier (i.e. name) for the resource. (required)
:type name: str
:param if_exists: Parameter that specifies how to handle the request for a resource that does not exist: - `true`: The endpoint does not throw an error if the resource does not exist. It returns a 200 success response, but does not take any action on the resource. - `false`: The endpoint throws an error if the resource doesn't exist.
:type if_exists: bool
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
                         be returned without reading/decoding response
                         data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
                         number provided, it will be total request
                         timeout. It can also be a pair (tuple) of
                         (connection, read) timeouts.
:return: Returns the result object.
         If the method is called asynchronously,
         returns a Future object representing the execution of the method.
:rtype: Union[SuccessResponse, Future[SuccessResponse]]

delete_cortex_search_service_with_http_info(database: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.', metadata=[Strict(strict=True)])], var_schema: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.', metadata=[Strict(strict=True)])], name: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the resource.', metadata=[Strict(strict=True)])], if_exists: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Parameter that specifies how to handle the request for a resource that does not exist: - `true`: The endpoint does not throw an error if the resource does not exist. It returns a 200 success response, but does not take any action on the resource. - `false`: The endpoint throws an error if the resource doesn't exist.")] = None, **kwargs)¶

Delete a cortex search service # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> future = api.delete_cortex_search_service_with_http_info(
...     database, var_schema, name, if_exists, async_req=True
... )
>>> result = future.result()
:param database: Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases. (required)
:type database: str
:param var_schema: Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database. (required)
:type var_schema: str
:param name: Identifier (i.e. name) for the resource. (required)
:type name: str
:param if_exists: Parameter that specifies how to handle the request for a resource that does not exist: - `true`: The endpoint does not throw an error if the resource does not exist. It returns a 200 success response, but does not take any action on the resource. - `false`: The endpoint throws an error if the resource doesn't exist.
:type if_exists: bool
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
                               and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
                         be returned without reading/decoding response
                         data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
                         number provided, it will be total request
                         timeout. It can also be a pair (tuple) of
                         (connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
                      request; this effectively ignores the authentication
                      in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
         If the method is called asynchronously,
         returns a Future object representing the execution of the method.
:rtype: tuple(Union[SuccessResponse, Future[SuccessResponse]], status_code(int), headers(HTTPHeaderDict))

deserialize(response, response_type)¶

Deserializes response into an object.

Parameters:

response – RESTResponse object to be deserialized.
response_type – class literal for deserialized object, or string of class name.

Returns:

deserialized object.

fetch_cortex_search_service(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], name: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the resource.')], async_req: Literal[False] = False, **kwargs) → CortexSearchService¶

fetch_cortex_search_service(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], name: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the resource.')], async_req: Literal[True] = True, **kwargs) → Future[CortexSearchService]

fetch_cortex_search_service(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], name: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the resource.')], async_req: bool = False, **kwargs) → CortexSearchService | Future[CortexSearchService]

Fetch a cortex search service. # noqa: E501

Fetch a Cortex Search Service. # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> future = api.fetch_cortex_search_service(database, var_schema, name, async_req=True)
>>> result = future.result()
:param database: Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases. (required)
:type database: str
:param var_schema: Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database. (required)
:type var_schema: str
:param name: Identifier (i.e. name) for the resource. (required)
:type name: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
                         be returned without reading/decoding response
                         data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
                         number provided, it will be total request
                         timeout. It can also be a pair (tuple) of
                         (connection, read) timeouts.
:return: Returns the result object.
         If the method is called asynchronously,
         returns a Future object representing the execution of the method.
:rtype: Union[CortexSearchService, Future[CortexSearchService]]

fetch_cortex_search_service_with_http_info(database: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.', metadata=[Strict(strict=True)])], var_schema: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.', metadata=[Strict(strict=True)])], name: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the resource.', metadata=[Strict(strict=True)])], **kwargs)¶

Fetch a cortex search service. # noqa: E501

Fetch a Cortex Search Service. # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> future = api.fetch_cortex_search_service_with_http_info(database, var_schema, name, async_req=True)
>>> result = future.result()
:param database: Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases. (required)
:type database: str
:param var_schema: Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database. (required)
:type var_schema: str
:param name: Identifier (i.e. name) for the resource. (required)
:type name: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
                               and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
                         be returned without reading/decoding response
                         data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
                         number provided, it will be total request
                         timeout. It can also be a pair (tuple) of
                         (connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
                      request; this effectively ignores the authentication
                      in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
         If the method is called asynchronously,
         returns a Future object representing the execution of the method.
:rtype: tuple(Union[CortexSearchService, Future[CortexSearchService]], status_code(int), headers(HTTPHeaderDict))

list_cortex_search_services(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], like: Annotated[StrictStr | None, Field(description='Parameter to filter the command output by resource name. Uses case-insensitive pattern matching, with support for SQL wildcard characters.')] = None, from_name: Annotated[StrictStr | None, Field(description='Parameter to enable fetching rows only following the first row whose object name matches the specified string. Case-sensitive and does not have to be the full name.')] = None, show_limit: Annotated[Annotated[int, Field(le=10000, strict=True, ge=1)] | None, Field(description='Parameter to limit the maximum number of rows returned by a command.')] = None, async_req: Literal[False] = False, **kwargs) → Iterable[CortexSearchService]¶

list_cortex_search_services(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], like: Annotated[StrictStr | None, Field(description='Parameter to filter the command output by resource name. Uses case-insensitive pattern matching, with support for SQL wildcard characters.')] = None, from_name: Annotated[StrictStr | None, Field(description='Parameter to enable fetching rows only following the first row whose object name matches the specified string. Case-sensitive and does not have to be the full name.')] = None, show_limit: Annotated[Annotated[int, Field(le=10000, strict=True, ge=1)] | None, Field(description='Parameter to limit the maximum number of rows returned by a command.')] = None, async_req: Literal[True] = True, **kwargs) → Future[Iterable[CortexSearchService]]

list_cortex_search_services(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], like: Annotated[StrictStr | None, Field(description='Parameter to filter the command output by resource name. Uses case-insensitive pattern matching, with support for SQL wildcard characters.')] = None, from_name: Annotated[StrictStr | None, Field(description='Parameter to enable fetching rows only following the first row whose object name matches the specified string. Case-sensitive and does not have to be the full name.')] = None, show_limit: Annotated[Annotated[int, Field(le=10000, strict=True, ge=1)] | None, Field(description='Parameter to limit the maximum number of rows returned by a command.')] = None, async_req: bool = False, **kwargs) → Iterable[CortexSearchService] | Future[Iterable[CortexSearchService]]

List cortex search services # noqa: E501

Lists the cortex search services under the database and schema. # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> future = api.list_cortex_search_services(
...     database, var_schema, like, from_name, show_limit, async_req=True
... )
>>> result = future.result()
:param database: Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases. (required)
:type database: str
:param var_schema: Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database. (required)
:type var_schema: str
:param like: Parameter to filter the command output by resource name. Uses case-insensitive pattern matching, with support for SQL wildcard characters.
:type like: str
:param from_name: Parameter to enable fetching rows only following the first row whose object name matches the specified string. Case-sensitive and does not have to be the full name.
:type from_name: str
:param show_limit: Parameter to limit the maximum number of rows returned by a command.
:type show_limit: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
                         be returned without reading/decoding response
                         data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
                         number provided, it will be total request
                         timeout. It can also be a pair (tuple) of
                         (connection, read) timeouts.
:return: Returns the result object.
         If the method is called asynchronously,
         returns a Future object representing the execution of the method.
:rtype: Union[Iterable[CortexSearchService], Future[Iterable[CortexSearchService]]]

list_cortex_search_services_with_http_info(database: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.', metadata=[Strict(strict=True)])], var_schema: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.', metadata=[Strict(strict=True)])], like: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Parameter to filter the command output by resource name. Uses case-insensitive pattern matching, with support for SQL wildcard characters.')] = None, from_name: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Parameter to enable fetching rows only following the first row whose object name matches the specified string. Case-sensitive and does not have to be the full name.')] = None, show_limit: Annotated[Annotated[int, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), Ge(ge=1), Le(le=10000)])] | None, FieldInfo(annotation=NoneType, required=True, description='Parameter to limit the maximum number of rows returned by a command.')] = None, **kwargs)¶

List cortex search services # noqa: E501

Lists the cortex search services under the database and schema. # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> future = api.list_cortex_search_services_with_http_info(
...     database, var_schema, like, from_name, show_limit, async_req=True
... )
>>> result = future.result()
:param database: Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases. (required)
:type database: str
:param var_schema: Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database. (required)
:type var_schema: str
:param like: Parameter to filter the command output by resource name. Uses case-insensitive pattern matching, with support for SQL wildcard characters.
:type like: str
:param from_name: Parameter to enable fetching rows only following the first row whose object name matches the specified string. Case-sensitive and does not have to be the full name.
:type from_name: str
:param show_limit: Parameter to limit the maximum number of rows returned by a command.
:type show_limit: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
                               and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
                         be returned without reading/decoding response
                         data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
                         number provided, it will be total request
                         timeout. It can also be a pair (tuple) of
                         (connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
                      request; this effectively ignores the authentication
                      in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
         If the method is called asynchronously,
         returns a Future object representing the execution of the method.
:rtype: tuple(Union[Iterable[CortexSearchService], Future[Iterable[CortexSearchService]]], status_code(int), headers(HTTPHeaderDict))

query_cortex_search_service(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], service_name: Annotated[StrictStr, Field(description='The name of the Cortex Search Service.')], query_request: QueryRequest | None = None, async_req: Literal[False] = False, **kwargs) → QueryResponse¶

query_cortex_search_service(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], service_name: Annotated[StrictStr, Field(description='The name of the Cortex Search Service.')], query_request: QueryRequest | None = None, async_req: bool = False, **kwargs) → QueryResponse | Future[QueryResponse]

Query a Cortex Search Service. # noqa: E501

Query a Cortex Search Service to get search results. # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> future = api.query_cortex_search_service(
...     database, var_schema, service_name, query_request, async_req=True
... )
>>> result = future.result()
:param database: Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases. (required)
:type database: str
:param var_schema: Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database. (required)
:type var_schema: str
:param service_name: The name of the Cortex Search Service. (required)
:type service_name: str
:param query_request:
:type query_request: QueryRequest
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
                         be returned without reading/decoding response
                         data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
                         number provided, it will be total request
                         timeout. It can also be a pair (tuple) of
                         (connection, read) timeouts.
:return: Returns the result object.
         If the method is called asynchronously,
         returns a Future object representing the execution of the method.
:rtype: Union[QueryResponse, Future[QueryResponse]]

query_cortex_search_service_with_http_info(database: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.', metadata=[Strict(strict=True)])], var_schema: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.', metadata=[Strict(strict=True)])], service_name: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The name of the Cortex Search Service.')], query_request: QueryRequest | None = None, **kwargs)¶

Query a Cortex Search Service. # noqa: E501

Query a Cortex Search Service to get search results. # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> future = api.query_cortex_search_service_with_http_info(
...     database, var_schema, service_name, query_request, async_req=True
... )
>>> result = future.result()
:param database: Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases. (required)
:type database: str
:param var_schema: Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database. (required)
:type var_schema: str
:param service_name: The name of the Cortex Search Service. (required)
:type service_name: str
:param query_request:
:type query_request: QueryRequest
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
                               and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
                         be returned without reading/decoding response
                         data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
                         number provided, it will be total request
                         timeout. It can also be a pair (tuple) of
                         (connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
                      request; this effectively ignores the authentication
                      in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
         If the method is called asynchronously,
         returns a Future object representing the execution of the method.
:rtype: tuple(Union[QueryResponse, Future[QueryResponse]], status_code(int), headers(HTTPHeaderDict))

resume_cortex_search_service(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], name: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the resource.')], if_exists: Annotated[StrictBool | None, Field(description="Parameter that specifies how to handle the request for a resource that does not exist: - `true`: The endpoint does not throw an error if the resource does not exist. It returns a 200 success response, but does not take any action on the resource. - `false`: The endpoint throws an error if the resource doesn't exist.")] = None, target: Annotated[StrictStr | None, Field(description='Query parameter that identifies the target to which suspension or resumption of the cortex search service should be applied.')] = None, async_req: Literal[False] = False, **kwargs) → SuccessResponse¶

resume_cortex_search_service(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], name: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the resource.')], if_exists: Annotated[StrictBool | None, Field(description="Parameter that specifies how to handle the request for a resource that does not exist: - `true`: The endpoint does not throw an error if the resource does not exist. It returns a 200 success response, but does not take any action on the resource. - `false`: The endpoint throws an error if the resource doesn't exist.")] = None, target: Annotated[StrictStr | None, Field(description='Query parameter that identifies the target to which suspension or resumption of the cortex search service should be applied.')] = None, async_req: bool = False, **kwargs) → SuccessResponse | Future[SuccessResponse]

Resume the cortex search service # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> future = api.resume_cortex_search_service(
...     database, var_schema, name, if_exists, target, async_req=True
... )
>>> result = future.result()
:param database: Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases. (required)
:type database: str
:param var_schema: Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database. (required)
:type var_schema: str
:param name: Identifier (i.e. name) for the resource. (required)
:type name: str
:param if_exists: Parameter that specifies how to handle the request for a resource that does not exist: - `true`: The endpoint does not throw an error if the resource does not exist. It returns a 200 success response, but does not take any action on the resource. - `false`: The endpoint throws an error if the resource doesn't exist.
:type if_exists: bool
:param target: Query parameter that identifies the target to which suspension or resumption of the cortex search service should be applied.
:type target: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
                         be returned without reading/decoding response
                         data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
                         number provided, it will be total request
                         timeout. It can also be a pair (tuple) of
                         (connection, read) timeouts.
:return: Returns the result object.
         If the method is called asynchronously,
         returns a Future object representing the execution of the method.
:rtype: Union[SuccessResponse, Future[SuccessResponse]]

resume_cortex_search_service_with_http_info(database: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.', metadata=[Strict(strict=True)])], var_schema: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.', metadata=[Strict(strict=True)])], name: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the resource.', metadata=[Strict(strict=True)])], if_exists: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Parameter that specifies how to handle the request for a resource that does not exist: - `true`: The endpoint does not throw an error if the resource does not exist. It returns a 200 success response, but does not take any action on the resource. - `false`: The endpoint throws an error if the resource doesn't exist.")] = None, target: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Query parameter that identifies the target to which suspension or resumption of the cortex search service should be applied.')] = None, **kwargs)¶

Resume the cortex search service # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> future = api.resume_cortex_search_service_with_http_info(
...     database, var_schema, name, if_exists, target, async_req=True
... )
>>> result = future.result()
:param database: Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases. (required)
:type database: str
:param var_schema: Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database. (required)
:type var_schema: str
:param name: Identifier (i.e. name) for the resource. (required)
:type name: str
:param if_exists: Parameter that specifies how to handle the request for a resource that does not exist: - `true`: The endpoint does not throw an error if the resource does not exist. It returns a 200 success response, but does not take any action on the resource. - `false`: The endpoint throws an error if the resource doesn't exist.
:type if_exists: bool
:param target: Query parameter that identifies the target to which suspension or resumption of the cortex search service should be applied.
:type target: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
                               and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
                         be returned without reading/decoding response
                         data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
                         number provided, it will be total request
                         timeout. It can also be a pair (tuple) of
                         (connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
                      request; this effectively ignores the authentication
                      in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
         If the method is called asynchronously,
         returns a Future object representing the execution of the method.
:rtype: tuple(Union[SuccessResponse, Future[SuccessResponse]], status_code(int), headers(HTTPHeaderDict))

send_feedback(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], name: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the resource.')], send_feedback_request: SendFeedbackRequest, async_req: Literal[False] = False, **kwargs) → SuccessResponse¶

send_feedback(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], name: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the resource.')], send_feedback_request: SendFeedbackRequest, async_req: bool = False, **kwargs) → SuccessResponse | Future[SuccessResponse]

send_feedback # noqa: E501

Send user feedback for a Cortex Search result # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> future = api.send_feedback(database, var_schema, name, send_feedback_request, async_req=True)
>>> result = future.result()
:param database: Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases. (required)
:type database: str
:param var_schema: Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database. (required)
:type var_schema: str
:param name: Identifier (i.e. name) for the resource. (required)
:type name: str
:param send_feedback_request: (required)
:type send_feedback_request: SendFeedbackRequest
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
                         be returned without reading/decoding response
                         data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
                         number provided, it will be total request
                         timeout. It can also be a pair (tuple) of
                         (connection, read) timeouts.
:return: Returns the result object.
         If the method is called asynchronously,
         returns a Future object representing the execution of the method.
:rtype: Union[SuccessResponse, Future[SuccessResponse]]

send_feedback_with_http_info(database: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.', metadata=[Strict(strict=True)])], var_schema: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.', metadata=[Strict(strict=True)])], name: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the resource.', metadata=[Strict(strict=True)])], send_feedback_request: SendFeedbackRequest, **kwargs)¶

send_feedback # noqa: E501

Send user feedback for a Cortex Search result # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> future = api.send_feedback_with_http_info(
...     database, var_schema, name, send_feedback_request, async_req=True
... )
>>> result = future.result()
:param database: Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases. (required)
:type database: str
:param var_schema: Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database. (required)
:type var_schema: str
:param name: Identifier (i.e. name) for the resource. (required)
:type name: str
:param send_feedback_request: (required)
:type send_feedback_request: SendFeedbackRequest
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
                               and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
                         be returned without reading/decoding response
                         data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
                         number provided, it will be total request
                         timeout. It can also be a pair (tuple) of
                         (connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
                      request; this effectively ignores the authentication
                      in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
         If the method is called asynchronously,
         returns a Future object representing the execution of the method.
:rtype: tuple(Union[SuccessResponse, Future[SuccessResponse]], status_code(int), headers(HTTPHeaderDict))

suggest_cortex_search_service(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], service_name: Annotated[StrictStr, Field(description='The name of the Cortex Search Service')], suggest_query_request: SuggestQueryRequest, async_req: Literal[False] = False, **kwargs) → SuggestQueryResponse¶

suggest_cortex_search_service(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], service_name: Annotated[StrictStr, Field(description='The name of the Cortex Search Service')], suggest_query_request: SuggestQueryRequest, async_req: Literal[True] = True, **kwargs) → Future[SuggestQueryResponse]

suggest_cortex_search_service(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], service_name: Annotated[StrictStr, Field(description='The name of the Cortex Search Service')], suggest_query_request: SuggestQueryRequest, async_req: bool = False, **kwargs) → SuggestQueryResponse | Future[SuggestQueryResponse]

Suggest from a Cortex Search Service # noqa: E501

Suggest from a Cortex Search Service to get auto-complete or contextual suggestions # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> future = api.suggest_cortex_search_service(
...     database, var_schema, service_name, suggest_query_request, async_req=True
... )
>>> result = future.result()
:param database: Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases. (required)
:type database: str
:param var_schema: Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database. (required)
:type var_schema: str
:param service_name: The name of the Cortex Search Service (required)
:type service_name: str
:param suggest_query_request: (required)
:type suggest_query_request: SuggestQueryRequest
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
                         be returned without reading/decoding response
                         data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
                         number provided, it will be total request
                         timeout. It can also be a pair (tuple) of
                         (connection, read) timeouts.
:return: Returns the result object.
         If the method is called asynchronously,
         returns a Future object representing the execution of the method.
:rtype: Union[SuggestQueryResponse, Future[SuggestQueryResponse]]

suggest_cortex_search_service_with_http_info(database: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.', metadata=[Strict(strict=True)])], var_schema: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.', metadata=[Strict(strict=True)])], service_name: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The name of the Cortex Search Service')], suggest_query_request: SuggestQueryRequest, **kwargs)¶

Suggest from a Cortex Search Service # noqa: E501

Suggest from a Cortex Search Service to get auto-complete or contextual suggestions # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> future = api.suggest_cortex_search_service_with_http_info(
...     database, var_schema, service_name, suggest_query_request, async_req=True
... )
>>> result = future.result()
:param database: Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases. (required)
:type database: str
:param var_schema: Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database. (required)
:type var_schema: str
:param service_name: The name of the Cortex Search Service (required)
:type service_name: str
:param suggest_query_request: (required)
:type suggest_query_request: SuggestQueryRequest
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
                               and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
                         be returned without reading/decoding response
                         data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
                         number provided, it will be total request
                         timeout. It can also be a pair (tuple) of
                         (connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
                      request; this effectively ignores the authentication
                      in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
         If the method is called asynchronously,
         returns a Future object representing the execution of the method.
:rtype: tuple(Union[SuggestQueryResponse, Future[SuggestQueryResponse]], status_code(int), headers(HTTPHeaderDict))

suspend_cortex_search_service(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], name: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the resource.')], if_exists: Annotated[StrictBool | None, Field(description="Parameter that specifies how to handle the request for a resource that does not exist: - `true`: The endpoint does not throw an error if the resource does not exist. It returns a 200 success response, but does not take any action on the resource. - `false`: The endpoint throws an error if the resource doesn't exist.")] = None, target: Annotated[StrictStr | None, Field(description='Query parameter that identifies the target to which suspension or resumption of the cortex search service should be applied.')] = None, async_req: Literal[False] = False, **kwargs) → SuccessResponse¶

suspend_cortex_search_service(database: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.')], var_schema: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.')], name: Annotated[str, Field(strict=True, description='Identifier (i.e. name) for the resource.')], if_exists: Annotated[StrictBool | None, Field(description="Parameter that specifies how to handle the request for a resource that does not exist: - `true`: The endpoint does not throw an error if the resource does not exist. It returns a 200 success response, but does not take any action on the resource. - `false`: The endpoint throws an error if the resource doesn't exist.")] = None, target: Annotated[StrictStr | None, Field(description='Query parameter that identifies the target to which suspension or resumption of the cortex search service should be applied.')] = None, async_req: bool = False, **kwargs) → SuccessResponse | Future[SuccessResponse]

Suspend a cortex search service. # noqa: E501

Suspends one or both of the indexing or serving targets of a cortex search service. # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> future = api.suspend_cortex_search_service(
...     database, var_schema, name, if_exists, target, async_req=True
... )
>>> result = future.result()
:param database: Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases. (required)
:type database: str
:param var_schema: Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database. (required)
:type var_schema: str
:param name: Identifier (i.e. name) for the resource. (required)
:type name: str
:param if_exists: Parameter that specifies how to handle the request for a resource that does not exist: - `true`: The endpoint does not throw an error if the resource does not exist. It returns a 200 success response, but does not take any action on the resource. - `false`: The endpoint throws an error if the resource doesn't exist.
:type if_exists: bool
:param target: Query parameter that identifies the target to which suspension or resumption of the cortex search service should be applied.
:type target: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
                         be returned without reading/decoding response
                         data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
                         number provided, it will be total request
                         timeout. It can also be a pair (tuple) of
                         (connection, read) timeouts.
:return: Returns the result object.
         If the method is called asynchronously,
         returns a Future object representing the execution of the method.
:rtype: Union[SuccessResponse, Future[SuccessResponse]]

suspend_cortex_search_service_with_http_info(database: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases.', metadata=[Strict(strict=True)])], var_schema: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database.', metadata=[Strict(strict=True)])], name: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='Identifier (i.e. name) for the resource.', metadata=[Strict(strict=True)])], if_exists: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Parameter that specifies how to handle the request for a resource that does not exist: - `true`: The endpoint does not throw an error if the resource does not exist. It returns a 200 success response, but does not take any action on the resource. - `false`: The endpoint throws an error if the resource doesn't exist.")] = None, target: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Query parameter that identifies the target to which suspension or resumption of the cortex search service should be applied.')] = None, **kwargs)¶

Suspend a cortex search service. # noqa: E501

Suspends one or both of the indexing or serving targets of a cortex search service. # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> future = api.suspend_cortex_search_service_with_http_info(
...     database, var_schema, name, if_exists, target, async_req=True
... )
>>> result = future.result()
:param database: Identifier (i.e. name) for the database to which the resource belongs. You can use the `/api/v2/databases` GET request to get a list of available databases. (required)
:type database: str
:param var_schema: Identifier (i.e. name) for the schema to which the resource belongs. You can use the `/api/v2/databases/{database}/schemas` GET request to get a list of available schemas for the specified database. (required)
:type var_schema: str
:param name: Identifier (i.e. name) for the resource. (required)
:type name: str
:param if_exists: Parameter that specifies how to handle the request for a resource that does not exist: - `true`: The endpoint does not throw an error if the resource does not exist. It returns a 200 success response, but does not take any action on the resource. - `false`: The endpoint throws an error if the resource doesn't exist.
:type if_exists: bool
:param target: Query parameter that identifies the target to which suspension or resumption of the cortex search service should be applied.
:type target: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
                               and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
                         be returned without reading/decoding response
                         data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
                         number provided, it will be total request
                         timeout. It can also be a pair (tuple) of
                         (connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
                      request; this effectively ignores the authentication
                      in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
         If the method is called asynchronously,
         returns a Future object representing the execution of the method.
:rtype: tuple(Union[SuccessResponse, Future[SuccessResponse]], status_code(int), headers(HTTPHeaderDict))