pulumi-gcp-kotlin/com.pulumi.gcp.bigquery.kotlin/Table

Table

Example Usage

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.bigquery.Dataset;
import com.pulumi.gcp.bigquery.DatasetArgs;
import com.pulumi.gcp.bigquery.Table;
import com.pulumi.gcp.bigquery.TableArgs;
import com.pulumi.gcp.bigquery.inputs.TableTimePartitioningArgs;
import com.pulumi.gcp.bigquery.inputs.TableExternalDataConfigurationArgs;
import com.pulumi.gcp.bigquery.inputs.TableExternalDataConfigurationGoogleSheetsOptionsArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var defaultDataset = new Dataset("defaultDataset", DatasetArgs.builder()
            .datasetId("foo")
            .friendlyName("test")
            .description("This is a test description")
            .location("EU")
            .defaultTableExpirationMs(3600000)
            .labels(Map.of("env", "default"))
            .build());
        var defaultTable = new Table("defaultTable", TableArgs.builder()
            .datasetId(defaultDataset.datasetId())
            .tableId("bar")
            .timePartitioning(TableTimePartitioningArgs.builder()
                .type("DAY")
                .build())
            .labels(Map.of("env", "default"))
            .schema("""
[
  {
    "name": "permalink",
    "type": "STRING",
    "mode": "NULLABLE",
    "description": "The Permalink"
  },
  {
    "name": "state",
    "type": "STRING",
    "mode": "NULLABLE",
    "description": "State where the head office is located"
  }
]
            """)
            .build());
        var sheet = new Table("sheet", TableArgs.builder()
            .datasetId(defaultDataset.datasetId())
            .tableId("sheet")
            .externalDataConfiguration(TableExternalDataConfigurationArgs.builder()
                .autodetect(true)
                .sourceFormat("GOOGLE_SHEETS")
                .googleSheetsOptions(TableExternalDataConfigurationGoogleSheetsOptionsArgs.builder()
                    .skipLeadingRows(1)
                    .build())
                .sourceUris("https://docs.google.com/spreadsheets/d/123456789012345")
                .build())
            .build());
    }
}

Import

BigQuery tables imported using any of these accepted formats

$ pulumi import gcp:bigquery/table:Table default projects/{{project}}/datasets/{{dataset_id}}/tables/{{table_id}}

$ pulumi import gcp:bigquery/table:Table default {{project}}/{{dataset_id}}/{{table_id}}

$ pulumi import gcp:bigquery/table:Table default {{dataset_id}}/{{table_id}}

Properties

clusterings

val clusterings: Output<List<String>>?

Specifies column names to use for data clustering. Up to four top-level columns are allowed, and should be specified in descending priority order.

creationTime

val creationTime: Output<Int>

The time when this table was created, in milliseconds since the epoch.

datasetId

val datasetId: Output<String>

The dataset ID to create the table in. Changing this forces a new resource to be created.

deletionProtection

val deletionProtection: Output<Boolean>?

Whether or not to allow Terraform to destroy the instance. Unless this field is set to false in Terraform state, a terraform destroy or terraform apply that would delete the instance will fail.

description

val description: Output<String>?

The field description.

encryptionConfiguration

val encryptionConfiguration: Output<TableEncryptionConfiguration>?

Specifies how the table should be encrypted. If left blank, the table will be encrypted with a Google-managed key; that process is transparent to the user. Structure is documented below.

etag

val etag: Output<String>

A hash of the resource.

expirationTime

val expirationTime: Output<Int>

The time when this table expires, in milliseconds since the epoch. If not present, the table will persist indefinitely. Expired tables will be deleted and their storage reclaimed.

externalDataConfiguration

val externalDataConfiguration: Output<TableExternalDataConfiguration>?

Describes the data format, location, and other properties of a table stored outside of BigQuery. By defining these properties, the data source can then be queried as if it were a standard BigQuery table. Structure is documented below.

friendlyName