| :mod:`airflow.providers.google.cloud.hooks.datacatalog` |
| ======================================================= |
| |
| .. py:module:: airflow.providers.google.cloud.hooks.datacatalog |
| |
| |
| Module Contents |
| --------------- |
| |
| .. py:class:: CloudDataCatalogHook(gcp_conn_id: str = 'google_cloud_default', delegate_to: Optional[str] = None, impersonation_chain: Optional[Union[str, Sequence[str]]] = None) |
| |
| Bases: :class:`airflow.providers.google.common.hooks.base_google.GoogleBaseHook` |
| |
| Hook for Google Cloud Data Catalog Service. |
| |
| :param gcp_conn_id: The connection ID to use when fetching connection info. |
| :type gcp_conn_id: str |
| :param delegate_to: The account to impersonate using domain-wide delegation of authority, |
| if any. For this to work, the service account making the request must have |
| domain-wide delegation enabled. |
| :type delegate_to: str |
| :param impersonation_chain: Optional service account to impersonate using short-term |
| credentials, or chained list of accounts required to get the access_token |
| of the last account in the list, which will be impersonated in the request. |
| If set as a string, the account must grant the originating account |
| the Service Account Token Creator IAM role. |
| If set as a sequence, the identities from the list must grant |
| Service Account Token Creator IAM role to the directly preceding identity, with first |
| account from the list granting this role to the originating account. |
| :type impersonation_chain: Union[str, Sequence[str]] |
| |
| |
| .. method:: get_conn(self) |
| |
| Retrieves client library object that allow access to Cloud Data Catalog service. |
| |
| |
| |
| |
| .. method:: create_entry(self, location: str, entry_group: str, entry_id: str, entry: Union[dict, Entry], project_id: str, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Creates an entry. |
| |
| Currently only entries of 'FILESET' type can be created. |
| |
| :param location: Required. The location of the entry to create. |
| :type location: str |
| :param entry_group: Required. Entry group ID under which the entry is created. |
| :type entry_group: str |
| :param entry_id: Required. The id of the entry to create. |
| :type entry_id: str |
| :param entry: Required. The entry to create. |
| If a dict is provided, it must be of the same form as the protobuf message |
| :class:`~google.cloud.datacatalog_v1beta1.types.Entry` |
| :type entry: Union[Dict, google.cloud.datacatalog_v1beta1.types.Entry] |
| :param project_id: The ID of the Google Cloud project that owns the entry. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param retry: A retry object used to retry requests. If set to ``None`` or missing, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: create_entry_group(self, location: str, entry_group_id: str, entry_group: Union[Dict, EntryGroup], project_id: str, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Creates an EntryGroup. |
| |
| :param location: Required. The location of the entry group to create. |
| :type location: str |
| :param entry_group_id: Required. The id of the entry group to create. The id must begin with a letter |
| or underscore, contain only English letters, numbers and underscores, and be at most 64 |
| characters. |
| :type entry_group_id: str |
| :param entry_group: The entry group to create. Defaults to an empty entry group. |
| |
| If a dict is provided, it must be of the same form as the protobuf message |
| :class:`~google.cloud.datacatalog_v1beta1.types.EntryGroup` |
| :type entry_group: Union[Dict, google.cloud.datacatalog_v1beta1.types.EntryGroup] |
| :param project_id: The ID of the Google Cloud project that owns the entry group. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: create_tag(self, location: str, entry_group: str, entry: str, tag: Union[dict, Tag], project_id: str, template_id: Optional[str] = None, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Creates a tag on an entry. |
| |
| :param location: Required. The location of the tag to create. |
| :type location: str |
| :param entry_group: Required. Entry group ID under which the tag is created. |
| :type entry_group: str |
| :param entry: Required. Entry group ID under which the tag is created. |
| :type entry: str |
| :param tag: Required. The tag to create. |
| If a dict is provided, it must be of the same form as the protobuf message |
| :class:`~google.cloud.datacatalog_v1beta1.types.Tag` |
| :type tag: Union[Dict, google.cloud.datacatalog_v1beta1.types.Tag] |
| :param template_id: Required. Template ID used to create tag |
| :type template_id: Optional[str] |
| :param project_id: The ID of the Google Cloud project that owns the tag. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: create_tag_template(self, location, tag_template_id: str, tag_template: Union[dict, TagTemplate], project_id: str, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Creates a tag template. |
| |
| :param location: Required. The location of the tag template to create. |
| :type location: str |
| :param tag_template_id: Required. The id of the tag template to create. |
| :type tag_template_id: str |
| :param tag_template: Required. The tag template to create. |
| |
| If a dict is provided, it must be of the same form as the protobuf message |
| :class:`~google.cloud.datacatalog_v1beta1.types.TagTemplate` |
| :type tag_template: Union[Dict, google.cloud.datacatalog_v1beta1.types.TagTemplate] |
| :param project_id: The ID of the Google Cloud project that owns the tag template. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: create_tag_template_field(self, location: str, tag_template: str, tag_template_field_id: str, tag_template_field: Union[dict, TagTemplateField], project_id: str, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Creates a field in a tag template. |
| |
| :param location: Required. The location of the tag template field to create. |
| :type location: str |
| :param tag_template: Required. The id of the tag template to create. |
| :type tag_template: str |
| :param tag_template_field_id: Required. The ID of the tag template field to create. Field ids can |
| contain letters (both uppercase and lowercase), numbers (0-9), underscores (\_) and dashes (-). |
| Field IDs must be at least 1 character long and at most 128 characters long. Field IDs must also |
| be unique within their template. |
| :type tag_template_field_id: str |
| :param tag_template_field: Required. The tag template field to create. |
| |
| If a dict is provided, it must be of the same form as the protobuf message |
| :class:`~google.cloud.datacatalog_v1beta1.types.TagTemplateField` |
| :type tag_template_field: Union[Dict, google.cloud.datacatalog_v1beta1.types.TagTemplateField] |
| :param project_id: The ID of the Google Cloud project that owns the tag template field. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: delete_entry(self, location: str, entry_group: str, entry: str, project_id: str, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Deletes an existing entry. |
| |
| :param location: Required. The location of the entry to delete. |
| :type location: str |
| :param entry_group: Required. Entry group ID for entries that is deleted. |
| :type entry_group: str |
| :param entry: Entry ID that is deleted. |
| :type entry: str |
| :param project_id: The ID of the Google Cloud project that owns the entry group. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: delete_entry_group(self, location, entry_group, project_id: str, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Deletes an EntryGroup. |
| |
| Only entry groups that do not contain entries can be deleted. |
| |
| :param location: Required. The location of the entry group to delete. |
| :type location: str |
| :param entry_group: Entry group ID that is deleted. |
| :type entry_group: str |
| :param project_id: The ID of the Google Cloud project that owns the entry group. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: delete_tag(self, location: str, entry_group: str, entry: str, tag: str, project_id: str, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Deletes a tag. |
| |
| :param location: Required. The location of the tag to delete. |
| :type location: str |
| :param entry_group: Entry group ID for tag that is deleted. |
| :type entry_group: str |
| :param entry: Entry ID for tag that is deleted. |
| :type entry: str |
| :param tag: Identifier for TAG that is deleted. |
| :type tag: str |
| :param project_id: The ID of the Google Cloud project that owns the entry group. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: delete_tag_template(self, location, tag_template, force: bool, project_id: str, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Deletes a tag template and all tags using the template. |
| |
| :param location: Required. The location of the tag template to delete. |
| :type location: str |
| :param tag_template: ID for tag template that is deleted. |
| :type tag_template: str |
| :param project_id: The ID of the Google Cloud project that owns the entry group. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param force: Required. Currently, this field must always be set to ``true``. This confirms the |
| deletion of any possible tags using this template. ``force = false`` will be supported in the |
| future. |
| :type force: bool |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: delete_tag_template_field(self, location: str, tag_template: str, field: str, force: bool, project_id: str, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Deletes a field in a tag template and all uses of that field. |
| |
| :param location: Required. The location of the tag template to delete. |
| :type location: str |
| :param tag_template: Tag Template ID for tag template field that is deleted. |
| :type tag_template: str |
| :param field: Name of field that is deleted. |
| :type field: str |
| :param force: Required. This confirms the deletion of this field from any tags using this field. |
| :type force: bool |
| :param project_id: The ID of the Google Cloud project that owns the entry group. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: get_entry(self, location: str, entry_group: str, entry: str, project_id: str, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Gets an entry. |
| |
| :param location: Required. The location of the entry to get. |
| :type location: str |
| :param entry_group: Required. The entry group of the entry to get. |
| :type entry_group: str |
| :param entry: The ID of the entry to get. |
| :type entry: str |
| :param project_id: The ID of the Google Cloud project that owns the entry group. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: get_entry_group(self, location: str, entry_group: str, project_id: str, read_mask: Union[Dict, FieldMask] = None, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Gets an entry group. |
| |
| :param location: Required. The location of the entry group to get. |
| :type location: str |
| :param entry_group: The ID of the entry group to get. |
| :type entry_group: str |
| :param read_mask: The fields to return. If not set or empty, all fields are returned. |
| |
| If a dict is provided, it must be of the same form as the protobuf message |
| :class:`~google.cloud.datacatalog_v1beta1.types.FieldMask` |
| :type read_mask: Union[Dict, google.cloud.datacatalog_v1beta1.types.FieldMask] |
| :param project_id: The ID of the Google Cloud project that owns the entry group. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: get_tag_template(self, location: str, tag_template: str, project_id: str, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Gets a tag template. |
| |
| :param location: Required. The location of the tag template to get. |
| :type location: str |
| :param tag_template: Required. The ID of the tag template to get. |
| :type tag_template: str |
| :param project_id: The ID of the Google Cloud project that owns the entry group. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: list_tags(self, location: str, entry_group: str, entry: str, project_id: str, page_size: int = 100, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Lists the tags on an Entry. |
| |
| :param location: Required. The location of the tags to get. |
| :type location: str |
| :param entry_group: Required. The entry group of the tags to get. |
| :type entry_group: str |
| :param entry_group: Required. The entry of the tags to get. |
| :type entry: str |
| :param page_size: The maximum number of resources contained in the underlying API response. If page |
| streaming is performed per- resource, this parameter does not affect the return value. If page |
| streaming is performed per-page, this determines the maximum number of resources in a page. |
| :type page_size: int |
| :param project_id: The ID of the Google Cloud project that owns the entry group. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: get_tag_for_template_name(self, location: str, entry_group: str, entry: str, template_name: str, project_id: str, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Gets for a tag with a specific template for a specific entry. |
| |
| :param location: Required. The location which contains the entry to search for. |
| :type location: str |
| :param entry_group: The entry group ID which contains the entry to search for. |
| :type entry_group: str |
| :param entry: The name of the entry to search for. |
| :type entry: str |
| :param template_name: The name of the template that will be the search criterion. |
| :type template_name: str |
| :param project_id: The ID of the Google Cloud project that owns the entry group. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: lookup_entry(self, linked_resource: Optional[str] = None, sql_resource: Optional[str] = None, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Get an entry by target resource name. |
| |
| This method allows clients to use the resource name from the source Google Cloud service |
| to get the Data Catalog Entry. |
| |
| :param linked_resource: The full name of the Google Cloud resource the Data Catalog entry |
| represents. See: https://cloud.google.com/apis/design/resource\_names#full\_resource\_name. Full |
| names are case-sensitive. |
| |
| :type linked_resource: str |
| :param sql_resource: The SQL name of the entry. SQL names are case-sensitive. |
| :type sql_resource: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: rename_tag_template_field(self, location: str, tag_template: str, field: str, new_tag_template_field_id: str, project_id: str, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Renames a field in a tag template. |
| |
| :param location: Required. The location of the tag template field to rename. |
| :type location: str |
| :param tag_template: The tag template ID for field that is renamed. |
| :type tag_template: str |
| :param field: Required. The old ID of this tag template field. For example, |
| ``my_old_field``. |
| :type field: str |
| :param new_tag_template_field_id: Required. The new ID of this tag template field. For example, |
| ``my_new_field``. |
| :type new_tag_template_field_id: str |
| :param project_id: The ID of the Google Cloud project that owns the entry group. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: search_catalog(self, scope: Union[Dict, SearchCatalogRequest.Scope], query: str, page_size: int = 100, order_by: Optional[str] = None, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Searches Data Catalog for multiple resources like entries, tags that match a query. |
| |
| This does not return the complete resource, only the resource identifier and high level fields. |
| Clients can subsequently call ``Get`` methods. |
| |
| Note that searches do not have full recall. There may be results that match your query but are not |
| returned, even in subsequent pages of results. These missing results may vary across repeated calls to |
| search. Do not rely on this method if you need to guarantee full recall. |
| |
| :param scope: Required. The scope of this search request. |
| |
| If a dict is provided, it must be of the same form as the protobuf message |
| :class:`~google.cloud.datacatalog_v1beta1.types.Scope` |
| :type scope: Union[Dict, google.cloud.datacatalog_v1beta1.types.SearchCatalogRequest.Scope] |
| :param query: Required. The query string in search query syntax. The query must be non-empty. |
| |
| Query strings can be simple as "x" or more qualified as: |
| |
| - name:x |
| - column:x |
| - description:y |
| |
| Note: Query tokens need to have a minimum of 3 characters for substring matching to work |
| correctly. See `Data Catalog Search Syntax <https://cloud.google.com/data-catalog/docs/how- |
| to/search-reference>`__ for more information. |
| :type query: str |
| :param page_size: The maximum number of resources contained in the underlying API response. If page |
| streaming is performed per-resource, this parameter does not affect the return value. If page |
| streaming is performed per-page, this determines the maximum number of resources in a page. |
| :type page_size: int |
| :param order_by: Specifies the ordering of results, currently supported case-sensitive choices are: |
| |
| - ``relevance``, only supports descending |
| - ``last_access_timestamp [asc|desc]``, defaults to descending if not specified |
| - ``last_modified_timestamp [asc|desc]``, defaults to descending if not specified |
| |
| If not specified, defaults to ``relevance`` descending. |
| :type order_by: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: update_entry(self, entry: Union[Dict, Entry], update_mask: Union[dict, FieldMask], project_id: str, location: Optional[str] = None, entry_group: Optional[str] = None, entry_id: Optional[str] = None, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Updates an existing entry. |
| |
| :param entry: Required. The updated entry. The "name" field must be set. |
| |
| If a dict is provided, it must be of the same form as the protobuf message |
| :class:`~google.cloud.datacatalog_v1beta1.types.Entry` |
| :type entry: Union[Dict, google.cloud.datacatalog_v1beta1.types.Entry] |
| :param update_mask: The fields to update on the entry. If absent or empty, all modifiable fields are |
| updated. |
| |
| If a dict is provided, it must be of the same form as the protobuf message |
| :class:`~google.cloud.datacatalog_v1beta1.types.FieldMask` |
| :type update_mask: Union[Dict, google.cloud.datacatalog_v1beta1.types.FieldMask] |
| :param location: Required. The location of the entry to update. |
| :type location: str |
| :param entry_group: The entry group ID for the entry that is being updated. |
| :type entry_group: str |
| :param entry_id: The entry ID that is being updated. |
| :type entry_id: str |
| :param project_id: The ID of the Google Cloud project that owns the entry group. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: update_tag(self, tag: Union[Dict, Tag], update_mask: Union[Dict, FieldMask], project_id: str, location: Optional[str] = None, entry_group: Optional[str] = None, entry: Optional[str] = None, tag_id: Optional[str] = None, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Updates an existing tag. |
| |
| :param tag: Required. The updated tag. The "name" field must be set. |
| |
| If a dict is provided, it must be of the same form as the protobuf message |
| :class:`~google.cloud.datacatalog_v1beta1.types.Tag` |
| :type tag: Union[Dict, google.cloud.datacatalog_v1beta1.types.Tag] |
| :param update_mask: The fields to update on the Tag. If absent or empty, all modifiable fields are |
| updated. Currently the only modifiable field is the field ``fields``. |
| |
| If a dict is provided, it must be of the same form as the protobuf message |
| :class:`~google.cloud.datacatalog_v1beta1.types.FieldMask` |
| :type update_mask: Union[Dict, google.cloud.datacatalog_v1beta1.types.FieldMask] |
| :param location: Required. The location of the tag to rename. |
| :type location: str |
| :param entry_group: The entry group ID for the tag that is being updated. |
| :type entry_group: str |
| :param entry: The entry ID for the tag that is being updated. |
| :type entry: str |
| :param tag_id: The tag ID that is being updated. |
| :type tag_id: str |
| :param project_id: The ID of the Google Cloud project that owns the entry group. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: update_tag_template(self, tag_template: Union[dict, TagTemplate], update_mask: Union[dict, FieldMask], project_id: str, location: Optional[str] = None, tag_template_id: Optional[str] = None, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Updates a tag template. |
| |
| This method cannot be used to update the fields of a template. The tag |
| template fields are represented as separate resources and should be updated using their own |
| create/update/delete methods. |
| |
| :param tag_template: Required. The template to update. The "name" field must be set. |
| |
| If a dict is provided, it must be of the same form as the protobuf message |
| :class:`~google.cloud.datacatalog_v1beta1.types.TagTemplate` |
| :type tag_template: Union[Dict, google.cloud.datacatalog_v1beta1.types.TagTemplate] |
| :param update_mask: The field mask specifies the parts of the template to overwrite. |
| |
| If absent or empty, all of the allowed fields above will be updated. |
| |
| If a dict is provided, it must be of the same form as the protobuf message |
| :class:`~google.cloud.datacatalog_v1beta1.types.FieldMask` |
| :type update_mask: Union[Dict, google.cloud.datacatalog_v1beta1.types.FieldMask] |
| :param location: Required. The location of the tag template to rename. |
| :type location: str |
| :param tag_template_id: Optional. The tag template ID for the entry that is being updated. |
| :type tag_template_id: str |
| :param project_id: The ID of the Google Cloud project that owns the entry group. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
| .. method:: update_tag_template_field(self, tag_template_field: Union[dict, TagTemplateField], update_mask: Union[dict, FieldMask], project_id: str, tag_template_field_name: Optional[str] = None, location: Optional[str] = None, tag_template: Optional[str] = None, tag_template_field_id: Optional[str] = None, retry: Optional[Retry] = None, timeout: Optional[float] = None, metadata: Optional[Sequence[Tuple[str, str]]] = None) |
| |
| Updates a field in a tag template. This method cannot be used to update the field type. |
| |
| :param tag_template_field: Required. The template to update. |
| |
| If a dict is provided, it must be of the same form as the protobuf message |
| :class:`~google.cloud.datacatalog_v1beta1.types.TagTemplateField` |
| :type tag_template_field: Union[Dict, google.cloud.datacatalog_v1beta1.types.TagTemplateField] |
| :param update_mask: The field mask specifies the parts of the template to be updated. Allowed fields: |
| |
| - ``display_name`` |
| - ``type.enum_type`` |
| |
| If ``update_mask`` is not set or empty, all of the allowed fields above will be updated. |
| |
| When updating an enum type, the provided values will be merged with the existing values. |
| Therefore, enum values can only be added, existing enum values cannot be deleted nor renamed. |
| |
| If a dict is provided, it must be of the same form as the protobuf message |
| :class:`~google.cloud.datacatalog_v1beta1.types.FieldMask` |
| :type update_mask: Union[Dict, google.cloud.datacatalog_v1beta1.types.FieldMask] |
| :param tag_template_field_name: Optional. The name of the tag template field to rename. |
| :type tag_template_field_name: str |
| :param location: Optional. The location of the tag to rename. |
| :type location: str |
| :param tag_template: Optional. The tag template ID for tag template field to rename. |
| :type tag_template: str |
| :param tag_template_field_id: Optional. The ID of tag template field to rename. |
| :type tag_template_field_id: str |
| :param project_id: The ID of the Google Cloud project that owns the entry group. |
| If set to ``None`` or missing, the default project_id from the Google Cloud connection is used. |
| :type project_id: str |
| :param retry: A retry object used to retry requests. If ``None`` is specified, requests will be |
| retried using a default configuration. |
| :type retry: google.api_core.retry.Retry |
| :param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if |
| ``retry`` is specified, the timeout applies to each individual attempt. |
| :type timeout: float |
| :param metadata: Additional metadata that is provided to the method. |
| :type metadata: Sequence[Tuple[str, str]] |
| |
| |
| |
| |
