pulumi-gcp 7.24.0a1716510380__py3-none-any.whl → 7.25.0__py3-none-any.whl

pulumi_gcp/bigquery/job.py

@@ -580,7 +580,8 @@ class Job(pulumi.CustomResource):
                 autodetect=True,
                 source_format="NEWLINE_DELIMITED_JSON",
                 json_extension="GEOJSON",
-            ))
+            ),
+            opts=pulumi.ResourceOptions(depends_on=[object]))
         ```
         ### Bigquery Job Load Parquet
 
@@ -679,6 +680,11 @@ class Job(pulumi.CustomResource):
         crypto_key = gcp.kms.CryptoKey("crypto_key",
             name="example-key",
             key_ring=key_ring.id)
+        project = gcp.organizations.get_project(project_id="my-project-name")
+        encrypt_role = gcp.projects.IAMMember("encrypt_role",
+            project=project.project_id,
+            role="roles/cloudkms.cryptoKeyEncrypterDecrypter",
+            member=f"serviceAccount:bq-{project.number}@bigquery-encryption.iam.gserviceaccount.com")
         dest = gcp.bigquery.Table("dest",
             deletion_protection=False,
             dataset_id=dest_dataset.dataset_id,
@@ -703,12 +709,8 @@ class Job(pulumi.CustomResource):
         \"\"\",
             encryption_configuration=gcp.bigquery.TableEncryptionConfigurationArgs(
                 kms_key_name=crypto_key.id,
-            ))
-        project = gcp.organizations.get_project(project_id="my-project-name")
-        encrypt_role = gcp.projects.IAMMember("encrypt_role",
-            project=project.project_id,
-            role="roles/cloudkms.cryptoKeyEncrypterDecrypter",
-            member=f"serviceAccount:bq-{project.number}@bigquery-encryption.iam.gserviceaccount.com")
+            ),
+            opts=pulumi.ResourceOptions(depends_on=[encrypt_role]))
         job = gcp.bigquery.Job("job",
             job_id="job_copy",
             copy=gcp.bigquery.JobCopyArgs(
@@ -732,7 +734,8 @@ class Job(pulumi.CustomResource):
                 destination_encryption_configuration=gcp.bigquery.JobCopyDestinationEncryptionConfigurationArgs(
                     kms_key_name=crypto_key.id,
                 ),
-            ))
+            ),
+            opts=pulumi.ResourceOptions(depends_on=[encrypt_role]))
         ```
         ### Bigquery Job Extract
 
@@ -1005,7 +1008,8 @@ class Job(pulumi.CustomResource):
                 autodetect=True,
                 source_format="NEWLINE_DELIMITED_JSON",
                 json_extension="GEOJSON",
-            ))
+            ),
+            opts=pulumi.ResourceOptions(depends_on=[object]))
         ```
         ### Bigquery Job Load Parquet
 
@@ -1104,6 +1108,11 @@ class Job(pulumi.CustomResource):
         crypto_key = gcp.kms.CryptoKey("crypto_key",
             name="example-key",
             key_ring=key_ring.id)
+        project = gcp.organizations.get_project(project_id="my-project-name")
+        encrypt_role = gcp.projects.IAMMember("encrypt_role",
+            project=project.project_id,
+            role="roles/cloudkms.cryptoKeyEncrypterDecrypter",
+            member=f"serviceAccount:bq-{project.number}@bigquery-encryption.iam.gserviceaccount.com")
         dest = gcp.bigquery.Table("dest",
             deletion_protection=False,
             dataset_id=dest_dataset.dataset_id,
@@ -1128,12 +1137,8 @@ class Job(pulumi.CustomResource):
         \"\"\",
             encryption_configuration=gcp.bigquery.TableEncryptionConfigurationArgs(
                 kms_key_name=crypto_key.id,
-            ))
-        project = gcp.organizations.get_project(project_id="my-project-name")
-        encrypt_role = gcp.projects.IAMMember("encrypt_role",
-            project=project.project_id,
-            role="roles/cloudkms.cryptoKeyEncrypterDecrypter",
-            member=f"serviceAccount:bq-{project.number}@bigquery-encryption.iam.gserviceaccount.com")
+            ),
+            opts=pulumi.ResourceOptions(depends_on=[encrypt_role]))
         job = gcp.bigquery.Job("job",
             job_id="job_copy",
             copy=gcp.bigquery.JobCopyArgs(
@@ -1157,7 +1162,8 @@ class Job(pulumi.CustomResource):
                 destination_encryption_configuration=gcp.bigquery.JobCopyDestinationEncryptionConfigurationArgs(
                     kms_key_name=crypto_key.id,
                 ),
-            ))
+            ),
+            opts=pulumi.ResourceOptions(depends_on=[encrypt_role]))
         ```
         ### Bigquery Job Extract
 

