pulumi-oci 1.29.0a1711606977__py3-none-any.whl → 1.29.0a1711616250__py3-none-any.whl

pulumi_oci/database/outputs.py

@@ -15524,6 +15524,8 @@ class GetAutonomousDatabasesAutonomousDatabaseResult(dict):
                  allocated_storage_size_in_tbs: float,
                  apex_details: Sequence['outputs.GetAutonomousDatabasesAutonomousDatabaseApexDetailResult'],
                  are_primary_whitelisted_ips_used: bool,
+                 auto_refresh_frequency_in_seconds: int,
+                 auto_refresh_point_lag_in_seconds: int,
                  autonomous_container_database_id: str,
                  autonomous_database_backup_id: str,
                  autonomous_database_id: str,
@@ -15632,6 +15634,7 @@ class GetAutonomousDatabasesAutonomousDatabaseResult(dict):
                  time_local_data_guard_enabled: str,
                  time_maintenance_begin: str,
                  time_maintenance_end: str,
+                 time_of_auto_refresh_start: str,
                  time_of_joining_resource_pool: str,
                  time_of_last_failover: str,
                  time_of_last_refresh: str,
@@ -15652,6 +15655,8 @@ class GetAutonomousDatabasesAutonomousDatabaseResult(dict):
         :param float allocated_storage_size_in_tbs: The amount of storage currently allocated for the database tables and billed for, rounded up. When auto-scaling is not enabled, this value is equal to the `dataStorageSizeInTBs` value. You can compare this value to the `actualUsedDataStorageSizeInTBs` value to determine if a manual shrink operation is appropriate for your allocated storage.
         :param Sequence['GetAutonomousDatabasesAutonomousDatabaseApexDetailArgs'] apex_details: Information about Oracle APEX Application Development.
         :param bool are_primary_whitelisted_ips_used: This field will be null if the Autonomous Database is not Data Guard enabled or Access Control is disabled. It's value would be `TRUE` if Autonomous Database is Data Guard enabled and Access Control is enabled and if the Autonomous Database uses primary IP access control list (ACL) for standby. It's value would be `FALSE` if Autonomous Database is Data Guard enabled and Access Control is enabled and if the Autonomous Database uses different IP access control list (ACL) for standby compared to primary.
