pulumi-databricks 1.77.0a1760375482__py3-none-any.whl → 1.79.0a1762839813__py3-none-any.whl

pulumi_databricks/get_database_database_catalogs.py

@@ -27,16 +27,19 @@ class GetDatabaseDatabaseCatalogsResult:
     """
     A collection of values returned by getDatabaseDatabaseCatalogs.
     """
-    def __init__(__self__, database_catalogs=None, id=None, workspace_id=None):
+    def __init__(__self__, database_catalogs=None, id=None, instance_name=None, page_size=None):
         if database_catalogs and not isinstance(database_catalogs, list):
             raise TypeError("Expected argument 'database_catalogs' to be a list")
         pulumi.set(__self__, "database_catalogs", database_catalogs)
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
-        if workspace_id and not isinstance(workspace_id, str):
-            raise TypeError("Expected argument 'workspace_id' to be a str")
-        pulumi.set(__self__, "workspace_id", workspace_id)
+        if instance_name and not isinstance(instance_name, str):
+            raise TypeError("Expected argument 'instance_name' to be a str")
+        pulumi.set(__self__, "instance_name", instance_name)
+        if page_size and not isinstance(page_size, int):
+            raise TypeError("Expected argument 'page_size' to be a int")
+        pulumi.set(__self__, "page_size", page_size)
 
     @_builtins.property
     @pulumi.getter(name="databaseCatalogs")
@@ -52,9 +55,14 @@ class GetDatabaseDatabaseCatalogsResult:
         return pulumi.get(self, "id")
 
     @_builtins.property
-    @pulumi.getter(name="workspaceId")
-    def workspace_id(self) -> Optional[_builtins.str]:
-        return pulumi.get(self, "workspace_id")
+    @pulumi.getter(name="instanceName")
+    def instance_name(self) -> _builtins.str:
+        return pulumi.get(self, "instance_name")
+
+    @_builtins.property
+    @pulumi.getter(name="pageSize")
+    def page_size(self) -> Optional[_builtins.int]:
+        return pulumi.get(self, "page_size")
 
 
 class AwaitableGetDatabaseDatabaseCatalogsResult(GetDatabaseDatabaseCatalogsResult):
@@ -65,37 +73,48 @@ class AwaitableGetDatabaseDatabaseCatalogsResult(GetDatabaseDatabaseCatalogsResu
         return GetDatabaseDatabaseCatalogsResult(
             database_catalogs=self.database_catalogs,
             id=self.id,
-            workspace_id=self.workspace_id)
+            instance_name=self.instance_name,
+            page_size=self.page_size)
 
 
-def get_database_database_catalogs(workspace_id: Optional[_builtins.str] = None,
+def get_database_database_catalogs(instance_name: Optional[_builtins.str] = None,
+                                   page_size: Optional[_builtins.int] = None,
                                    opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDatabaseDatabaseCatalogsResult:
     """
-    Use this data source to access information about an existing resource.
+    [![Private Preview](https://img.shields.io/badge/Release_Stage-Private_Preview-blueviolet)](https://docs.databricks.com/aws/en/release-notes/release-types)
 
-    :param _builtins.str workspace_id: Workspace ID of the resource
+
+    :param _builtins.str instance_name: Name of the instance to get database catalogs for
+    :param _builtins.int page_size: Upper bound for items returned
     """
     __args__ = dict()
-    __args__['workspaceId'] = workspace_id
+    __args__['instanceName'] = instance_name
+    __args__['pageSize'] = page_size
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('databricks:index/getDatabaseDatabaseCatalogs:getDatabaseDatabaseCatalogs', __args__, opts=opts, typ=GetDatabaseDatabaseCatalogsResult).value
 
     return AwaitableGetDatabaseDatabaseCatalogsResult(
         database_catalogs=pulumi.get(__ret__, 'database_catalogs'),
         id=pulumi.get(__ret__, 'id'),
-        workspace_id=pulumi.get(__ret__, 'workspace_id'))
-def get_database_database_catalogs_output(workspace_id: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
+        instance_name=pulumi.get(__ret__, 'instance_name'),
+        page_size=pulumi.get(__ret__, 'page_size'))
+def get_database_database_catalogs_output(instance_name: Optional[pulumi.Input[_builtins.str]] = None,
+                                          page_size: Optional[pulumi.Input[Optional[_builtins.int]]] = None,
                                           opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetDatabaseDatabaseCatalogsResult]:
     """
-    Use this data source to access information about an existing resource.
+    [![Private Preview](https://img.shields.io/badge/Release_Stage-Private_Preview-blueviolet)](https://docs.databricks.com/aws/en/release-notes/release-types)
+
 
-    :param _builtins.str workspace_id: Workspace ID of the resource
+    :param _builtins.str instance_name: Name of the instance to get database catalogs for
+    :param _builtins.int page_size: Upper bound for items returned
     """
     __args__ = dict()
-    __args__['workspaceId'] = workspace_id
+    __args__['instanceName'] = instance_name
+    __args__['pageSize'] = page_size
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('databricks:index/getDatabaseDatabaseCatalogs:getDatabaseDatabaseCatalogs', __args__, opts=opts, typ=GetDatabaseDatabaseCatalogsResult)
     return __ret__.apply(lambda __response__: GetDatabaseDatabaseCatalogsResult(
         database_catalogs=pulumi.get(__response__, 'database_catalogs'),
         id=pulumi.get(__response__, 'id'),
-        workspace_id=pulumi.get(__response__, 'workspace_id')))
+        instance_name=pulumi.get(__response__, 'instance_name'),
+        page_size=pulumi.get(__response__, 'page_size')))