pulumi_gcp/bigquery/outputs.py

@@ -70,6 +70,9 @@ __all__ = [
     'TableEncryptionConfiguration',
     'TableExternalDataConfiguration',
     'TableExternalDataConfigurationAvroOptions',
+    'TableExternalDataConfigurationBigtableOptions',
+    'TableExternalDataConfigurationBigtableOptionsColumnFamily',
+    'TableExternalDataConfigurationBigtableOptionsColumnFamilyColumn',
     'TableExternalDataConfigurationCsvOptions',
     'TableExternalDataConfigurationGoogleSheetsOptions',
     'TableExternalDataConfigurationHivePartitioningOptions',
@@ -4307,6 +4310,8 @@ class TableExternalDataConfiguration(dict):
             suggest = "source_uris"
         elif key == "avroOptions":
             suggest = "avro_options"
+        elif key == "bigtableOptions":
+            suggest = "bigtable_options"
         elif key == "connectionId":
             suggest = "connection_id"
         elif key == "csvOptions":
@@ -4351,6 +4356,7 @@ class TableExternalDataConfiguration(dict):
                  autodetect: bool,
                  source_uris: Sequence[str],
                  avro_options: Optional['outputs.TableExternalDataConfigurationAvroOptions'] = None,
+                 bigtable_options: Optional['outputs.TableExternalDataConfigurationBigtableOptions'] = None,
                  compression: Optional[str] = None,
                  connection_id: Optional[str] = None,
                  csv_options: Optional['outputs.TableExternalDataConfigurationCsvOptions'] = None,
@@ -4374,6 +4380,8 @@ class TableExternalDataConfiguration(dict):
                your data in Google Cloud.
         :param 'TableExternalDataConfigurationAvroOptionsArgs' avro_options: Additional options if `source_format` is set to
                "AVRO".  Structure is documented below.
+        :param 'TableExternalDataConfigurationBigtableOptionsArgs' bigtable_options: Additional properties to set if
+               `source_format` is set to "BIGTABLE". Structure is documented below.
         :param str compression: The compression type of the data source.
                Valid values are "NONE" or "GZIP".
         :param str connection_id: The connection specifying the credentials to be used to read
@@ -4436,6 +4444,8 @@ class TableExternalDataConfiguration(dict):
         pulumi.set(__self__, "source_uris", source_uris)
         if avro_options is not None:
             pulumi.set(__self__, "avro_options", avro_options)
+        if bigtable_options is not None:
+            pulumi.set(__self__, "bigtable_options", bigtable_options)
         if compression is not None:
             pulumi.set(__self__, "compression", compression)
         if connection_id is not None:
@@ -4496,6 +4506,15 @@ class TableExternalDataConfiguration(dict):
         """
         return pulumi.get(self, "avro_options")
 
+    @property
+    @pulumi.getter(name="bigtableOptions")
+    def bigtable_options(self) -> Optional['outputs.TableExternalDataConfigurationBigtableOptions']:
+        """
+        Additional properties to set if
+        `source_format` is set to "BIGTABLE". Structure is documented below.
+        """
+        return pulumi.get(self, "bigtable_options")
+
     @property
     @pulumi.getter
     def compression(self) -> Optional[str]:
@@ -4705,6 +4724,272 @@ class TableExternalDataConfigurationAvroOptions(dict):
         return pulumi.get(self, "use_avro_logical_types")
 
 
+@pulumi.output_type
+class TableExternalDataConfigurationBigtableOptions(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "columnFamilies":
+            suggest = "column_families"
+        elif key == "ignoreUnspecifiedColumnFamilies":
+            suggest = "ignore_unspecified_column_families"
+        elif key == "outputColumnFamiliesAsJson":
+            suggest = "output_column_families_as_json"
+        elif key == "readRowkeyAsString":
+            suggest = "read_rowkey_as_string"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in TableExternalDataConfigurationBigtableOptions. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        TableExternalDataConfigurationBigtableOptions.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        TableExternalDataConfigurationBigtableOptions.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 column_families: Optional[Sequence['outputs.TableExternalDataConfigurationBigtableOptionsColumnFamily']] = None,
+                 ignore_unspecified_column_families: Optional[bool] = None,
+                 output_column_families_as_json: Optional[bool] = None,
+                 read_rowkey_as_string: Optional[bool] = None):
+        """
+        :param Sequence['TableExternalDataConfigurationBigtableOptionsColumnFamilyArgs'] column_families: A list of column families to expose in the table schema along with their types. This list restricts the column families that can be referenced in queries and specifies their value types. You can use this list to do type conversions - see the 'type' field for more details. If you leave this list empty, all column families are present in the table schema and their values are read as BYTES. During a query only the column families referenced in that query are read from Bigtable.  Structure is documented below.
+        :param bool ignore_unspecified_column_families: If field is true, then the column families that are not specified in columnFamilies list are not exposed in the table schema. Otherwise, they are read with BYTES type values. The default value is false.
+        :param bool output_column_families_as_json: If field is true, then each column family will be read as a single JSON column. Otherwise they are read as a repeated cell structure containing timestamp/value tuples. The default value is false.
+        :param bool read_rowkey_as_string: If field is true, then the rowkey column families will be read and converted to string. Otherwise they are read with BYTES type values and users need to manually cast them with CAST if necessary. The default value is false.
+        """
+        if column_families is not None:
+            pulumi.set(__self__, "column_families", column_families)
+        if ignore_unspecified_column_families is not None:
+            pulumi.set(__self__, "ignore_unspecified_column_families", ignore_unspecified_column_families)
+        if output_column_families_as_json is not None:
+            pulumi.set(__self__, "output_column_families_as_json", output_column_families_as_json)
+        if read_rowkey_as_string is not None:
+            pulumi.set(__self__, "read_rowkey_as_string", read_rowkey_as_string)
+
+    @property
+    @pulumi.getter(name="columnFamilies")
+    def column_families(self) -> Optional[Sequence['outputs.TableExternalDataConfigurationBigtableOptionsColumnFamily']]:
+        """
+        A list of column families to expose in the table schema along with their types. This list restricts the column families that can be referenced in queries and specifies their value types. You can use this list to do type conversions - see the 'type' field for more details. If you leave this list empty, all column families are present in the table schema and their values are read as BYTES. During a query only the column families referenced in that query are read from Bigtable.  Structure is documented below.
+        """
+        return pulumi.get(self, "column_families")
+
+    @property
+    @pulumi.getter(name="ignoreUnspecifiedColumnFamilies")
+    def ignore_unspecified_column_families(self) -> Optional[bool]:
+        """
+        If field is true, then the column families that are not specified in columnFamilies list are not exposed in the table schema. Otherwise, they are read with BYTES type values. The default value is false.
+        """
+        return pulumi.get(self, "ignore_unspecified_column_families")
+
+    @property
+    @pulumi.getter(name="outputColumnFamiliesAsJson")
+    def output_column_families_as_json(self) -> Optional[bool]:
+        """
+        If field is true, then each column family will be read as a single JSON column. Otherwise they are read as a repeated cell structure containing timestamp/value tuples. The default value is false.
+        """
+        return pulumi.get(self, "output_column_families_as_json")
+
+    @property
+    @pulumi.getter(name="readRowkeyAsString")
+    def read_rowkey_as_string(self) -> Optional[bool]:
+        """
+        If field is true, then the rowkey column families will be read and converted to string. Otherwise they are read with BYTES type values and users need to manually cast them with CAST if necessary. The default value is false.
+        """
+        return pulumi.get(self, "read_rowkey_as_string")
+
+
+@pulumi.output_type
+class TableExternalDataConfigurationBigtableOptionsColumnFamily(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "familyId":
+            suggest = "family_id"
+        elif key == "onlyReadLatest":
+            suggest = "only_read_latest"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in TableExternalDataConfigurationBigtableOptionsColumnFamily. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        TableExternalDataConfigurationBigtableOptionsColumnFamily.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        TableExternalDataConfigurationBigtableOptionsColumnFamily.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 columns: Optional[Sequence['outputs.TableExternalDataConfigurationBigtableOptionsColumnFamilyColumn']] = None,
+                 encoding: Optional[str] = None,
+                 family_id: Optional[str] = None,
+                 only_read_latest: Optional[bool] = None,
+                 type: Optional[str] = None):
+        """
+        :param Sequence['TableExternalDataConfigurationBigtableOptionsColumnFamilyColumnArgs'] columns: A List of columns that should be exposed as individual fields as opposed to a list of (column name, value) pairs. All columns whose qualifier matches a qualifier in this list can be accessed as Other columns can be accessed as a list through column field.  Structure is documented below.
+        :param str encoding: The encoding of the values when the type is not STRING. Acceptable encoding values are: TEXT - indicates values are alphanumeric text strings. BINARY - indicates values are encoded using HBase Bytes.toBytes family of functions. This can be overridden for a specific column by listing that column in 'columns' and specifying an encoding for it.
+        :param str family_id: Identifier of the column family.
+        :param bool only_read_latest: If this is set only the latest version of value are exposed for all columns in this column family. This can be overridden for a specific column by listing that column in 'columns' and specifying a different setting for that column.
+        :param str type: The type to convert the value in cells of this column family. The values are expected to be encoded using HBase Bytes.toBytes function when using the BINARY encoding value. Following BigQuery types are allowed (case-sensitive): "BYTES", "STRING", "INTEGER", "FLOAT", "BOOLEAN", "JSON". Default type is BYTES. This can be overridden for a specific column by listing that column in 'columns' and specifying a type for it.
+        """
+        if columns is not None:
+            pulumi.set(__self__, "columns", columns)
+        if encoding is not None:
+            pulumi.set(__self__, "encoding", encoding)
+        if family_id is not None:
+            pulumi.set(__self__, "family_id", family_id)
+        if only_read_latest is not None:
+            pulumi.set(__self__, "only_read_latest", only_read_latest)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def columns(self) -> Optional[Sequence['outputs.TableExternalDataConfigurationBigtableOptionsColumnFamilyColumn']]:
+        """
+        A List of columns that should be exposed as individual fields as opposed to a list of (column name, value) pairs. All columns whose qualifier matches a qualifier in this list can be accessed as Other columns can be accessed as a list through column field.  Structure is documented below.
+        """
+        return pulumi.get(self, "columns")
+
+    @property
+    @pulumi.getter
+    def encoding(self) -> Optional[str]:
+        """
+        The encoding of the values when the type is not STRING. Acceptable encoding values are: TEXT - indicates values are alphanumeric text strings. BINARY - indicates values are encoded using HBase Bytes.toBytes family of functions. This can be overridden for a specific column by listing that column in 'columns' and specifying an encoding for it.
+        """
+        return pulumi.get(self, "encoding")
+
+    @property
+    @pulumi.getter(name="familyId")
+    def family_id(self) -> Optional[str]:
+        """
+        Identifier of the column family.
+        """
+        return pulumi.get(self, "family_id")
+
+    @property
+    @pulumi.getter(name="onlyReadLatest")
+    def only_read_latest(self) -> Optional[bool]:
+        """
+        If this is set only the latest version of value are exposed for all columns in this column family. This can be overridden for a specific column by listing that column in 'columns' and specifying a different setting for that column.
+        """
+        return pulumi.get(self, "only_read_latest")
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[str]:
+        """
+        The type to convert the value in cells of this column family. The values are expected to be encoded using HBase Bytes.toBytes function when using the BINARY encoding value. Following BigQuery types are allowed (case-sensitive): "BYTES", "STRING", "INTEGER", "FLOAT", "BOOLEAN", "JSON". Default type is BYTES. This can be overridden for a specific column by listing that column in 'columns' and specifying a type for it.
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class TableExternalDataConfigurationBigtableOptionsColumnFamilyColumn(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "fieldName":
+            suggest = "field_name"
+        elif key == "onlyReadLatest":
+            suggest = "only_read_latest"
+        elif key == "qualifierEncoded":
+            suggest = "qualifier_encoded"
+        elif key == "qualifierString":
+            suggest = "qualifier_string"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in TableExternalDataConfigurationBigtableOptionsColumnFamilyColumn. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        TableExternalDataConfigurationBigtableOptionsColumnFamilyColumn.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        TableExternalDataConfigurationBigtableOptionsColumnFamilyColumn.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 encoding: Optional[str] = None,
+                 field_name: Optional[str] = None,
+                 only_read_latest: Optional[bool] = None,
+                 qualifier_encoded: Optional[str] = None,
+                 qualifier_string: Optional[str] = None,
+                 type: Optional[str] = None):
+        """
+        :param str encoding: The encoding of the values when the type is not STRING. Acceptable encoding values are: TEXT - indicates values are alphanumeric text strings. BINARY - indicates values are encoded using HBase Bytes.toBytes family of functions. 'encoding' can also be set at the column family level. However, the setting at this level takes precedence if 'encoding' is set at both levels.
+        :param str field_name: If the qualifier is not a valid BigQuery field identifier i.e. does not match [a-zA-Z][a-zA-Z0-9_]*, a valid identifier must be provided as the column field name and is used as field name in queries.
+        :param bool only_read_latest: If this is set, only the latest version of value in this column are exposed. 'onlyReadLatest' can also be set at the column family level. However, the setting at this level takes precedence if 'onlyReadLatest' is set at both levels.
+        :param str qualifier_encoded: Qualifier of the column. Columns in the parent column family that has this exact qualifier are exposed as . field. If the qualifier is valid UTF-8 string, it can be specified in the qualifierString field. Otherwise, a base-64 encoded value must be set to qualifierEncoded. The column field name is the same as the column qualifier. However, if the qualifier is not a valid BigQuery field identifier i.e. does not match [a-zA-Z][a-zA-Z0-9_]*, a valid identifier must be provided as fieldName.
+        :param str qualifier_string: Qualifier string.
+        :param str type: The type to convert the value in cells of this column. The values are expected to be encoded using HBase Bytes.toBytes function when using the BINARY encoding value. Following BigQuery types are allowed (case-sensitive): "BYTES", "STRING", "INTEGER", "FLOAT", "BOOLEAN", "JSON", Default type is "BYTES". 'type' can also be set at the column family level. However, the setting at this level takes precedence if 'type' is set at both levels.
+        """
+        if encoding is not None:
+            pulumi.set(__self__, "encoding", encoding)
+        if field_name is not None:
+            pulumi.set(__self__, "field_name", field_name)
+        if only_read_latest is not None:
+            pulumi.set(__self__, "only_read_latest", only_read_latest)
+        if qualifier_encoded is not None:
+            pulumi.set(__self__, "qualifier_encoded", qualifier_encoded)
+        if qualifier_string is not None:
+            pulumi.set(__self__, "qualifier_string", qualifier_string)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def encoding(self) -> Optional[str]:
+        """
+        The encoding of the values when the type is not STRING. Acceptable encoding values are: TEXT - indicates values are alphanumeric text strings. BINARY - indicates values are encoded using HBase Bytes.toBytes family of functions. 'encoding' can also be set at the column family level. However, the setting at this level takes precedence if 'encoding' is set at both levels.
+        """
+        return pulumi.get(self, "encoding")
+
+    @property
+    @pulumi.getter(name="fieldName")
+    def field_name(self) -> Optional[str]:
+        """
+        If the qualifier is not a valid BigQuery field identifier i.e. does not match [a-zA-Z][a-zA-Z0-9_]*, a valid identifier must be provided as the column field name and is used as field name in queries.
+        """
+        return pulumi.get(self, "field_name")
+
+    @property
+    @pulumi.getter(name="onlyReadLatest")
+    def only_read_latest(self) -> Optional[bool]:
+        """
+        If this is set, only the latest version of value in this column are exposed. 'onlyReadLatest' can also be set at the column family level. However, the setting at this level takes precedence if 'onlyReadLatest' is set at both levels.
+        """
+        return pulumi.get(self, "only_read_latest")
+
+    @property
+    @pulumi.getter(name="qualifierEncoded")
+    def qualifier_encoded(self) -> Optional[str]:
+        """
+        Qualifier of the column. Columns in the parent column family that has this exact qualifier are exposed as . field. If the qualifier is valid UTF-8 string, it can be specified in the qualifierString field. Otherwise, a base-64 encoded value must be set to qualifierEncoded. The column field name is the same as the column qualifier. However, if the qualifier is not a valid BigQuery field identifier i.e. does not match [a-zA-Z][a-zA-Z0-9_]*, a valid identifier must be provided as fieldName.
+        """
+        return pulumi.get(self, "qualifier_encoded")
+
+    @property
+    @pulumi.getter(name="qualifierString")
+    def qualifier_string(self) -> Optional[str]:
+        """
+        Qualifier string.
+        """
+        return pulumi.get(self, "qualifier_string")
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[str]:
+        """
+        The type to convert the value in cells of this column. The values are expected to be encoded using HBase Bytes.toBytes function when using the BINARY encoding value. Following BigQuery types are allowed (case-sensitive): "BYTES", "STRING", "INTEGER", "FLOAT", "BOOLEAN", "JSON", Default type is "BYTES". 'type' can also be set at the column family level. However, the setting at this level takes precedence if 'type' is set at both levels.
+        """
+        return pulumi.get(self, "type")
+
+
 @pulumi.output_type
 class TableExternalDataConfigurationCsvOptions(dict):
     @staticmethod
@@ -5500,7 +5785,8 @@ class TableTableReplicationInfo(dict):
         :param str source_dataset_id: The ID of the source dataset.
         :param str source_project_id: The ID of the source project.
         :param str source_table_id: The ID of the source materialized view.
-        :param int replication_interval_ms: The interval at which the source materialized view is polled for updates. The default is 300000.
+        :param int replication_interval_ms: The interval at which the source
+               materialized view is polled for updates. The default is 300000.
         """
         pulumi.set(__self__, "source_dataset_id", source_dataset_id)
         pulumi.set(__self__, "source_project_id", source_project_id)
@@ -5536,7 +5822,8 @@ class TableTableReplicationInfo(dict):
     @pulumi.getter(name="replicationIntervalMs")
     def replication_interval_ms(self) -> Optional[int]:
         """
-        The interval at which the source materialized view is polled for updates. The default is 300000.
+        The interval at which the source
+        materialized view is polled for updates. The default is 300000.
         """
         return pulumi.get(self, "replication_interval_ms")
 

pulumi_gcp/bigquery/routine.py

@@ -840,7 +840,7 @@ class Routine(pulumi.CustomResource):
         import pulumi
         import pulumi_gcp as gcp
 
-        test = gcp.bigquery.Dataset("test", dataset_id="tf_test_dataset_id_77884")
+        test = gcp.bigquery.Dataset("test", dataset_id="tf_test_dataset_id_15222")
         custom_masking_routine = gcp.bigquery.Routine("custom_masking_routine",
             dataset_id=test.dataset_id,
             routine_id="custom_masking_routine",
@@ -1135,7 +1135,7 @@ class Routine(pulumi.CustomResource):
         import pulumi
         import pulumi_gcp as gcp
 
-        test = gcp.bigquery.Dataset("test", dataset_id="tf_test_dataset_id_77884")
+        test = gcp.bigquery.Dataset("test", dataset_id="tf_test_dataset_id_15222")
         custom_masking_routine = gcp.bigquery.Routine("custom_masking_routine",
             dataset_id=test.dataset_id,
             routine_id="custom_masking_routine",