+        :param int auto_refresh_frequency_in_seconds: The frequency a refreshable clone is refreshed after auto-refresh is enabled. The minimum is 1 hour. The maximum is 7 days. The date and time that auto-refresh is enabled is controlled by the `timeOfAutoRefreshStart` parameter.
+        :param int auto_refresh_point_lag_in_seconds: The time, in seconds, the data of the refreshable clone lags the primary database at the point of refresh. The minimum is 0 minutes (0 mins means refresh to the latest available timestamp). The maximum is 7 days. The lag time increases after refreshing until the next data refresh happens.
         :param str autonomous_container_database_id: The Autonomous Container Database [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         :param str autonomous_maintenance_schedule_type: The maintenance schedule type of the Autonomous Database Serverless. An EARLY maintenance schedule follows a schedule applying patches prior to the REGULAR schedule. A REGULAR maintenance schedule follows the normal cycle
         :param Sequence[str] available_upgrade_versions: List of Oracle Database versions available for a database upgrade. If there are no version upgrades available, this list is empty.
@@ -15748,6 +15753,7 @@ class GetAutonomousDatabasesAutonomousDatabaseResult(dict):
         :param str time_local_data_guard_enabled: The date and time that Autonomous Data Guard was enabled for an Autonomous Database where the standby was provisioned in the same region as the primary database.
         :param str time_maintenance_begin: The date and time when maintenance will begin.
         :param str time_maintenance_end: The date and time when maintenance will end.
+        :param str time_of_auto_refresh_start: The the date and time that auto-refreshing will begin for an Autonomous Database refreshable clone. This value controls only the start time for the first refresh operation. Subsequent (ongoing) refresh operations have start times controlled by the value of the `autoRefreshFrequencyInSeconds` parameter.
         :param str time_of_joining_resource_pool: The time the member joined the resource pool.
         :param str time_of_last_failover: The timestamp of the last failover operation.
         :param str time_of_last_refresh: The date and time when last refresh happened.
@@ -15767,6 +15773,8 @@ class GetAutonomousDatabasesAutonomousDatabaseResult(dict):
         pulumi.set(__self__, "allocated_storage_size_in_tbs", allocated_storage_size_in_tbs)
         pulumi.set(__self__, "apex_details", apex_details)
         pulumi.set(__self__, "are_primary_whitelisted_ips_used", are_primary_whitelisted_ips_used)
+        pulumi.set(__self__, "auto_refresh_frequency_in_seconds", auto_refresh_frequency_in_seconds)
+        pulumi.set(__self__, "auto_refresh_point_lag_in_seconds", auto_refresh_point_lag_in_seconds)
         pulumi.set(__self__, "autonomous_container_database_id", autonomous_container_database_id)
         pulumi.set(__self__, "autonomous_database_backup_id", autonomous_database_backup_id)
         pulumi.set(__self__, "autonomous_database_id", autonomous_database_id)
@@ -15875,6 +15883,7 @@ class GetAutonomousDatabasesAutonomousDatabaseResult(dict):
         pulumi.set(__self__, "time_local_data_guard_enabled", time_local_data_guard_enabled)
         pulumi.set(__self__, "time_maintenance_begin", time_maintenance_begin)
         pulumi.set(__self__, "time_maintenance_end", time_maintenance_end)
+        pulumi.set(__self__, "time_of_auto_refresh_start", time_of_auto_refresh_start)
         pulumi.set(__self__, "time_of_joining_resource_pool", time_of_joining_resource_pool)
         pulumi.set(__self__, "time_of_last_failover", time_of_last_failover)
         pulumi.set(__self__, "time_of_last_refresh", time_of_last_refresh)
@@ -15928,6 +15937,22 @@ class GetAutonomousDatabasesAutonomousDatabaseResult(dict):
         """
         return pulumi.get(self, "are_primary_whitelisted_ips_used")
 
+    @property
+    @pulumi.getter(name="autoRefreshFrequencyInSeconds")
+    def auto_refresh_frequency_in_seconds(self) -> int:
+        """
+        The frequency a refreshable clone is refreshed after auto-refresh is enabled. The minimum is 1 hour. The maximum is 7 days. The date and time that auto-refresh is enabled is controlled by the `timeOfAutoRefreshStart` parameter.
+        """
+        return pulumi.get(self, "auto_refresh_frequency_in_seconds")
+
+    @property
+    @pulumi.getter(name="autoRefreshPointLagInSeconds")
+    def auto_refresh_point_lag_in_seconds(self) -> int:
+        """
+        The time, in seconds, the data of the refreshable clone lags the primary database at the point of refresh. The minimum is 0 minutes (0 mins means refresh to the latest available timestamp). The maximum is 7 days. The lag time increases after refreshing until the next data refresh happens.
+        """
+        return pulumi.get(self, "auto_refresh_point_lag_in_seconds")
+
     @property
     @pulumi.getter(name="autonomousContainerDatabaseId")
     def autonomous_container_database_id(self) -> str:
@@ -16757,6 +16782,14 @@ class GetAutonomousDatabasesAutonomousDatabaseResult(dict):
         """
         return pulumi.get(self, "time_maintenance_end")
 
+    @property
+    @pulumi.getter(name="timeOfAutoRefreshStart")
+    def time_of_auto_refresh_start(self) -> str:
+        """
+        The the date and time that auto-refreshing will begin for an Autonomous Database refreshable clone. This value controls only the start time for the first refresh operation. Subsequent (ongoing) refresh operations have start times controlled by the value of the `autoRefreshFrequencyInSeconds` parameter.
+        """
+        return pulumi.get(self, "time_of_auto_refresh_start")
+
     @property
     @pulumi.getter(name="timeOfJoiningResourcePool")
     def time_of_joining_resource_pool(self) -> str:
@@ -17636,6 +17669,8 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseResult(dict):
                  allocated_storage_size_in_tbs: float,
                  apex_details: Sequence['outputs.GetAutonomousDatabasesClonesAutonomousDatabaseApexDetailResult'],
                  are_primary_whitelisted_ips_used: bool,
+                 auto_refresh_frequency_in_seconds: int,
+                 auto_refresh_point_lag_in_seconds: int,
                  autonomous_container_database_id: str,
                  autonomous_maintenance_schedule_type: str,
                  available_upgrade_versions: Sequence[str],
@@ -17728,6 +17763,7 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseResult(dict):
                  time_local_data_guard_enabled: str,
                  time_maintenance_begin: str,
                  time_maintenance_end: str,
+                 time_of_auto_refresh_start: str,
                  time_of_joining_resource_pool: str,
                  time_of_last_failover: str,
                  time_of_last_refresh: str,
@@ -17746,7 +17782,9 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseResult(dict):
         :param float allocated_storage_size_in_tbs: The amount of storage currently allocated for the database tables and billed for, rounded up. When auto-scaling is not enabled, this value is equal to the `dataStorageSizeInTBs` value. You can compare this value to the `actualUsedDataStorageSizeInTBs` value to determine if a manual shrink operation is appropriate for your allocated storage.
         :param Sequence['GetAutonomousDatabasesClonesAutonomousDatabaseApexDetailArgs'] apex_details: Information about Oracle APEX Application Development.
         :param bool are_primary_whitelisted_ips_used: This field will be null if the Autonomous Database is not Data Guard enabled or Access Control is disabled. It's value would be `TRUE` if Autonomous Database is Data Guard enabled and Access Control is enabled and if the Autonomous Database uses primary IP access control list (ACL) for standby. It's value would be `FALSE` if Autonomous Database is Data Guard enabled and Access Control is enabled and if the Autonomous Database uses different IP access control list (ACL) for standby compared to primary.
-        :param str autonomous_container_database_id: The Autonomous Container Database [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm). Used only by Autonomous Database on Dedicated Exadata Infrastructure.
+        :param int auto_refresh_frequency_in_seconds: The frequency a refreshable clone is refreshed after auto-refresh is enabled. The minimum is 1 hour. The maximum is 7 days. The date and time that auto-refresh is enabled is controlled by the `timeOfAutoRefreshStart` parameter.
+        :param int auto_refresh_point_lag_in_seconds: The time, in seconds, the data of the refreshable clone lags the primary database at the point of refresh. The minimum is 0 minutes (0 mins means refresh to the latest available timestamp). The maximum is 7 days. The lag time increases after refreshing until the next data refresh happens.
+        :param str autonomous_container_database_id: The Autonomous Container Database [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         :param str autonomous_maintenance_schedule_type: The maintenance schedule type of the Autonomous Database Serverless. An EARLY maintenance schedule follows a schedule applying patches prior to the REGULAR schedule. A REGULAR maintenance schedule follows the normal cycle
         :param Sequence[str] available_upgrade_versions: List of Oracle Database versions available for a database upgrade. If there are no version upgrades available, this list is empty.
         :param Sequence['GetAutonomousDatabasesClonesAutonomousDatabaseBackupConfigArgs'] backup_configs: Autonomous Database configuration details for storing [manual backups](https://docs.oracle.com/en/cloud/paas/autonomous-database/adbsa/backup-restore.html#GUID-9035DFB8-4702-4CEB-8281-C2A303820809) in the [Object Storage](https://docs.cloud.oracle.com/iaas/Content/Object/Concepts/objectstorageoverview.htm) service.
@@ -17843,6 +17881,7 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseResult(dict):
         :param str time_local_data_guard_enabled: The date and time that Autonomous Data Guard was enabled for an Autonomous Database where the standby was provisioned in the same region as the primary database.
         :param str time_maintenance_begin: The date and time when maintenance will begin.
         :param str time_maintenance_end: The date and time when maintenance will end.
+        :param str time_of_auto_refresh_start: The the date and time that auto-refreshing will begin for an Autonomous Database refreshable clone. This value controls only the start time for the first refresh operation. Subsequent (ongoing) refresh operations have start times controlled by the value of the `autoRefreshFrequencyInSeconds` parameter.
         :param str time_of_last_failover: The timestamp of the last failover operation.
         :param str time_of_last_refresh: The date and time when last refresh happened.
         :param str time_of_last_refresh_point: The refresh point timestamp (UTC). The refresh point is the time to which the database was most recently refreshed. Data created after the refresh point is not included in the refresh.
@@ -17860,6 +17899,8 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseResult(dict):
         pulumi.set(__self__, "allocated_storage_size_in_tbs", allocated_storage_size_in_tbs)
         pulumi.set(__self__, "apex_details", apex_details)
         pulumi.set(__self__, "are_primary_whitelisted_ips_used", are_primary_whitelisted_ips_used)
+        pulumi.set(__self__, "auto_refresh_frequency_in_seconds", auto_refresh_frequency_in_seconds)
+        pulumi.set(__self__, "auto_refresh_point_lag_in_seconds", auto_refresh_point_lag_in_seconds)
         pulumi.set(__self__, "autonomous_container_database_id", autonomous_container_database_id)
         pulumi.set(__self__, "autonomous_maintenance_schedule_type", autonomous_maintenance_schedule_type)
         pulumi.set(__self__, "available_upgrade_versions", available_upgrade_versions)
@@ -17952,6 +17993,7 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseResult(dict):
         pulumi.set(__self__, "time_local_data_guard_enabled", time_local_data_guard_enabled)
         pulumi.set(__self__, "time_maintenance_begin", time_maintenance_begin)
         pulumi.set(__self__, "time_maintenance_end", time_maintenance_end)
+        pulumi.set(__self__, "time_of_auto_refresh_start", time_of_auto_refresh_start)
         pulumi.set(__self__, "time_of_joining_resource_pool", time_of_joining_resource_pool)
         pulumi.set(__self__, "time_of_last_failover", time_of_last_failover)
         pulumi.set(__self__, "time_of_last_refresh", time_of_last_refresh)
@@ -17998,11 +18040,27 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseResult(dict):
         """
         return pulumi.get(self, "are_primary_whitelisted_ips_used")
 
+    @property
+    @pulumi.getter(name="autoRefreshFrequencyInSeconds")
+    def auto_refresh_frequency_in_seconds(self) -> int:
+        """
+        The frequency a refreshable clone is refreshed after auto-refresh is enabled. The minimum is 1 hour. The maximum is 7 days. The date and time that auto-refresh is enabled is controlled by the `timeOfAutoRefreshStart` parameter.
+        """
+        return pulumi.get(self, "auto_refresh_frequency_in_seconds")
+
+    @property
+    @pulumi.getter(name="autoRefreshPointLagInSeconds")
+    def auto_refresh_point_lag_in_seconds(self) -> int:
+        """
+        The time, in seconds, the data of the refreshable clone lags the primary database at the point of refresh. The minimum is 0 minutes (0 mins means refresh to the latest available timestamp). The maximum is 7 days. The lag time increases after refreshing until the next data refresh happens.
+        """
+        return pulumi.get(self, "auto_refresh_point_lag_in_seconds")
+
     @property
     @pulumi.getter(name="autonomousContainerDatabaseId")
     def autonomous_container_database_id(self) -> str:
         """
-        The Autonomous Container Database [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm). Used only by Autonomous Database on Dedicated Exadata Infrastructure.
+        The Autonomous Container Database [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         """
         return pulumi.get(self, "autonomous_container_database_id")
 
@@ -18739,6 +18797,14 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseResult(dict):
         """
         return pulumi.get(self, "time_maintenance_end")
 
+    @property
+    @pulumi.getter(name="timeOfAutoRefreshStart")
+    def time_of_auto_refresh_start(self) -> str:
+        """
+        The the date and time that auto-refreshing will begin for an Autonomous Database refreshable clone. This value controls only the start time for the first refresh operation. Subsequent (ongoing) refresh operations have start times controlled by the value of the `autoRefreshFrequencyInSeconds` parameter.
+        """
+        return pulumi.get(self, "time_of_auto_refresh_start")
+
     @property
     @pulumi.getter(name="timeOfJoiningResourcePool")
     def time_of_joining_resource_pool(self) -> str:

pulumi_oci/databasemanagement/get_managed_my_sql_database.py

@@ -8,6 +8,7 @@ import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
 from .. import _utilities
+from . import outputs
 
 __all__ = [
     'GetManagedMySqlDatabaseResult',
@@ -21,7 +22,7 @@ class GetManagedMySqlDatabaseResult:
     """
     A collection of values returned by getManagedMySqlDatabase.
     """
-    def __init__(__self__, compartment_id=None, db_name=None, db_version=None, id=None, managed_my_sql_database_id=None, name=None, time_created=None):
+    def __init__(__self__, compartment_id=None, db_name=None, db_version=None, heat_wave_cluster_display_name=None, heat_wave_memory_size=None, heat_wave_node_shape=None, heat_wave_nodes=None, id=None, is_heat_wave_active=None, is_heat_wave_enabled=None, is_lakehouse_enabled=None, managed_my_sql_database_id=None, name=None, time_created=None, time_created_heat_wave=None):
         if compartment_id and not isinstance(compartment_id, str):
             raise TypeError("Expected argument 'compartment_id' to be a str")
         pulumi.set(__self__, "compartment_id", compartment_id)
@@ -31,9 +32,30 @@ class GetManagedMySqlDatabaseResult:
         if db_version and not isinstance(db_version, str):
             raise TypeError("Expected argument 'db_version' to be a str")
         pulumi.set(__self__, "db_version", db_version)
+        if heat_wave_cluster_display_name and not isinstance(heat_wave_cluster_display_name, str):
+            raise TypeError("Expected argument 'heat_wave_cluster_display_name' to be a str")
+        pulumi.set(__self__, "heat_wave_cluster_display_name", heat_wave_cluster_display_name)
+        if heat_wave_memory_size and not isinstance(heat_wave_memory_size, int):
+            raise TypeError("Expected argument 'heat_wave_memory_size' to be a int")
+        pulumi.set(__self__, "heat_wave_memory_size", heat_wave_memory_size)
+        if heat_wave_node_shape and not isinstance(heat_wave_node_shape, str):
+            raise TypeError("Expected argument 'heat_wave_node_shape' to be a str")
+        pulumi.set(__self__, "heat_wave_node_shape", heat_wave_node_shape)
+        if heat_wave_nodes and not isinstance(heat_wave_nodes, list):
+            raise TypeError("Expected argument 'heat_wave_nodes' to be a list")
+        pulumi.set(__self__, "heat_wave_nodes", heat_wave_nodes)
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
+        if is_heat_wave_active and not isinstance(is_heat_wave_active, bool):
+            raise TypeError("Expected argument 'is_heat_wave_active' to be a bool")
+        pulumi.set(__self__, "is_heat_wave_active", is_heat_wave_active)
+        if is_heat_wave_enabled and not isinstance(is_heat_wave_enabled, bool):
+            raise TypeError("Expected argument 'is_heat_wave_enabled' to be a bool")
+        pulumi.set(__self__, "is_heat_wave_enabled", is_heat_wave_enabled)
+        if is_lakehouse_enabled and not isinstance(is_lakehouse_enabled, bool):
+            raise TypeError("Expected argument 'is_lakehouse_enabled' to be a bool")
+        pulumi.set(__self__, "is_lakehouse_enabled", is_lakehouse_enabled)
         if managed_my_sql_database_id and not isinstance(managed_my_sql_database_id, str):
             raise TypeError("Expected argument 'managed_my_sql_database_id' to be a str")
         pulumi.set(__self__, "managed_my_sql_database_id", managed_my_sql_database_id)
@@ -43,6 +65,9 @@ class GetManagedMySqlDatabaseResult:
         if time_created and not isinstance(time_created, str):
             raise TypeError("Expected argument 'time_created' to be a str")
         pulumi.set(__self__, "time_created", time_created)
+        if time_created_heat_wave and not isinstance(time_created_heat_wave, str):
+            raise TypeError("Expected argument 'time_created_heat_wave' to be a str")
+        pulumi.set(__self__, "time_created_heat_wave", time_created_heat_wave)
 
     @property
     @pulumi.getter(name="compartmentId")
@@ -56,7 +81,7 @@ class GetManagedMySqlDatabaseResult:
     @pulumi.getter(name="dbName")
     def db_name(self) -> str:
         """
-        MySQL Database Name
+        The name of the MySQL Database.
         """
         return pulumi.get(self, "db_name")
 
@@ -64,10 +89,42 @@ class GetManagedMySqlDatabaseResult:
     @pulumi.getter(name="dbVersion")
     def db_version(self) -> str:
         """
-        MySQL Database Version
+        The version of the MySQL Database.
         """
         return pulumi.get(self, "db_version")
 
+    @property
+    @pulumi.getter(name="heatWaveClusterDisplayName")
+    def heat_wave_cluster_display_name(self) -> str:
+        """
+        The name of the HeatWave cluster.
+        """
+        return pulumi.get(self, "heat_wave_cluster_display_name")
+
+    @property
+    @pulumi.getter(name="heatWaveMemorySize")
+    def heat_wave_memory_size(self) -> int:
+        """
+        The total memory belonging to the HeatWave cluster in GBs.
+        """
+        return pulumi.get(self, "heat_wave_memory_size")
+
+    @property
+    @pulumi.getter(name="heatWaveNodeShape")
+    def heat_wave_node_shape(self) -> str:
+        """
+        Shape of the nodes in the HeatWave cluster.
+        """
+        return pulumi.get(self, "heat_wave_node_shape")
+
+    @property
+    @pulumi.getter(name="heatWaveNodes")
+    def heat_wave_nodes(self) -> Sequence['outputs.GetManagedMySqlDatabaseHeatWaveNodeResult']:
+        """
+        The information about an individual HeatWave nodes in the cluster.
+        """
+        return pulumi.get(self, "heat_wave_nodes")
+
     @property
     @pulumi.getter
     def id(self) -> str:
@@ -76,6 +133,30 @@ class GetManagedMySqlDatabaseResult:
         """
         return pulumi.get(self, "id")
 
+    @property
+    @pulumi.getter(name="isHeatWaveActive")
+    def is_heat_wave_active(self) -> bool:
+        """
+        If the HeatWave cluster is active or not.
+        """
+        return pulumi.get(self, "is_heat_wave_active")
+
+    @property
+    @pulumi.getter(name="isHeatWaveEnabled")
+    def is_heat_wave_enabled(self) -> bool:
+        """
+        If HeatWave is enabled for this db system or not.
+        """
+        return pulumi.get(self, "is_heat_wave_enabled")
+
+    @property
+    @pulumi.getter(name="isLakehouseEnabled")
+    def is_lakehouse_enabled(self) -> bool:
+        """
+        If HeatWave Lakehouse is enabled for the db system or not.
+        """
+        return pulumi.get(self, "is_lakehouse_enabled")
+
     @property
     @pulumi.getter(name="managedMySqlDatabaseId")
     def managed_my_sql_database_id(self) -> str:
@@ -93,10 +174,18 @@ class GetManagedMySqlDatabaseResult:
     @pulumi.getter(name="timeCreated")
     def time_created(self) -> str:
         """
-        The date and time the Managed Database was created.
+        The date and time the node was created.
         """
         return pulumi.get(self, "time_created")
 
+    @property
+    @pulumi.getter(name="timeCreatedHeatWave")
+    def time_created_heat_wave(self) -> str:
+        """
+        The date and time the Managed MySQL Database was created.
+        """
+        return pulumi.get(self, "time_created_heat_wave")
+
 
 class AwaitableGetManagedMySqlDatabaseResult(GetManagedMySqlDatabaseResult):
     # pylint: disable=using-constant-test
@@ -107,10 +196,18 @@ class AwaitableGetManagedMySqlDatabaseResult(GetManagedMySqlDatabaseResult):
             compartment_id=self.compartment_id,
             db_name=self.db_name,
             db_version=self.db_version,
+            heat_wave_cluster_display_name=self.heat_wave_cluster_display_name,
+            heat_wave_memory_size=self.heat_wave_memory_size,
+            heat_wave_node_shape=self.heat_wave_node_shape,
+            heat_wave_nodes=self.heat_wave_nodes,
             id=self.id,
+            is_heat_wave_active=self.is_heat_wave_active,
+            is_heat_wave_enabled=self.is_heat_wave_enabled,
+            is_lakehouse_enabled=self.is_lakehouse_enabled,
             managed_my_sql_database_id=self.managed_my_sql_database_id,
             name=self.name,
-            time_created=self.time_created)
+            time_created=self.time_created,
+            time_created_heat_wave=self.time_created_heat_wave)
 
 
 def get_managed_my_sql_database(managed_my_sql_database_id: Optional[str] = None,
@@ -143,10 +240,18 @@ def get_managed_my_sql_database(managed_my_sql_database_id: Optional[str] = None
         compartment_id=pulumi.get(__ret__, 'compartment_id'),
         db_name=pulumi.get(__ret__, 'db_name'),
         db_version=pulumi.get(__ret__, 'db_version'),
+        heat_wave_cluster_display_name=pulumi.get(__ret__, 'heat_wave_cluster_display_name'),
+        heat_wave_memory_size=pulumi.get(__ret__, 'heat_wave_memory_size'),
+        heat_wave_node_shape=pulumi.get(__ret__, 'heat_wave_node_shape'),
+        heat_wave_nodes=pulumi.get(__ret__, 'heat_wave_nodes'),
         id=pulumi.get(__ret__, 'id'),
+        is_heat_wave_active=pulumi.get(__ret__, 'is_heat_wave_active'),
+        is_heat_wave_enabled=pulumi.get(__ret__, 'is_heat_wave_enabled'),
+        is_lakehouse_enabled=pulumi.get(__ret__, 'is_lakehouse_enabled'),
         managed_my_sql_database_id=pulumi.get(__ret__, 'managed_my_sql_database_id'),
         name=pulumi.get(__ret__, 'name'),
-        time_created=pulumi.get(__ret__, 'time_created'))
+        time_created=pulumi.get(__ret__, 'time_created'),
+        time_created_heat_wave=pulumi.get(__ret__, 'time_created_heat_wave'))
 
 
 @_utilities.lift_output_func(get_managed_my_sql_database)

pulumi_oci/databasemanagement/get_managed_my_sql_database_sql_data.py

@@ -130,8 +130,22 @@ def get_managed_my_sql_database_sql_data(end_time: Optional[str] = None,
 
 
     :param str end_time: The end time of the time range to retrieve the health metrics of a Managed Database in UTC in ISO-8601 format, which is "yyyy-MM-dd'T'hh:mm:ss.sss'Z'".
-    :param str filter_column: The parameter to filter results by key criteria.
-    :param str managed_my_sql_database_id: The OCID of ManagedMySqlDatabase.
+    :param str filter_column: The parameter to filter results by key criteria which include :
+           * AVG_TIMER_WAIT
+           * SUM_TIMER_WAIT
+           * COUNT_STAR
+           * SUM_ERRORS
+           * SUM_ROWS_AFFECTED
+           * SUM_ROWS_SENT
+           * SUM_ROWS_EXAMINED
+           * SUM_CREATED_TMP_TABLES
+           * SUM_NO_INDEX_USED
+           * SUM_NO_GOOD_INDEX_USED
+           * FIRST_SEEN
+           * LAST_SEEN
+           * HEATWAVE_OFFLOADED
+           * HEATWAVE_OUT_OF_MEMORY
+    :param str managed_my_sql_database_id: The OCID of the Managed MySQL Database.
     :param str start_time: The start time of the time range to retrieve the health metrics of a Managed Database in UTC in ISO-8601 format, which is "yyyy-MM-dd'T'hh:mm:ss.sss'Z'".
     """
     __args__ = dict()
@@ -181,8 +195,22 @@ def get_managed_my_sql_database_sql_data_output(end_time: Optional[pulumi.Input[
 
 
     :param str end_time: The end time of the time range to retrieve the health metrics of a Managed Database in UTC in ISO-8601 format, which is "yyyy-MM-dd'T'hh:mm:ss.sss'Z'".
-    :param str filter_column: The parameter to filter results by key criteria.
-    :param str managed_my_sql_database_id: The OCID of ManagedMySqlDatabase.
+    :param str filter_column: The parameter to filter results by key criteria which include :
+           * AVG_TIMER_WAIT
+           * SUM_TIMER_WAIT
+           * COUNT_STAR
+           * SUM_ERRORS
+           * SUM_ROWS_AFFECTED
+           * SUM_ROWS_SENT
+           * SUM_ROWS_EXAMINED
+           * SUM_CREATED_TMP_TABLES
+           * SUM_NO_INDEX_USED
+           * SUM_NO_GOOD_INDEX_USED
+           * FIRST_SEEN
+           * LAST_SEEN
+           * HEATWAVE_OFFLOADED
+           * HEATWAVE_OUT_OF_MEMORY
+    :param str managed_my_sql_database_id: The OCID of the Managed MySQL Database.
     :param str start_time: The start time of the time range to retrieve the health metrics of a Managed Database in UTC in ISO-8601 format, which is "yyyy-MM-dd'T'hh:mm:ss.sss'Z'".
     """
     ...