pulumi_databricks/get_database_instance.py

@@ -14,7 +14,6 @@ else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from . import _utilities
 from . import outputs
-from ._inputs import *
 
 __all__ = [
     'GetDatabaseInstanceResult',
@@ -28,7 +27,7 @@ class GetDatabaseInstanceResult:
     """
     A collection of values returned by getDatabaseInstance.
     """
-    def __init__(__self__, capacity=None, child_instance_refs=None, creation_time=None, creator=None, effective_enable_pg_native_login=None, effective_enable_readable_secondaries=None, effective_node_count=None, effective_retention_window_in_days=None, effective_stopped=None, enable_pg_native_login=None, enable_readable_secondaries=None, id=None, name=None, node_count=None, parent_instance_ref=None, pg_version=None, read_only_dns=None, read_write_dns=None, retention_window_in_days=None, state=None, stopped=None, uid=None, workspace_id=None):
+    def __init__(__self__, capacity=None, child_instance_refs=None, creation_time=None, creator=None, custom_tags=None, effective_capacity=None, effective_custom_tags=None, effective_enable_pg_native_login=None, effective_enable_readable_secondaries=None, effective_node_count=None, effective_retention_window_in_days=None, effective_stopped=None, effective_usage_policy_id=None, enable_pg_native_login=None, enable_readable_secondaries=None, id=None, name=None, node_count=None, parent_instance_ref=None, pg_version=None, read_only_dns=None, read_write_dns=None, retention_window_in_days=None, state=None, stopped=None, uid=None, usage_policy_id=None):
         if capacity and not isinstance(capacity, str):
             raise TypeError("Expected argument 'capacity' to be a str")
         pulumi.set(__self__, "capacity", capacity)
@@ -41,6 +40,15 @@ class GetDatabaseInstanceResult:
         if creator and not isinstance(creator, str):
             raise TypeError("Expected argument 'creator' to be a str")
         pulumi.set(__self__, "creator", creator)
+        if custom_tags and not isinstance(custom_tags, list):
+            raise TypeError("Expected argument 'custom_tags' to be a list")
+        pulumi.set(__self__, "custom_tags", custom_tags)
+        if effective_capacity and not isinstance(effective_capacity, str):
+            raise TypeError("Expected argument 'effective_capacity' to be a str")
+        pulumi.set(__self__, "effective_capacity", effective_capacity)
+        if effective_custom_tags and not isinstance(effective_custom_tags, list):
+            raise TypeError("Expected argument 'effective_custom_tags' to be a list")
+        pulumi.set(__self__, "effective_custom_tags", effective_custom_tags)
         if effective_enable_pg_native_login and not isinstance(effective_enable_pg_native_login, bool):
             raise TypeError("Expected argument 'effective_enable_pg_native_login' to be a bool")
         pulumi.set(__self__, "effective_enable_pg_native_login", effective_enable_pg_native_login)
@@ -56,6 +64,9 @@ class GetDatabaseInstanceResult:
         if effective_stopped and not isinstance(effective_stopped, bool):
             raise TypeError("Expected argument 'effective_stopped' to be a bool")
         pulumi.set(__self__, "effective_stopped", effective_stopped)
+        if effective_usage_policy_id and not isinstance(effective_usage_policy_id, str):
+            raise TypeError("Expected argument 'effective_usage_policy_id' to be a str")
+        pulumi.set(__self__, "effective_usage_policy_id", effective_usage_policy_id)
         if enable_pg_native_login and not isinstance(enable_pg_native_login, bool):
             raise TypeError("Expected argument 'enable_pg_native_login' to be a bool")
         pulumi.set(__self__, "enable_pg_native_login", enable_pg_native_login)
@@ -95,13 +106,13 @@ class GetDatabaseInstanceResult:
         if uid and not isinstance(uid, str):
             raise TypeError("Expected argument 'uid' to be a str")
         pulumi.set(__self__, "uid", uid)
-        if workspace_id and not isinstance(workspace_id, str):
-            raise TypeError("Expected argument 'workspace_id' to be a str")
-        pulumi.set(__self__, "workspace_id", workspace_id)
+        if usage_policy_id and not isinstance(usage_policy_id, str):
+            raise TypeError("Expected argument 'usage_policy_id' to be a str")
+        pulumi.set(__self__, "usage_policy_id", usage_policy_id)
 
     @_builtins.property
     @pulumi.getter
-    def capacity(self) -> Optional[_builtins.str]:
+    def capacity(self) -> _builtins.str:
         """
         (string) - The sku of the instance. Valid values are "CU_1", "CU_2", "CU_4", "CU_8"
         """
@@ -132,13 +143,35 @@ class GetDatabaseInstanceResult:
         """
         return pulumi.get(self, "creator")
 
+    @_builtins.property
+    @pulumi.getter(name="customTags")
+    def custom_tags(self) -> Sequence['outputs.GetDatabaseInstanceCustomTagResult']:
+        """
+        (list of CustomTag) - Custom tags associated with the instance. This field is only included on create and update responses
+        """
+        return pulumi.get(self, "custom_tags")
+
+    @_builtins.property
+    @pulumi.getter(name="effectiveCapacity")
+    def effective_capacity(self) -> _builtins.str:
+        """
+        (string, deprecated) - Deprecated. The sku of the instance; this field will always match the value of capacity
+        """
+        return pulumi.get(self, "effective_capacity")
+
+    @_builtins.property
+    @pulumi.getter(name="effectiveCustomTags")
+    def effective_custom_tags(self) -> Sequence['outputs.GetDatabaseInstanceEffectiveCustomTagResult']:
+        """
+        (list of CustomTag) - The recorded custom tags associated with the instance
+        """
+        return pulumi.get(self, "effective_custom_tags")
+
     @_builtins.property
     @pulumi.getter(name="effectiveEnablePgNativeLogin")
     def effective_enable_pg_native_login(self) -> _builtins.bool:
         """
-        (boolean) - xref AIP-129. `enable_pg_native_login` is owned by the client, while `effective_enable_pg_native_login` is owned by the server.
-        `enable_pg_native_login` will only be set in Create/Update response messages if and only if the user provides the field via the request.
-        `effective_enable_pg_native_login` on the other hand will always bet set in all response messages (Create/Update/Get/List)
+        (boolean) - Whether the instance has PG native password login enabled
         """
         return pulumi.get(self, "effective_enable_pg_native_login")
 
@@ -146,9 +179,7 @@ class GetDatabaseInstanceResult:
     @pulumi.getter(name="effectiveEnableReadableSecondaries")
     def effective_enable_readable_secondaries(self) -> _builtins.bool:
         """
-        (boolean) - xref AIP-129. `enable_readable_secondaries` is owned by the client, while `effective_enable_readable_secondaries` is owned by the server.
-        `enable_readable_secondaries` will only be set in Create/Update response messages if and only if the user provides the field via the request.
-        `effective_enable_readable_secondaries` on the other hand will always bet set in all response messages (Create/Update/Get/List)
+        (boolean) - Whether secondaries serving read-only traffic are enabled. Defaults to false
         """
         return pulumi.get(self, "effective_enable_readable_secondaries")
 
@@ -156,9 +187,8 @@ class GetDatabaseInstanceResult:
     @pulumi.getter(name="effectiveNodeCount")
     def effective_node_count(self) -> _builtins.int:
         """
-        (integer) - xref AIP-129. `node_count` is owned by the client, while `effective_node_count` is owned by the server.
-        `node_count` will only be set in Create/Update response messages if and only if the user provides the field via the request.
-        `effective_node_count` on the other hand will always bet set in all response messages (Create/Update/Get/List)
+        (integer) - The number of nodes in the instance, composed of 1 primary and 0 or more secondaries. Defaults to
+        1 primary and 0 secondaries
         """
         return pulumi.get(self, "effective_node_count")
 
@@ -166,9 +196,8 @@ class GetDatabaseInstanceResult:
     @pulumi.getter(name="effectiveRetentionWindowInDays")
     def effective_retention_window_in_days(self) -> _builtins.int:
         """
-        (integer) - xref AIP-129. `retention_window_in_days` is owned by the client, while `effective_retention_window_in_days` is owned by the server.
-        `retention_window_in_days` will only be set in Create/Update response messages if and only if the user provides the field via the request.
-        `effective_retention_window_in_days` on the other hand will always bet set in all response messages (Create/Update/Get/List)
+        (integer) - The retention window for the instance. This is the time window in days
+        for which the historical data is retained
         """
         return pulumi.get(self, "effective_retention_window_in_days")
 
@@ -176,23 +205,29 @@ class GetDatabaseInstanceResult:
     @pulumi.getter(name="effectiveStopped")
     def effective_stopped(self) -> _builtins.bool:
         """
-        (boolean) - xref AIP-129. `stopped` is owned by the client, while `effective_stopped` is owned by the server.
-        `stopped` will only be set in Create/Update response messages if and only if the user provides the field via the request.
-        `effective_stopped` on the other hand will always bet set in all response messages (Create/Update/Get/List)
+        (boolean) - Whether the instance is stopped
         """
         return pulumi.get(self, "effective_stopped")
 
+    @_builtins.property
+    @pulumi.getter(name="effectiveUsagePolicyId")
+    def effective_usage_policy_id(self) -> _builtins.str:
+        """
+        (string) - The policy that is applied to the instance
+        """
+        return pulumi.get(self, "effective_usage_policy_id")
+
     @_builtins.property
     @pulumi.getter(name="enablePgNativeLogin")
     def enable_pg_native_login(self) -> _builtins.bool:
         """
-        (boolean) - Whether the instance has PG native password login enabled. Defaults to true
+        (boolean) - Whether to enable PG native password login on the instance. Defaults to false
         """
         return pulumi.get(self, "enable_pg_native_login")
 
     @_builtins.property
     @pulumi.getter(name="enableReadableSecondaries")
-    def enable_readable_secondaries(self) -> Optional[_builtins.bool]:
+    def enable_readable_secondaries(self) -> _builtins.bool:
         """
         (boolean) - Whether to enable secondaries to serve read-only traffic. Defaults to false
         """
@@ -216,16 +251,16 @@ class GetDatabaseInstanceResult:
 
     @_builtins.property
     @pulumi.getter(name="nodeCount")
-    def node_count(self) -> Optional[_builtins.int]:
+    def node_count(self) -> _builtins.int:
         """
         (integer) - The number of nodes in the instance, composed of 1 primary and 0 or more secondaries. Defaults to
-        1 primary and 0 secondaries
+        1 primary and 0 secondaries. This field is input only, see effective_node_count for the output
         """
         return pulumi.get(self, "node_count")
 
     @_builtins.property
     @pulumi.getter(name="parentInstanceRef")
-    def parent_instance_ref(self) -> Optional['outputs.GetDatabaseInstanceParentInstanceRefResult']:
+    def parent_instance_ref(self) -> 'outputs.GetDatabaseInstanceParentInstanceRefResult':
         """
         (DatabaseInstanceRef) - The ref of the parent instance. This is only available if the instance is
         child instance.
@@ -261,7 +296,7 @@ class GetDatabaseInstanceResult:
 
     @_builtins.property
     @pulumi.getter(name="retentionWindowInDays")
-    def retention_window_in_days(self) -> Optional[_builtins.int]:
+    def retention_window_in_days(self) -> _builtins.int:
         """
         (integer) - The retention window for the instance. This is the time window in days
         for which the historical data is retained. The default value is 7 days.
@@ -279,9 +314,9 @@ class GetDatabaseInstanceResult:
 
     @_builtins.property
     @pulumi.getter
-    def stopped(self) -> Optional[_builtins.bool]:
+    def stopped(self) -> _builtins.bool:
         """
-        (boolean) - Whether the instance is stopped
+        (boolean) - Whether to stop the instance. An input only param, see effective_stopped for the output
         """
         return pulumi.get(self, "stopped")
 
@@ -294,9 +329,12 @@ class GetDatabaseInstanceResult:
         return pulumi.get(self, "uid")
 
     @_builtins.property
-    @pulumi.getter(name="workspaceId")
-    def workspace_id(self) -> Optional[_builtins.str]:
-        return pulumi.get(self, "workspace_id")
+    @pulumi.getter(name="usagePolicyId")
+    def usage_policy_id(self) -> _builtins.str:
+        """
+        (string) - The desired usage policy to associate with the instance
+        """
+        return pulumi.get(self, "usage_policy_id")
 
 
 class AwaitableGetDatabaseInstanceResult(GetDatabaseInstanceResult):
@@ -309,11 +347,15 @@ class AwaitableGetDatabaseInstanceResult(GetDatabaseInstanceResult):
             child_instance_refs=self.child_instance_refs,
             creation_time=self.creation_time,
             creator=self.creator,
+            custom_tags=self.custom_tags,
+            effective_capacity=self.effective_capacity,
+            effective_custom_tags=self.effective_custom_tags,
             effective_enable_pg_native_login=self.effective_enable_pg_native_login,
             effective_enable_readable_secondaries=self.effective_enable_readable_secondaries,
             effective_node_count=self.effective_node_count,
             effective_retention_window_in_days=self.effective_retention_window_in_days,
             effective_stopped=self.effective_stopped,
+            effective_usage_policy_id=self.effective_usage_policy_id,
             enable_pg_native_login=self.enable_pg_native_login,
             enable_readable_secondaries=self.enable_readable_secondaries,
             id=self.id,
@@ -327,20 +369,14 @@ class AwaitableGetDatabaseInstanceResult(GetDatabaseInstanceResult):
             state=self.state,
             stopped=self.stopped,
             uid=self.uid,
-            workspace_id=self.workspace_id)
-
-
-def get_database_instance(capacity: Optional[_builtins.str] = None,
-                          enable_pg_native_login: Optional[_builtins.bool] = None,
-                          enable_readable_secondaries: Optional[_builtins.bool] = None,
-                          name: Optional[_builtins.str] = None,
-                          node_count: Optional[_builtins.int] = None,
-                          parent_instance_ref: Optional[Union['GetDatabaseInstanceParentInstanceRefArgs', 'GetDatabaseInstanceParentInstanceRefArgsDict']] = None,
-                          retention_window_in_days: Optional[_builtins.int] = None,
-                          stopped: Optional[_builtins.bool] = None,
-                          workspace_id: Optional[_builtins.str] = None,
+            usage_policy_id=self.usage_policy_id)
+
+
+def get_database_instance(name: Optional[_builtins.str] = None,
                           opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDatabaseInstanceResult:
     """
+    [![Public Preview](https://img.shields.io/badge/Release_Stage-Public_Preview-yellowgreen)](https://docs.databricks.com/aws/en/release-notes/release-types)
+
     This data source can be used to get a single Database Instance.
 
     ## Example Usage
@@ -355,32 +391,10 @@ def get_database_instance(capacity: Optional[_builtins.str] = None,
     ```
 
 
-    :param _builtins.str capacity: (string) - The sku of the instance. Valid values are "CU_1", "CU_2", "CU_4", "CU_8"
-    :param _builtins.bool enable_pg_native_login: (boolean) - Whether the instance has PG native password login enabled. Defaults to true
-    :param _builtins.bool enable_readable_secondaries: (boolean) - Whether to enable secondaries to serve read-only traffic. Defaults to false
     :param _builtins.str name: The name of the instance. This is the unique identifier for the instance
-    :param _builtins.int node_count: (integer) - The number of nodes in the instance, composed of 1 primary and 0 or more secondaries. Defaults to
-           1 primary and 0 secondaries
-    :param Union['GetDatabaseInstanceParentInstanceRefArgs', 'GetDatabaseInstanceParentInstanceRefArgsDict'] parent_instance_ref: (DatabaseInstanceRef) - The ref of the parent instance. This is only available if the instance is
-           child instance.
-           Input: For specifying the parent instance to create a child instance. Optional.
-           Output: Only populated if provided as input to create a child instance
-    :param _builtins.int retention_window_in_days: (integer) - The retention window for the instance. This is the time window in days
-           for which the historical data is retained. The default value is 7 days.
-           Valid values are 2 to 35 days
-    :param _builtins.bool stopped: (boolean) - Whether the instance is stopped
-    :param _builtins.str workspace_id: Workspace ID of the resource
     """
     __args__ = dict()
-    __args__['capacity'] = capacity
-    __args__['enablePgNativeLogin'] = enable_pg_native_login
-    __args__['enableReadableSecondaries'] = enable_readable_secondaries
     __args__['name'] = name
-    __args__['nodeCount'] = node_count
-    __args__['parentInstanceRef'] = parent_instance_ref
-    __args__['retentionWindowInDays'] = retention_window_in_days
-    __args__['stopped'] = stopped
-    __args__['workspaceId'] = workspace_id
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('databricks:index/getDatabaseInstance:getDatabaseInstance', __args__, opts=opts, typ=GetDatabaseInstanceResult).value
 
@@ -389,11 +403,15 @@ def get_database_instance(capacity: Optional[_builtins.str] = None,
         child_instance_refs=pulumi.get(__ret__, 'child_instance_refs'),
         creation_time=pulumi.get(__ret__, 'creation_time'),
         creator=pulumi.get(__ret__, 'creator'),
+        custom_tags=pulumi.get(__ret__, 'custom_tags'),
+        effective_capacity=pulumi.get(__ret__, 'effective_capacity'),
+        effective_custom_tags=pulumi.get(__ret__, 'effective_custom_tags'),
         effective_enable_pg_native_login=pulumi.get(__ret__, 'effective_enable_pg_native_login'),
         effective_enable_readable_secondaries=pulumi.get(__ret__, 'effective_enable_readable_secondaries'),
         effective_node_count=pulumi.get(__ret__, 'effective_node_count'),
         effective_retention_window_in_days=pulumi.get(__ret__, 'effective_retention_window_in_days'),
         effective_stopped=pulumi.get(__ret__, 'effective_stopped'),
+        effective_usage_policy_id=pulumi.get(__ret__, 'effective_usage_policy_id'),
         enable_pg_native_login=pulumi.get(__ret__, 'enable_pg_native_login'),
         enable_readable_secondaries=pulumi.get(__ret__, 'enable_readable_secondaries'),
         id=pulumi.get(__ret__, 'id'),
@@ -407,18 +425,12 @@ def get_database_instance(capacity: Optional[_builtins.str] = None,
         state=pulumi.get(__ret__, 'state'),
         stopped=pulumi.get(__ret__, 'stopped'),
         uid=pulumi.get(__ret__, 'uid'),
-        workspace_id=pulumi.get(__ret__, 'workspace_id'))
-def get_database_instance_output(capacity: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
-                                 enable_pg_native_login: Optional[pulumi.Input[Optional[_builtins.bool]]] = None,
-                                 enable_readable_secondaries: Optional[pulumi.Input[Optional[_builtins.bool]]] = None,
-                                 name: Optional[pulumi.Input[_builtins.str]] = None,
-                                 node_count: Optional[pulumi.Input[Optional[_builtins.int]]] = None,
-                                 parent_instance_ref: Optional[pulumi.Input[Optional[Union['GetDatabaseInstanceParentInstanceRefArgs', 'GetDatabaseInstanceParentInstanceRefArgsDict']]]] = None,
-                                 retention_window_in_days: Optional[pulumi.Input[Optional[_builtins.int]]] = None,
-                                 stopped: Optional[pulumi.Input[Optional[_builtins.bool]]] = None,
-                                 workspace_id: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
+        usage_policy_id=pulumi.get(__ret__, 'usage_policy_id'))
+def get_database_instance_output(name: Optional[pulumi.Input[_builtins.str]] = None,
                                  opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetDatabaseInstanceResult]:
     """
+    [![Public Preview](https://img.shields.io/badge/Release_Stage-Public_Preview-yellowgreen)](https://docs.databricks.com/aws/en/release-notes/release-types)
+
     This data source can be used to get a single Database Instance.
 
     ## Example Usage
@@ -433,32 +445,10 @@ def get_database_instance_output(capacity: Optional[pulumi.Input[Optional[_built
     ```
 
 
-    :param _builtins.str capacity: (string) - The sku of the instance. Valid values are "CU_1", "CU_2", "CU_4", "CU_8"
-    :param _builtins.bool enable_pg_native_login: (boolean) - Whether the instance has PG native password login enabled. Defaults to true
-    :param _builtins.bool enable_readable_secondaries: (boolean) - Whether to enable secondaries to serve read-only traffic. Defaults to false
     :param _builtins.str name: The name of the instance. This is the unique identifier for the instance
-    :param _builtins.int node_count: (integer) - The number of nodes in the instance, composed of 1 primary and 0 or more secondaries. Defaults to
-           1 primary and 0 secondaries
-    :param Union['GetDatabaseInstanceParentInstanceRefArgs', 'GetDatabaseInstanceParentInstanceRefArgsDict'] parent_instance_ref: (DatabaseInstanceRef) - The ref of the parent instance. This is only available if the instance is
-           child instance.
-           Input: For specifying the parent instance to create a child instance. Optional.
-           Output: Only populated if provided as input to create a child instance
-    :param _builtins.int retention_window_in_days: (integer) - The retention window for the instance. This is the time window in days
-           for which the historical data is retained. The default value is 7 days.
-           Valid values are 2 to 35 days
-    :param _builtins.bool stopped: (boolean) - Whether the instance is stopped
-    :param _builtins.str workspace_id: Workspace ID of the resource
     """
     __args__ = dict()
-    __args__['capacity'] = capacity
-    __args__['enablePgNativeLogin'] = enable_pg_native_login
-    __args__['enableReadableSecondaries'] = enable_readable_secondaries
     __args__['name'] = name
-    __args__['nodeCount'] = node_count
-    __args__['parentInstanceRef'] = parent_instance_ref
-    __args__['retentionWindowInDays'] = retention_window_in_days
-    __args__['stopped'] = stopped
-    __args__['workspaceId'] = workspace_id
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('databricks:index/getDatabaseInstance:getDatabaseInstance', __args__, opts=opts, typ=GetDatabaseInstanceResult)
     return __ret__.apply(lambda __response__: GetDatabaseInstanceResult(
@@ -466,11 +456,15 @@ def get_database_instance_output(capacity: Optional[pulumi.Input[Optional[_built
         child_instance_refs=pulumi.get(__response__, 'child_instance_refs'),
         creation_time=pulumi.get(__response__, 'creation_time'),
         creator=pulumi.get(__response__, 'creator'),
+        custom_tags=pulumi.get(__response__, 'custom_tags'),
+        effective_capacity=pulumi.get(__response__, 'effective_capacity'),
+        effective_custom_tags=pulumi.get(__response__, 'effective_custom_tags'),
         effective_enable_pg_native_login=pulumi.get(__response__, 'effective_enable_pg_native_login'),
         effective_enable_readable_secondaries=pulumi.get(__response__, 'effective_enable_readable_secondaries'),
         effective_node_count=pulumi.get(__response__, 'effective_node_count'),
         effective_retention_window_in_days=pulumi.get(__response__, 'effective_retention_window_in_days'),
         effective_stopped=pulumi.get(__response__, 'effective_stopped'),
+        effective_usage_policy_id=pulumi.get(__response__, 'effective_usage_policy_id'),
         enable_pg_native_login=pulumi.get(__response__, 'enable_pg_native_login'),
         enable_readable_secondaries=pulumi.get(__response__, 'enable_readable_secondaries'),
         id=pulumi.get(__response__, 'id'),
@@ -484,4 +478,4 @@ def get_database_instance_output(capacity: Optional[pulumi.Input[Optional[_built
         state=pulumi.get(__response__, 'state'),
         stopped=pulumi.get(__response__, 'stopped'),
         uid=pulumi.get(__response__, 'uid'),
-        workspace_id=pulumi.get(__response__, 'workspace_id')))
+        usage_policy_id=pulumi.get(__response__, 'usage_policy_id')))

pulumi_databricks/get_database_instances.py

@@ -27,16 +27,16 @@ class GetDatabaseInstancesResult:
     """
     A collection of values returned by getDatabaseInstances.
     """
-    def __init__(__self__, database_instances=None, id=None, workspace_id=None):
+    def __init__(__self__, database_instances=None, id=None, page_size=None):
         if database_instances and not isinstance(database_instances, list):
             raise TypeError("Expected argument 'database_instances' to be a list")
         pulumi.set(__self__, "database_instances", database_instances)
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
-        if workspace_id and not isinstance(workspace_id, str):
-            raise TypeError("Expected argument 'workspace_id' to be a str")
-        pulumi.set(__self__, "workspace_id", workspace_id)
+        if page_size and not isinstance(page_size, int):
+            raise TypeError("Expected argument 'page_size' to be a int")
+        pulumi.set(__self__, "page_size", page_size)
 
     @_builtins.property
     @pulumi.getter(name="databaseInstances")
@@ -52,9 +52,9 @@ class GetDatabaseInstancesResult:
         return pulumi.get(self, "id")
 
     @_builtins.property
-    @pulumi.getter(name="workspaceId")
-    def workspace_id(self) -> Optional[_builtins.str]:
-        return pulumi.get(self, "workspace_id")
+    @pulumi.getter(name="pageSize")
+    def page_size(self) -> Optional[_builtins.int]:
+        return pulumi.get(self, "page_size")
 
 
 class AwaitableGetDatabaseInstancesResult(GetDatabaseInstancesResult):
@@ -65,12 +65,14 @@ class AwaitableGetDatabaseInstancesResult(GetDatabaseInstancesResult):
         return GetDatabaseInstancesResult(
             database_instances=self.database_instances,
             id=self.id,
-            workspace_id=self.workspace_id)
+            page_size=self.page_size)
 
 
-def get_database_instances(workspace_id: Optional[_builtins.str] = None,
+def get_database_instances(page_size: Optional[_builtins.int] = None,
                            opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDatabaseInstancesResult:
     """
+    [![Public Preview](https://img.shields.io/badge/Release_Stage-Public_Preview-yellowgreen)](https://docs.databricks.com/aws/en/release-notes/release-types)
+
     This data source can be used to fetch the list of Database Instances within the workspace.
     The list can then be accessed via the data object's `database_instances` field.
 
@@ -87,20 +89,22 @@ def get_database_instances(workspace_id: Optional[_builtins.str] = None,
     ```
 
 
-    :param _builtins.str workspace_id: Workspace ID of the resource
+    :param _builtins.int page_size: Upper bound for items returned
     """
     __args__ = dict()
-    __args__['workspaceId'] = workspace_id
+    __args__['pageSize'] = page_size
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('databricks:index/getDatabaseInstances:getDatabaseInstances', __args__, opts=opts, typ=GetDatabaseInstancesResult).value
 
     return AwaitableGetDatabaseInstancesResult(
         database_instances=pulumi.get(__ret__, 'database_instances'),
         id=pulumi.get(__ret__, 'id'),
-        workspace_id=pulumi.get(__ret__, 'workspace_id'))
-def get_database_instances_output(workspace_id: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
+        page_size=pulumi.get(__ret__, 'page_size'))
+def get_database_instances_output(page_size: Optional[pulumi.Input[Optional[_builtins.int]]] = None,
                                   opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetDatabaseInstancesResult]:
     """
+    [![Public Preview](https://img.shields.io/badge/Release_Stage-Public_Preview-yellowgreen)](https://docs.databricks.com/aws/en/release-notes/release-types)
+
     This data source can be used to fetch the list of Database Instances within the workspace.
     The list can then be accessed via the data object's `database_instances` field.
 
@@ -117,13 +121,13 @@ def get_database_instances_output(workspace_id: Optional[pulumi.Input[Optional[_
     ```
 
 
-    :param _builtins.str workspace_id: Workspace ID of the resource
+    :param _builtins.int page_size: Upper bound for items returned
     """
     __args__ = dict()
-    __args__['workspaceId'] = workspace_id
+    __args__['pageSize'] = page_size
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('databricks:index/getDatabaseInstances:getDatabaseInstances', __args__, opts=opts, typ=GetDatabaseInstancesResult)
     return __ret__.apply(lambda __response__: GetDatabaseInstancesResult(
         database_instances=pulumi.get(__response__, 'database_instances'),
         id=pulumi.get(__response__, 'id'),
-        workspace_id=pulumi.get(__response__, 'workspace_id')))
+        page_size=pulumi.get(__response__, 'page_size')))