pulumi-gcp 8.42.0a1756925793__py3-none-any.whl → 9.0.0a1__py3-none-any.whl

pulumi_gcp/bigquery/_inputs.py

@@ -111,6 +111,8 @@ __all__ = [
     'JobLoadTimePartitioningArgsDict',
     'JobQueryArgs',
     'JobQueryArgsDict',
+    'JobQueryConnectionPropertyArgs',
+    'JobQueryConnectionPropertyArgsDict',
     'JobQueryDefaultDatasetArgs',
     'JobQueryDefaultDatasetArgsDict',
     'JobQueryDestinationEncryptionConfigurationArgs',
@@ -1406,18 +1408,26 @@ if not MYPY:
         """
         The Secret Access Key of the AWS account transferring data from.
         """
+        secret_access_key_wo_version: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The version of the sensitive params - used to trigger updates of the write-only params. For more info see [updating write-only attributes](https://www.terraform.io/docs/providers/google/guides/using_write_only_attributes.html#updating-write-only-attributes)
+        """
 elif False:
     DataTransferConfigSensitiveParamsArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class DataTransferConfigSensitiveParamsArgs:
     def __init__(__self__, *,
-                 secret_access_key: Optional[pulumi.Input[_builtins.str]] = None):
+                 secret_access_key: Optional[pulumi.Input[_builtins.str]] = None,
+                 secret_access_key_wo_version: Optional[pulumi.Input[_builtins.int]] = None):
         """
         :param pulumi.Input[_builtins.str] secret_access_key: The Secret Access Key of the AWS account transferring data from.
+        :param pulumi.Input[_builtins.int] secret_access_key_wo_version: The version of the sensitive params - used to trigger updates of the write-only params. For more info see [updating write-only attributes](https://www.terraform.io/docs/providers/google/guides/using_write_only_attributes.html#updating-write-only-attributes)
         """
         if secret_access_key is not None:
             pulumi.set(__self__, "secret_access_key", secret_access_key)
+        if secret_access_key_wo_version is not None:
+            pulumi.set(__self__, "secret_access_key_wo_version", secret_access_key_wo_version)
 
     @_builtins.property
     @pulumi.getter(name="secretAccessKey")
@@ -1431,6 +1441,18 @@ class DataTransferConfigSensitiveParamsArgs:
     def secret_access_key(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "secret_access_key", value)
 
+    @_builtins.property
+    @pulumi.getter(name="secretAccessKeyWoVersion")
+    def secret_access_key_wo_version(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The version of the sensitive params - used to trigger updates of the write-only params. For more info see [updating write-only attributes](https://www.terraform.io/docs/providers/google/guides/using_write_only_attributes.html#updating-write-only-attributes)
+        """
+        return pulumi.get(self, "secret_access_key_wo_version")
+
+    @secret_access_key_wo_version.setter
+    def secret_access_key_wo_version(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "secret_access_key_wo_version", value)
+
 
 if not MYPY:
     class DatasetAccessArgsDict(TypedDict):
@@ -4097,6 +4119,13 @@ if not MYPY:
         Requires destinationTable to be set. For standard SQL queries, this flag is ignored and large results are always allowed.
         However, you must still set destinationTable when result size exceeds the allowed maximum response size.
         """
+        connection_properties: NotRequired[pulumi.Input[Sequence[pulumi.Input['JobQueryConnectionPropertyArgsDict']]]]
+        """
+        Connection properties to customize query behavior. Under JDBC, these correspond
+        directly to connection properties passed to the DriverManager. Under ODBC, these
+        correspond to properties in the connection string.
+        Structure is documented below.
+        """
         continuous: NotRequired[pulumi.Input[_builtins.bool]]
         """
         Whether to run the query as continuous or a regular query.
@@ -4202,6 +4231,7 @@ class JobQueryArgs:
     def __init__(__self__, *,
                  query: pulumi.Input[_builtins.str],
                  allow_large_results: Optional[pulumi.Input[_builtins.bool]] = None,
+                 connection_properties: Optional[pulumi.Input[Sequence[pulumi.Input['JobQueryConnectionPropertyArgs']]]] = None,
                  continuous: Optional[pulumi.Input[_builtins.bool]] = None,
                  create_disposition: Optional[pulumi.Input[_builtins.str]] = None,
                  default_dataset: Optional[pulumi.Input['JobQueryDefaultDatasetArgs']] = None,
@@ -4225,6 +4255,10 @@ class JobQueryArgs:
         :param pulumi.Input[_builtins.bool] allow_large_results: If true and query uses legacy SQL dialect, allows the query to produce arbitrarily large result tables at a slight cost in performance.
                Requires destinationTable to be set. For standard SQL queries, this flag is ignored and large results are always allowed.
                However, you must still set destinationTable when result size exceeds the allowed maximum response size.
+        :param pulumi.Input[Sequence[pulumi.Input['JobQueryConnectionPropertyArgs']]] connection_properties: Connection properties to customize query behavior. Under JDBC, these correspond
+               directly to connection properties passed to the DriverManager. Under ODBC, these
+               correspond to properties in the connection string.
+               Structure is documented below.
         :param pulumi.Input[_builtins.bool] continuous: Whether to run the query as continuous or a regular query.
         :param pulumi.Input[_builtins.str] create_disposition: Specifies whether the job is allowed to create new tables. The following values are supported:
                CREATE_IF_NEEDED: If the table does not exist, BigQuery creates the table.
@@ -4278,6 +4312,8 @@ class JobQueryArgs:
         pulumi.set(__self__, "query", query)
         if allow_large_results is not None:
             pulumi.set(__self__, "allow_large_results", allow_large_results)
+        if connection_properties is not None:
+            pulumi.set(__self__, "connection_properties", connection_properties)
         if continuous is not None:
             pulumi.set(__self__, "continuous", continuous)
         if create_disposition is not None:
@@ -4339,6 +4375,21 @@ class JobQueryArgs:
     def allow_large_results(self, value: Optional[pulumi.Input[_builtins.bool]]):
         pulumi.set(self, "allow_large_results", value)
 
+    @_builtins.property
+    @pulumi.getter(name="connectionProperties")
+    def connection_properties(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['JobQueryConnectionPropertyArgs']]]]:
+        """
+        Connection properties to customize query behavior. Under JDBC, these correspond
+        directly to connection properties passed to the DriverManager. Under ODBC, these
+        correspond to properties in the connection string.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "connection_properties")
+
+    @connection_properties.setter
+    def connection_properties(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['JobQueryConnectionPropertyArgs']]]]):
+        pulumi.set(self, "connection_properties", value)
+
     @_builtins.property
     @pulumi.getter
     def continuous(self) -> Optional[pulumi.Input[_builtins.bool]]:
@@ -4565,6 +4616,56 @@ class JobQueryArgs:
         pulumi.set(self, "write_disposition", value)
 
 
+if not MYPY:
+    class JobQueryConnectionPropertyArgsDict(TypedDict):
+        key: pulumi.Input[_builtins.str]
+        """
+        The key of the property to set. Currently supported connection properties:
+        """
+        value: pulumi.Input[_builtins.str]
+        """
+        The value of the property to set.
+        """
+elif False:
+    JobQueryConnectionPropertyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class JobQueryConnectionPropertyArgs:
+    def __init__(__self__, *,
+                 key: pulumi.Input[_builtins.str],
+                 value: pulumi.Input[_builtins.str]):
+        """
+        :param pulumi.Input[_builtins.str] key: The key of the property to set. Currently supported connection properties:
+        :param pulumi.Input[_builtins.str] value: The value of the property to set.
+        """
+        pulumi.set(__self__, "key", key)
+        pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def key(self) -> pulumi.Input[_builtins.str]:
+        """
+        The key of the property to set. Currently supported connection properties:
+        """
+        return pulumi.get(self, "key")
+
+    @key.setter
+    def key(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "key", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> pulumi.Input[_builtins.str]:
+        """
+        The value of the property to set.
+        """
+        return pulumi.get(self, "value")
+
+    @value.setter
+    def value(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "value", value)
+
+
 if not MYPY:
     class JobQueryDefaultDatasetArgsDict(TypedDict):
         dataset_id: pulumi.Input[_builtins.str]
@@ -8386,7 +8487,10 @@ if not MYPY:
         use_legacy_sql: NotRequired[pulumi.Input[_builtins.bool]]
         """
         Specifies whether to use BigQuery's legacy SQL for this view.
-        The default value is true. If set to false, the view will use BigQuery's standard SQL.
+        If set to `false`, the view will use BigQuery's standard SQL. If set to
+        `true`, the view will use BigQuery's legacy SQL. If unset, the API will
+        interpret it as a `true` and assumes the legacy SQL dialect for its query
+        according to the [API documentation](https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#ViewDefinition).
         > **Note**: Starting in provider version `7.0.0`, no default value is
         provided for this field unless explicitly set in the configuration.
         """
@@ -8401,7 +8505,10 @@ class TableViewArgs:
         """
         :param pulumi.Input[_builtins.str] query: A query that BigQuery executes when the view is referenced.
         :param pulumi.Input[_builtins.bool] use_legacy_sql: Specifies whether to use BigQuery's legacy SQL for this view.
-               The default value is true. If set to false, the view will use BigQuery's standard SQL.
+               If set to `false`, the view will use BigQuery's standard SQL. If set to
+               `true`, the view will use BigQuery's legacy SQL. If unset, the API will
+               interpret it as a `true` and assumes the legacy SQL dialect for its query
+               according to the [API documentation](https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#ViewDefinition).
                > **Note**: Starting in provider version `7.0.0`, no default value is
                provided for this field unless explicitly set in the configuration.
         """
@@ -8426,7 +8533,10 @@ class TableViewArgs:
     def use_legacy_sql(self) -> Optional[pulumi.Input[_builtins.bool]]:
         """
         Specifies whether to use BigQuery's legacy SQL for this view.
-        The default value is true. If set to false, the view will use BigQuery's standard SQL.
+        If set to `false`, the view will use BigQuery's standard SQL. If set to
+        `true`, the view will use BigQuery's legacy SQL. If unset, the API will
+        interpret it as a `true` and assumes the legacy SQL dialect for its query
+        according to the [API documentation](https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#ViewDefinition).
         > **Note**: Starting in provider version `7.0.0`, no default value is
         provided for this field unless explicitly set in the configuration.
         """

pulumi_gcp/bigquery/app_profile.py

@@ -40,13 +40,18 @@ class AppProfileArgs:
         :param pulumi.Input[_builtins.str] description: Long form description of the use case for this app profile.
         :param pulumi.Input[_builtins.bool] ignore_warnings: If true, ignore safety checks when deleting/updating the app profile.
         :param pulumi.Input[_builtins.str] instance: The name of the instance to create the app profile within.
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] multi_cluster_routing_cluster_ids: The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all clusters are eligible.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] multi_cluster_routing_cluster_ids: The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all
+               clusters are eligible.
         :param pulumi.Input[_builtins.bool] multi_cluster_routing_use_any: If true, read/write requests are routed to the nearest cluster in the instance, and will fail over to the nearest cluster that is available
                in the event of transient errors or delays. Clusters in a region are considered equidistant. Choosing this option sacrifices read-your-writes
                consistency to improve availability.
         :param pulumi.Input[_builtins.str] project: The ID of the project in which the resource belongs.
                If it is not provided, the provider project is used.
-        :param pulumi.Input[_builtins.bool] row_affinity: Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
+        :param pulumi.Input[_builtins.bool] row_affinity: Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row
+               affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key
+               will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves
+               read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency
+               is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
         :param pulumi.Input['AppProfileSingleClusterRoutingArgs'] single_cluster_routing: Use a single-cluster routing policy.
                Structure is documented below.
         :param pulumi.Input['AppProfileStandardIsolationArgs'] standard_isolation: The standard options used for isolating this app profile's traffic from other use cases.
@@ -139,7 +144,8 @@ class AppProfileArgs:
     @pulumi.getter(name="multiClusterRoutingClusterIds")
     def multi_cluster_routing_cluster_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
         """
-        The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all clusters are eligible.
+        The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all
+        clusters are eligible.
         """
         return pulumi.get(self, "multi_cluster_routing_cluster_ids")
 
@@ -178,7 +184,11 @@ class AppProfileArgs:
     @pulumi.getter(name="rowAffinity")
     def row_affinity(self) -> Optional[pulumi.Input[_builtins.bool]]:
         """
-        Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
+        Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row
+        affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key
+        will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves
+        read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency
+        is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
         """
         return pulumi.get(self, "row_affinity")
 
@@ -236,14 +246,19 @@ class _AppProfileState:
         :param pulumi.Input[_builtins.str] description: Long form description of the use case for this app profile.
         :param pulumi.Input[_builtins.bool] ignore_warnings: If true, ignore safety checks when deleting/updating the app profile.
         :param pulumi.Input[_builtins.str] instance: The name of the instance to create the app profile within.
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] multi_cluster_routing_cluster_ids: The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all clusters are eligible.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] multi_cluster_routing_cluster_ids: The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all
+               clusters are eligible.
         :param pulumi.Input[_builtins.bool] multi_cluster_routing_use_any: If true, read/write requests are routed to the nearest cluster in the instance, and will fail over to the nearest cluster that is available
                in the event of transient errors or delays. Clusters in a region are considered equidistant. Choosing this option sacrifices read-your-writes
                consistency to improve availability.
         :param pulumi.Input[_builtins.str] name: The unique name of the requested app profile. Values are of the form `projects/<project>/instances/<instance>/appProfiles/<appProfileId>`.
         :param pulumi.Input[_builtins.str] project: The ID of the project in which the resource belongs.
                If it is not provided, the provider project is used.
-        :param pulumi.Input[_builtins.bool] row_affinity: Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
+        :param pulumi.Input[_builtins.bool] row_affinity: Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row
+               affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key
+               will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves
+               read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency
+               is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
         :param pulumi.Input['AppProfileSingleClusterRoutingArgs'] single_cluster_routing: Use a single-cluster routing policy.
                Structure is documented below.
         :param pulumi.Input['AppProfileStandardIsolationArgs'] standard_isolation: The standard options used for isolating this app profile's traffic from other use cases.
@@ -339,7 +354,8 @@ class _AppProfileState:
     @pulumi.getter(name="multiClusterRoutingClusterIds")
     def multi_cluster_routing_cluster_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
         """
-        The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all clusters are eligible.
+        The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all
+        clusters are eligible.
         """
         return pulumi.get(self, "multi_cluster_routing_cluster_ids")
 
@@ -390,7 +406,11 @@ class _AppProfileState:
     @pulumi.getter(name="rowAffinity")
     def row_affinity(self) -> Optional[pulumi.Input[_builtins.bool]]:
         """
-        Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
+        Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row
+        affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key
+        will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves
+        read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency
+        is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
         """
         return pulumi.get(self, "row_affinity")
 
@@ -425,12 +445,12 @@ class _AppProfileState:
         pulumi.set(self, "standard_isolation", value)
 
 
-warnings.warn("""gcp.bigquery/appprofile.AppProfile has been deprecated in favor of gcp.bigtable/appprofile.AppProfile""", DeprecationWarning)
+warnings.warn("""gcp.bigquery.AppProfile has been deprecated in favor of gcp.bigtable.AppProfile""", DeprecationWarning)
 
 
 @pulumi.type_token("gcp:bigquery/appProfile:AppProfile")
 class AppProfile(pulumi.CustomResource):
-    warnings.warn("""gcp.bigquery/appprofile.AppProfile has been deprecated in favor of gcp.bigtable/appprofile.AppProfile""", DeprecationWarning)
+    warnings.warn("""gcp.bigquery.AppProfile has been deprecated in favor of gcp.bigtable.AppProfile""", DeprecationWarning)
 
     @overload
     def __init__(__self__,
@@ -615,13 +635,18 @@ class AppProfile(pulumi.CustomResource):
         :param pulumi.Input[_builtins.str] description: Long form description of the use case for this app profile.
         :param pulumi.Input[_builtins.bool] ignore_warnings: If true, ignore safety checks when deleting/updating the app profile.
         :param pulumi.Input[_builtins.str] instance: The name of the instance to create the app profile within.
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] multi_cluster_routing_cluster_ids: The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all clusters are eligible.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] multi_cluster_routing_cluster_ids: The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all
+               clusters are eligible.
         :param pulumi.Input[_builtins.bool] multi_cluster_routing_use_any: If true, read/write requests are routed to the nearest cluster in the instance, and will fail over to the nearest cluster that is available
                in the event of transient errors or delays. Clusters in a region are considered equidistant. Choosing this option sacrifices read-your-writes
                consistency to improve availability.
         :param pulumi.Input[_builtins.str] project: The ID of the project in which the resource belongs.
                If it is not provided, the provider project is used.
-        :param pulumi.Input[_builtins.bool] row_affinity: Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
+        :param pulumi.Input[_builtins.bool] row_affinity: Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row
+               affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key
+               will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves
+               read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency
+               is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
         :param pulumi.Input[Union['AppProfileSingleClusterRoutingArgs', 'AppProfileSingleClusterRoutingArgsDict']] single_cluster_routing: Use a single-cluster routing policy.
                Structure is documented below.
         :param pulumi.Input[Union['AppProfileStandardIsolationArgs', 'AppProfileStandardIsolationArgsDict']] standard_isolation: The standard options used for isolating this app profile's traffic from other use cases.
@@ -819,7 +844,7 @@ class AppProfile(pulumi.CustomResource):
                  single_cluster_routing: Optional[pulumi.Input[Union['AppProfileSingleClusterRoutingArgs', 'AppProfileSingleClusterRoutingArgsDict']]] = None,
                  standard_isolation: Optional[pulumi.Input[Union['AppProfileStandardIsolationArgs', 'AppProfileStandardIsolationArgsDict']]] = None,
                  __props__=None):
-        pulumi.log.warn("""AppProfile is deprecated: gcp.bigquery/appprofile.AppProfile has been deprecated in favor of gcp.bigtable/appprofile.AppProfile""")
+        pulumi.log.warn("""AppProfile is deprecated: gcp.bigquery.AppProfile has been deprecated in favor of gcp.bigtable.AppProfile""")
         opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
         if not isinstance(opts, pulumi.ResourceOptions):
             raise TypeError('Expected resource options to be a ResourceOptions instance')
@@ -842,8 +867,6 @@ class AppProfile(pulumi.CustomResource):
             __props__.__dict__["single_cluster_routing"] = single_cluster_routing
             __props__.__dict__["standard_isolation"] = standard_isolation
             __props__.__dict__["name"] = None
-        alias_opts = pulumi.ResourceOptions(aliases=[pulumi.Alias(type_="gcp:bigquery/appProfile:AppProfile")])
-        opts = pulumi.ResourceOptions.merge(opts, alias_opts)
         super(AppProfile, __self__).__init__(
             'gcp:bigquery/appProfile:AppProfile',
             resource_name,
@@ -879,14 +902,19 @@ class AppProfile(pulumi.CustomResource):
         :param pulumi.Input[_builtins.str] description: Long form description of the use case for this app profile.
         :param pulumi.Input[_builtins.bool] ignore_warnings: If true, ignore safety checks when deleting/updating the app profile.
         :param pulumi.Input[_builtins.str] instance: The name of the instance to create the app profile within.
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] multi_cluster_routing_cluster_ids: The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all clusters are eligible.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] multi_cluster_routing_cluster_ids: The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all
+               clusters are eligible.
         :param pulumi.Input[_builtins.bool] multi_cluster_routing_use_any: If true, read/write requests are routed to the nearest cluster in the instance, and will fail over to the nearest cluster that is available
                in the event of transient errors or delays. Clusters in a region are considered equidistant. Choosing this option sacrifices read-your-writes
                consistency to improve availability.
         :param pulumi.Input[_builtins.str] name: The unique name of the requested app profile. Values are of the form `projects/<project>/instances/<instance>/appProfiles/<appProfileId>`.
         :param pulumi.Input[_builtins.str] project: The ID of the project in which the resource belongs.
                If it is not provided, the provider project is used.
-        :param pulumi.Input[_builtins.bool] row_affinity: Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
+        :param pulumi.Input[_builtins.bool] row_affinity: Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row
+               affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key
+               will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves
+               read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency
+               is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
         :param pulumi.Input[Union['AppProfileSingleClusterRoutingArgs', 'AppProfileSingleClusterRoutingArgsDict']] single_cluster_routing: Use a single-cluster routing policy.
                Structure is documented below.
         :param pulumi.Input[Union['AppProfileStandardIsolationArgs', 'AppProfileStandardIsolationArgsDict']] standard_isolation: The standard options used for isolating this app profile's traffic from other use cases.
@@ -955,7 +983,8 @@ class AppProfile(pulumi.CustomResource):
     @pulumi.getter(name="multiClusterRoutingClusterIds")
     def multi_cluster_routing_cluster_ids(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
         """
-        The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all clusters are eligible.
+        The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all
+        clusters are eligible.
         """
         return pulumi.get(self, "multi_cluster_routing_cluster_ids")
 
@@ -990,7 +1019,11 @@ class AppProfile(pulumi.CustomResource):
     @pulumi.getter(name="rowAffinity")
     def row_affinity(self) -> pulumi.Output[Optional[_builtins.bool]]:
         """
-        Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
+        Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row
+        affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key
+        will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves
+        read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency
+        is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
         """
         return pulumi.get(self, "row_affinity")
 

pulumi_gcp/bigquery/dataset_access.py

@@ -291,7 +291,8 @@ class _DatasetAccessState:
                  view: Optional[pulumi.Input['DatasetAccessViewArgs']] = None):
         """
         Input properties used for looking up and filtering DatasetAccess resources.
-        :param pulumi.Input[_builtins.bool] api_updated_member: If true, represents that that the iam_member in the config was translated to a different member type by the API, and is stored in state as a different member type
+        :param pulumi.Input[_builtins.bool] api_updated_member: If true, represents that that the iam_member in the config was translated to a different member type by the API, and is
+               stored in state as a different member type
         :param pulumi.Input['DatasetAccessAuthorizedDatasetArgs'] authorized_dataset: Grants all resources of particular types in a particular dataset read access to the current dataset.
                Structure is documented below.
         :param pulumi.Input['DatasetAccessConditionArgs'] condition: Condition for the binding. If CEL expression in this field is true, this
@@ -364,7 +365,8 @@ class _DatasetAccessState:
     @pulumi.getter(name="apiUpdatedMember")
     def api_updated_member(self) -> Optional[pulumi.Input[_builtins.bool]]:
         """
-        If true, represents that that the iam_member in the config was translated to a different member type by the API, and is stored in state as a different member type
+        If true, represents that that the iam_member in the config was translated to a different member type by the API, and is
+        stored in state as a different member type
         """
         return pulumi.get(self, "api_updated_member")
 
@@ -904,7 +906,8 @@ class DatasetAccess(pulumi.CustomResource):
         :param str resource_name: The unique name of the resulting resource.
         :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
         :param pulumi.ResourceOptions opts: Options for the resource.
-        :param pulumi.Input[_builtins.bool] api_updated_member: If true, represents that that the iam_member in the config was translated to a different member type by the API, and is stored in state as a different member type
+        :param pulumi.Input[_builtins.bool] api_updated_member: If true, represents that that the iam_member in the config was translated to a different member type by the API, and is
+               stored in state as a different member type
         :param pulumi.Input[Union['DatasetAccessAuthorizedDatasetArgs', 'DatasetAccessAuthorizedDatasetArgsDict']] authorized_dataset: Grants all resources of particular types in a particular dataset read access to the current dataset.
                Structure is documented below.
         :param pulumi.Input[Union['DatasetAccessConditionArgs', 'DatasetAccessConditionArgsDict']] condition: Condition for the binding. If CEL expression in this field is true, this
@@ -969,7 +972,8 @@ class DatasetAccess(pulumi.CustomResource):
     @pulumi.getter(name="apiUpdatedMember")
     def api_updated_member(self) -> pulumi.Output[_builtins.bool]:
         """
-        If true, represents that that the iam_member in the config was translated to a different member type by the API, and is stored in state as a different member type
+        If true, represents that that the iam_member in the config was translated to a different member type by the API, and is
+        stored in state as a different member type
         """
         return pulumi.get(self, "api_updated_member")
 

pulumi_gcp/bigquery/outputs.py

@@ -64,6 +64,7 @@ __all__ = [
     'JobLoadParquetOptions',
     'JobLoadTimePartitioning',
     'JobQuery',
+    'JobQueryConnectionProperty',
     'JobQueryDefaultDataset',
     'JobQueryDestinationEncryptionConfiguration',
     'JobQueryDestinationTable',
@@ -1154,6 +1155,8 @@ class DataTransferConfigSensitiveParams(dict):
         suggest = None
         if key == "secretAccessKey":
             suggest = "secret_access_key"
+        elif key == "secretAccessKeyWoVersion":
+            suggest = "secret_access_key_wo_version"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in DataTransferConfigSensitiveParams. Access the value via the '{suggest}' property getter instead.")
@@ -1167,12 +1170,16 @@ class DataTransferConfigSensitiveParams(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 secret_access_key: Optional[_builtins.str] = None):
+                 secret_access_key: Optional[_builtins.str] = None,
+                 secret_access_key_wo_version: Optional[_builtins.int] = None):
         """
         :param _builtins.str secret_access_key: The Secret Access Key of the AWS account transferring data from.
+        :param _builtins.int secret_access_key_wo_version: The version of the sensitive params - used to trigger updates of the write-only params. For more info see [updating write-only attributes](https://www.terraform.io/docs/providers/google/guides/using_write_only_attributes.html#updating-write-only-attributes)
         """
         if secret_access_key is not None:
             pulumi.set(__self__, "secret_access_key", secret_access_key)
+        if secret_access_key_wo_version is not None:
+            pulumi.set(__self__, "secret_access_key_wo_version", secret_access_key_wo_version)
 
     @_builtins.property
     @pulumi.getter(name="secretAccessKey")
@@ -1182,6 +1189,14 @@ class DataTransferConfigSensitiveParams(dict):
         """
         return pulumi.get(self, "secret_access_key")
 
+    @_builtins.property
+    @pulumi.getter(name="secretAccessKeyWoVersion")
+    def secret_access_key_wo_version(self) -> Optional[_builtins.int]:
+        """
+        The version of the sensitive params - used to trigger updates of the write-only params. For more info see [updating write-only attributes](https://www.terraform.io/docs/providers/google/guides/using_write_only_attributes.html#updating-write-only-attributes)
+        """
+        return pulumi.get(self, "secret_access_key_wo_version")
+
 
 @pulumi.output_type
 class DatasetAccess(dict):
@@ -3257,6 +3272,8 @@ class JobQuery(dict):
         suggest = None
         if key == "allowLargeResults":
             suggest = "allow_large_results"
+        elif key == "connectionProperties":
+            suggest = "connection_properties"
         elif key == "createDisposition":
             suggest = "create_disposition"
         elif key == "defaultDataset":
@@ -3300,6 +3317,7 @@ class JobQuery(dict):
     def __init__(__self__, *,
                  query: _builtins.str,
                  allow_large_results: Optional[_builtins.bool] = None,
+                 connection_properties: Optional[Sequence['outputs.JobQueryConnectionProperty']] = None,
                  continuous: Optional[_builtins.bool] = None,
                  create_disposition: Optional[_builtins.str] = None,
                  default_dataset: Optional['outputs.JobQueryDefaultDataset'] = None,
@@ -3323,6 +3341,10 @@ class JobQuery(dict):
         :param _builtins.bool allow_large_results: If true and query uses legacy SQL dialect, allows the query to produce arbitrarily large result tables at a slight cost in performance.
                Requires destinationTable to be set. For standard SQL queries, this flag is ignored and large results are always allowed.
                However, you must still set destinationTable when result size exceeds the allowed maximum response size.
+        :param Sequence['JobQueryConnectionPropertyArgs'] connection_properties: Connection properties to customize query behavior. Under JDBC, these correspond
+               directly to connection properties passed to the DriverManager. Under ODBC, these
+               correspond to properties in the connection string.
+               Structure is documented below.
         :param _builtins.bool continuous: Whether to run the query as continuous or a regular query.
         :param _builtins.str create_disposition: Specifies whether the job is allowed to create new tables. The following values are supported:
                CREATE_IF_NEEDED: If the table does not exist, BigQuery creates the table.
@@ -3376,6 +3398,8 @@ class JobQuery(dict):
         pulumi.set(__self__, "query", query)
         if allow_large_results is not None:
             pulumi.set(__self__, "allow_large_results", allow_large_results)
+        if connection_properties is not None:
+            pulumi.set(__self__, "connection_properties", connection_properties)
         if continuous is not None:
             pulumi.set(__self__, "continuous", continuous)
         if create_disposition is not None:
@@ -3429,6 +3453,17 @@ class JobQuery(dict):
         """
         return pulumi.get(self, "allow_large_results")
 
+    @_builtins.property
+    @pulumi.getter(name="connectionProperties")
+    def connection_properties(self) -> Optional[Sequence['outputs.JobQueryConnectionProperty']]:
+        """
+        Connection properties to customize query behavior. Under JDBC, these correspond
+        directly to connection properties passed to the DriverManager. Under ODBC, these
+        correspond to properties in the connection string.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "connection_properties")
+
     @_builtins.property
     @pulumi.getter
     def continuous(self) -> Optional[_builtins.bool]:
@@ -3591,6 +3626,35 @@ class JobQuery(dict):
         return pulumi.get(self, "write_disposition")
 
 
+@pulumi.output_type
+class JobQueryConnectionProperty(dict):
+    def __init__(__self__, *,
+                 key: _builtins.str,
+                 value: _builtins.str):
+        """
+        :param _builtins.str key: The key of the property to set. Currently supported connection properties:
+        :param _builtins.str value: The value of the property to set.
+        """
+        pulumi.set(__self__, "key", key)
+        pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def key(self) -> _builtins.str:
+        """
+        The key of the property to set. Currently supported connection properties:
+        """
+        return pulumi.get(self, "key")
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> _builtins.str:
+        """
+        The value of the property to set.
+        """
+        return pulumi.get(self, "value")
+
+
 @pulumi.output_type
 class JobQueryDefaultDataset(dict):
     @staticmethod
@@ -6608,7 +6672,10 @@ class TableView(dict):
         """
         :param _builtins.str query: A query that BigQuery executes when the view is referenced.
         :param _builtins.bool use_legacy_sql: Specifies whether to use BigQuery's legacy SQL for this view.
-               The default value is true. If set to false, the view will use BigQuery's standard SQL.
+               If set to `false`, the view will use BigQuery's standard SQL. If set to
+               `true`, the view will use BigQuery's legacy SQL. If unset, the API will
+               interpret it as a `true` and assumes the legacy SQL dialect for its query
+               according to the [API documentation](https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#ViewDefinition).
                > **Note**: Starting in provider version `7.0.0`, no default value is
                provided for this field unless explicitly set in the configuration.
         """
@@ -6629,7 +6696,10 @@ class TableView(dict):
     def use_legacy_sql(self) -> Optional[_builtins.bool]:
         """
         Specifies whether to use BigQuery's legacy SQL for this view.
-        The default value is true. If set to false, the view will use BigQuery's standard SQL.
+        If set to `false`, the view will use BigQuery's standard SQL. If set to
+        `true`, the view will use BigQuery's legacy SQL. If unset, the API will
+        interpret it as a `true` and assumes the legacy SQL dialect for its query
+        according to the [API documentation](https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#ViewDefinition).
         > **Note**: Starting in provider version `7.0.0`, no default value is
         provided for this field unless explicitly set in the configuration.
         """
@@ -8365,7 +8435,7 @@ class GetTableViewResult(dict):
                  use_legacy_sql: _builtins.bool):
         """
         :param _builtins.str query: A query that BigQuery executes when the view is referenced.
-        :param _builtins.bool use_legacy_sql: Specifies whether to use BigQuery's legacy SQL for this view. The default value is true. If set to false, the view will use BigQuery's standard SQL
+        :param _builtins.bool use_legacy_sql: Specifies whether to use BigQuery's legacy SQL for this view. If set to false, the view will use BigQuery's standard SQL
         """
         pulumi.set(__self__, "query", query)
         pulumi.set(__self__, "use_legacy_sql", use_legacy_sql)
@@ -8382,7 +8452,7 @@ class GetTableViewResult(dict):
     @pulumi.getter(name="useLegacySql")
     def use_legacy_sql(self) -> _builtins.bool:
         """
-        Specifies whether to use BigQuery's legacy SQL for this view. The default value is true. If set to false, the view will use BigQuery's standard SQL
+        Specifies whether to use BigQuery's legacy SQL for this view. If set to false, the view will use BigQuery's standard SQL
         """
         return pulumi.get(self, "use_legacy_sql")