Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.pulumi.gcp.bigquery.kotlin.DatasetAccess.kt Maven / Gradle / Ivy
@file:Suppress("NAME_SHADOWING", "DEPRECATION")
package com.pulumi.gcp.bigquery.kotlin
import com.pulumi.core.Output
import com.pulumi.gcp.bigquery.kotlin.outputs.DatasetAccessAuthorizedDataset
import com.pulumi.gcp.bigquery.kotlin.outputs.DatasetAccessRoutine
import com.pulumi.gcp.bigquery.kotlin.outputs.DatasetAccessView
import com.pulumi.kotlin.KotlinCustomResource
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.ResourceMapper
import com.pulumi.kotlin.options.CustomResourceOptions
import com.pulumi.kotlin.options.CustomResourceOptionsBuilder
import com.pulumi.resources.Resource
import kotlin.Boolean
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import com.pulumi.gcp.bigquery.kotlin.outputs.DatasetAccessAuthorizedDataset.Companion.toKotlin as datasetAccessAuthorizedDatasetToKotlin
import com.pulumi.gcp.bigquery.kotlin.outputs.DatasetAccessRoutine.Companion.toKotlin as datasetAccessRoutineToKotlin
import com.pulumi.gcp.bigquery.kotlin.outputs.DatasetAccessView.Companion.toKotlin as datasetAccessViewToKotlin
/**
* Builder for [DatasetAccess].
*/
@PulumiTagMarker
public class DatasetAccessResourceBuilder internal constructor() {
public var name: String? = null
public var args: DatasetAccessArgs = DatasetAccessArgs()
public var opts: CustomResourceOptions = CustomResourceOptions()
/**
* @param name The _unique_ name of the resulting resource.
*/
public fun name(`value`: String) {
this.name = value
}
/**
* @param block The arguments to use to populate this resource's properties.
*/
public suspend fun args(block: suspend DatasetAccessArgsBuilder.() -> Unit) {
val builder = DatasetAccessArgsBuilder()
block(builder)
this.args = builder.build()
}
/**
* @param block A bag of options that control this resource's behavior.
*/
public suspend fun opts(block: suspend CustomResourceOptionsBuilder.() -> Unit) {
this.opts = com.pulumi.kotlin.options.CustomResourceOptions.opts(block)
}
internal fun build(): DatasetAccess {
val builtJavaResource = com.pulumi.gcp.bigquery.DatasetAccess(
this.name,
this.args.toJava(),
this.opts.toJava(),
)
return DatasetAccess(builtJavaResource)
}
}
/**
* ## Example Usage
* ### Bigquery Dataset Access Basic User
*
* ```typescript
* import * as pulumi from "@pulumi/pulumi";
* import * as gcp from "@pulumi/gcp";
* const dataset = new gcp.bigquery.Dataset("dataset", {datasetId: "example_dataset"});
* const bqowner = new gcp.serviceaccount.Account("bqowner", {accountId: "bqowner"});
* const access = new gcp.bigquery.DatasetAccess("access", {
* datasetId: dataset.datasetId,
* role: "OWNER",
* userByEmail: bqowner.email,
* });
* ```
* ```python
* import pulumi
* import pulumi_gcp as gcp
* dataset = gcp.bigquery.Dataset("dataset", dataset_id="example_dataset")
* bqowner = gcp.serviceaccount.Account("bqowner", account_id="bqowner")
* access = gcp.bigquery.DatasetAccess("access",
* dataset_id=dataset.dataset_id,
* role="OWNER",
* user_by_email=bqowner.email)
* ```
* ```csharp
* using System.Collections.Generic;
* using System.Linq;
* using Pulumi;
* using Gcp = Pulumi.Gcp;
* return await Deployment.RunAsync(() =>
* {
* var dataset = new Gcp.BigQuery.Dataset("dataset", new()
* {
* DatasetId = "example_dataset",
* });
* var bqowner = new Gcp.ServiceAccount.Account("bqowner", new()
* {
* AccountId = "bqowner",
* });
* var access = new Gcp.BigQuery.DatasetAccess("access", new()
* {
* DatasetId = dataset.DatasetId,
* Role = "OWNER",
* UserByEmail = bqowner.Email,
* });
* });
* ```
* ```go
* package main
* import (
* "github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigquery"
* "github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/serviceaccount"
* "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
* )
* func main() {
* pulumi.Run(func(ctx *pulumi.Context) error {
* dataset, err := bigquery.NewDataset(ctx, "dataset", &bigquery.DatasetArgs{
* DatasetId: pulumi.String("example_dataset"),
* })
* if err != nil {
* return err
* }
* bqowner, err := serviceaccount.NewAccount(ctx, "bqowner", &serviceaccount.AccountArgs{
* AccountId: pulumi.String("bqowner"),
* })
* if err != nil {
* return err
* }
* _, err = bigquery.NewDatasetAccess(ctx, "access", &bigquery.DatasetAccessArgs{
* DatasetId: dataset.DatasetId,
* Role: pulumi.String("OWNER"),
* UserByEmail: bqowner.Email,
* })
* if err != nil {
* return err
* }
* return nil
* })
* }
* ```
* ```java
* 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.serviceaccount.Account;
* import com.pulumi.gcp.serviceaccount.AccountArgs;
* import com.pulumi.gcp.bigquery.DatasetAccess;
* import com.pulumi.gcp.bigquery.DatasetAccessArgs;
* 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 dataset = new Dataset("dataset", DatasetArgs.builder()
* .datasetId("example_dataset")
* .build());
* var bqowner = new Account("bqowner", AccountArgs.builder()
* .accountId("bqowner")
* .build());
* var access = new DatasetAccess("access", DatasetAccessArgs.builder()
* .datasetId(dataset.datasetId())
* .role("OWNER")
* .userByEmail(bqowner.email())
* .build());
* }
* }
* ```
* ```yaml
* resources:
* access:
* type: gcp:bigquery:DatasetAccess
* properties:
* datasetId: ${dataset.datasetId}
* role: OWNER
* userByEmail: ${bqowner.email}
* dataset:
* type: gcp:bigquery:Dataset
* properties:
* datasetId: example_dataset
* bqowner:
* type: gcp:serviceaccount:Account
* properties:
* accountId: bqowner
* ```
*
* ### Bigquery Dataset Access View
*
* ```typescript
* import * as pulumi from "@pulumi/pulumi";
* import * as gcp from "@pulumi/gcp";
* const _private = new gcp.bigquery.Dataset("private", {datasetId: "example_dataset"});
* const _public = new gcp.bigquery.Dataset("public", {datasetId: "example_dataset2"});
* const publicTable = new gcp.bigquery.Table("public", {
* deletionProtection: false,
* datasetId: _public.datasetId,
* tableId: "example_table",
* view: {
* query: "SELECT state FROM [lookerdata:cdc.project_tycho_reports]",
* useLegacySql: false,
* },
* });
* const access = new gcp.bigquery.DatasetAccess("access", {
* datasetId: _private.datasetId,
* view: {
* projectId: publicTable.project,
* datasetId: _public.datasetId,
* tableId: publicTable.tableId,
* },
* });
* ```
* ```python
* import pulumi
* import pulumi_gcp as gcp
* private = gcp.bigquery.Dataset("private", dataset_id="example_dataset")
* public = gcp.bigquery.Dataset("public", dataset_id="example_dataset2")
* public_table = gcp.bigquery.Table("public",
* deletion_protection=False,
* dataset_id=public.dataset_id,
* table_id="example_table",
* view={
* "query": "SELECT state FROM [lookerdata:cdc.project_tycho_reports]",
* "use_legacy_sql": False,
* })
* access = gcp.bigquery.DatasetAccess("access",
* dataset_id=private.dataset_id,
* view={
* "project_id": public_table.project,
* "dataset_id": public.dataset_id,
* "table_id": public_table.table_id,
* })
* ```
* ```csharp
* using System.Collections.Generic;
* using System.Linq;
* using Pulumi;
* using Gcp = Pulumi.Gcp;
* return await Deployment.RunAsync(() =>
* {
* var @private = new Gcp.BigQuery.Dataset("private", new()
* {
* DatasetId = "example_dataset",
* });
* var @public = new Gcp.BigQuery.Dataset("public", new()
* {
* DatasetId = "example_dataset2",
* });
* var publicTable = new Gcp.BigQuery.Table("public", new()
* {
* DeletionProtection = false,
* DatasetId = @public.DatasetId,
* TableId = "example_table",
* View = new Gcp.BigQuery.Inputs.TableViewArgs
* {
* Query = "SELECT state FROM [lookerdata:cdc.project_tycho_reports]",
* UseLegacySql = false,
* },
* });
* var access = new Gcp.BigQuery.DatasetAccess("access", new()
* {
* DatasetId = @private.DatasetId,
* View = new Gcp.BigQuery.Inputs.DatasetAccessViewArgs
* {
* ProjectId = publicTable.Project,
* DatasetId = @public.DatasetId,
* TableId = publicTable.TableId,
* },
* });
* });
* ```
* ```go
* package main
* import (
* "github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigquery"
* "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
* )
* func main() {
* pulumi.Run(func(ctx *pulumi.Context) error {
* private, err := bigquery.NewDataset(ctx, "private", &bigquery.DatasetArgs{
* DatasetId: pulumi.String("example_dataset"),
* })
* if err != nil {
* return err
* }
* public, err := bigquery.NewDataset(ctx, "public", &bigquery.DatasetArgs{
* DatasetId: pulumi.String("example_dataset2"),
* })
* if err != nil {
* return err
* }
* publicTable, err := bigquery.NewTable(ctx, "public", &bigquery.TableArgs{
* DeletionProtection: pulumi.Bool(false),
* DatasetId: public.DatasetId,
* TableId: pulumi.String("example_table"),
* View: &bigquery.TableViewArgs{
* Query: pulumi.String("SELECT state FROM [lookerdata:cdc.project_tycho_reports]"),
* UseLegacySql: pulumi.Bool(false),
* },
* })
* if err != nil {
* return err
* }
* _, err = bigquery.NewDatasetAccess(ctx, "access", &bigquery.DatasetAccessArgs{
* DatasetId: private.DatasetId,
* View: &bigquery.DatasetAccessViewArgs{
* ProjectId: publicTable.Project,
* DatasetId: public.DatasetId,
* TableId: publicTable.TableId,
* },
* })
* if err != nil {
* return err
* }
* return nil
* })
* }
* ```
* ```java
* 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.TableViewArgs;
* import com.pulumi.gcp.bigquery.DatasetAccess;
* import com.pulumi.gcp.bigquery.DatasetAccessArgs;
* import com.pulumi.gcp.bigquery.inputs.DatasetAccessViewArgs;
* 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 private_ = new Dataset("private", DatasetArgs.builder()
* .datasetId("example_dataset")
* .build());
* var public_ = new Dataset("public", DatasetArgs.builder()
* .datasetId("example_dataset2")
* .build());
* var publicTable = new Table("publicTable", TableArgs.builder()
* .deletionProtection(false)
* .datasetId(public_.datasetId())
* .tableId("example_table")
* .view(TableViewArgs.builder()
* .query("SELECT state FROM [lookerdata:cdc.project_tycho_reports]")
* .useLegacySql(false)
* .build())
* .build());
* var access = new DatasetAccess("access", DatasetAccessArgs.builder()
* .datasetId(private_.datasetId())
* .view(DatasetAccessViewArgs.builder()
* .projectId(publicTable.project())
* .datasetId(public_.datasetId())
* .tableId(publicTable.tableId())
* .build())
* .build());
* }
* }
* ```
* ```yaml
* resources:
* access:
* type: gcp:bigquery:DatasetAccess
* properties:
* datasetId: ${private.datasetId}
* view:
* projectId: ${publicTable.project}
* datasetId: ${public.datasetId}
* tableId: ${publicTable.tableId}
* private:
* type: gcp:bigquery:Dataset
* properties:
* datasetId: example_dataset
* public:
* type: gcp:bigquery:Dataset
* properties:
* datasetId: example_dataset2
* publicTable:
* type: gcp:bigquery:Table
* name: public
* properties:
* deletionProtection: false
* datasetId: ${public.datasetId}
* tableId: example_table
* view:
* query: SELECT state FROM [lookerdata:cdc.project_tycho_reports]
* useLegacySql: false
* ```
*
* ### Bigquery Dataset Access Authorized Dataset
*
* ```typescript
* import * as pulumi from "@pulumi/pulumi";
* import * as gcp from "@pulumi/gcp";
* const _private = new gcp.bigquery.Dataset("private", {datasetId: "private"});
* const _public = new gcp.bigquery.Dataset("public", {datasetId: "public"});
* const access = new gcp.bigquery.DatasetAccess("access", {
* datasetId: _private.datasetId,
* authorizedDataset: {
* dataset: {
* projectId: _public.project,
* datasetId: _public.datasetId,
* },
* targetTypes: ["VIEWS"],
* },
* });
* ```
* ```python
* import pulumi
* import pulumi_gcp as gcp
* private = gcp.bigquery.Dataset("private", dataset_id="private")
* public = gcp.bigquery.Dataset("public", dataset_id="public")
* access = gcp.bigquery.DatasetAccess("access",
* dataset_id=private.dataset_id,
* authorized_dataset={
* "dataset": {
* "project_id": public.project,
* "dataset_id": public.dataset_id,
* },
* "target_types": ["VIEWS"],
* })
* ```
* ```csharp
* using System.Collections.Generic;
* using System.Linq;
* using Pulumi;
* using Gcp = Pulumi.Gcp;
* return await Deployment.RunAsync(() =>
* {
* var @private = new Gcp.BigQuery.Dataset("private", new()
* {
* DatasetId = "private",
* });
* var @public = new Gcp.BigQuery.Dataset("public", new()
* {
* DatasetId = "public",
* });
* var access = new Gcp.BigQuery.DatasetAccess("access", new()
* {
* DatasetId = @private.DatasetId,
* AuthorizedDataset = new Gcp.BigQuery.Inputs.DatasetAccessAuthorizedDatasetArgs
* {
* Dataset = new Gcp.BigQuery.Inputs.DatasetAccessAuthorizedDatasetDatasetArgs
* {
* ProjectId = @public.Project,
* DatasetId = @public.DatasetId,
* },
* TargetTypes = new[]
* {
* "VIEWS",
* },
* },
* });
* });
* ```
* ```go
* package main
* import (
* "github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigquery"
* "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
* )
* func main() {
* pulumi.Run(func(ctx *pulumi.Context) error {
* private, err := bigquery.NewDataset(ctx, "private", &bigquery.DatasetArgs{
* DatasetId: pulumi.String("private"),
* })
* if err != nil {
* return err
* }
* public, err := bigquery.NewDataset(ctx, "public", &bigquery.DatasetArgs{
* DatasetId: pulumi.String("public"),
* })
* if err != nil {
* return err
* }
* _, err = bigquery.NewDatasetAccess(ctx, "access", &bigquery.DatasetAccessArgs{
* DatasetId: private.DatasetId,
* AuthorizedDataset: &bigquery.DatasetAccessAuthorizedDatasetArgs{
* Dataset: &bigquery.DatasetAccessAuthorizedDatasetDatasetArgs{
* ProjectId: public.Project,
* DatasetId: public.DatasetId,
* },
* TargetTypes: pulumi.StringArray{
* pulumi.String("VIEWS"),
* },
* },
* })
* if err != nil {
* return err
* }
* return nil
* })
* }
* ```
* ```java
* 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.DatasetAccess;
* import com.pulumi.gcp.bigquery.DatasetAccessArgs;
* import com.pulumi.gcp.bigquery.inputs.DatasetAccessAuthorizedDatasetArgs;
* import com.pulumi.gcp.bigquery.inputs.DatasetAccessAuthorizedDatasetDatasetArgs;
* 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 private_ = new Dataset("private", DatasetArgs.builder()
* .datasetId("private")
* .build());
* var public_ = new Dataset("public", DatasetArgs.builder()
* .datasetId("public")
* .build());
* var access = new DatasetAccess("access", DatasetAccessArgs.builder()
* .datasetId(private_.datasetId())
* .authorizedDataset(DatasetAccessAuthorizedDatasetArgs.builder()
* .dataset(DatasetAccessAuthorizedDatasetDatasetArgs.builder()
* .projectId(public_.project())
* .datasetId(public_.datasetId())
* .build())
* .targetTypes("VIEWS")
* .build())
* .build());
* }
* }
* ```
* ```yaml
* resources:
* access:
* type: gcp:bigquery:DatasetAccess
* properties:
* datasetId: ${private.datasetId}
* authorizedDataset:
* dataset:
* projectId: ${public.project}
* datasetId: ${public.datasetId}
* targetTypes:
* - VIEWS
* private:
* type: gcp:bigquery:Dataset
* properties:
* datasetId: private
* public:
* type: gcp:bigquery:Dataset
* properties:
* datasetId: public
* ```
*
* ### Bigquery Dataset Access Authorized Routine
*
* ```typescript
* import * as pulumi from "@pulumi/pulumi";
* import * as gcp from "@pulumi/gcp";
* const _public = new gcp.bigquery.Dataset("public", {
* datasetId: "public_dataset",
* description: "This dataset is public",
* });
* const publicRoutine = new gcp.bigquery.Routine("public", {
* datasetId: _public.datasetId,
* routineId: "public_routine",
* routineType: "TABLE_VALUED_FUNCTION",
* language: "SQL",
* definitionBody: "SELECT 1 + value AS value\n",
* arguments: [{
* name: "value",
* argumentKind: "FIXED_TYPE",
* dataType: JSON.stringify({
* typeKind: "INT64",
* }),
* }],
* returnTableType: JSON.stringify({
* columns: [{
* name: "value",
* type: {
* typeKind: "INT64",
* },
* }],
* }),
* });
* const _private = new gcp.bigquery.Dataset("private", {
* datasetId: "private_dataset",
* description: "This dataset is private",
* });
* const authorizedRoutine = new gcp.bigquery.DatasetAccess("authorized_routine", {
* datasetId: _private.datasetId,
* routine: {
* projectId: publicRoutine.project,
* datasetId: publicRoutine.datasetId,
* routineId: publicRoutine.routineId,
* },
* });
* ```
* ```python
* import pulumi
* import json
* import pulumi_gcp as gcp
* public = gcp.bigquery.Dataset("public",
* dataset_id="public_dataset",
* description="This dataset is public")
* public_routine = gcp.bigquery.Routine("public",
* dataset_id=public.dataset_id,
* routine_id="public_routine",
* routine_type="TABLE_VALUED_FUNCTION",
* language="SQL",
* definition_body="SELECT 1 + value AS value\n",
* arguments=[{
* "name": "value",
* "argument_kind": "FIXED_TYPE",
* "data_type": json.dumps({
* "type_kind": "INT64",
* }),
* }],
* return_table_type=json.dumps({
* "columns": [{
* "name": "value",
* "type": {
* "typeKind": "INT64",
* },
* }],
* }))
* private = gcp.bigquery.Dataset("private",
* dataset_id="private_dataset",
* description="This dataset is private")
* authorized_routine = gcp.bigquery.DatasetAccess("authorized_routine",
* dataset_id=private.dataset_id,
* routine={
* "project_id": public_routine.project,
* "dataset_id": public_routine.dataset_id,
* "routine_id": public_routine.routine_id,
* })
* ```
* ```csharp
* using System.Collections.Generic;
* using System.Linq;
* using System.Text.Json;
* using Pulumi;
* using Gcp = Pulumi.Gcp;
* return await Deployment.RunAsync(() =>
* {
* var @public = new Gcp.BigQuery.Dataset("public", new()
* {
* DatasetId = "public_dataset",
* Description = "This dataset is public",
* });
* var publicRoutine = new Gcp.BigQuery.Routine("public", new()
* {
* DatasetId = @public.DatasetId,
* RoutineId = "public_routine",
* RoutineType = "TABLE_VALUED_FUNCTION",
* Language = "SQL",
* DefinitionBody = @"SELECT 1 + value AS value
* ",
* Arguments = new[]
* {
* new Gcp.BigQuery.Inputs.RoutineArgumentArgs
* {
* Name = "value",
* ArgumentKind = "FIXED_TYPE",
* DataType = JsonSerializer.Serialize(new Dictionary
* {
* ["typeKind"] = "INT64",
* }),
* },
* },
* ReturnTableType = JsonSerializer.Serialize(new Dictionary
* {
* ["columns"] = new[]
* {
* new Dictionary
* {
* ["name"] = "value",
* ["type"] = new Dictionary
* {
* ["typeKind"] = "INT64",
* },
* },
* },
* }),
* });
* var @private = new Gcp.BigQuery.Dataset("private", new()
* {
* DatasetId = "private_dataset",
* Description = "This dataset is private",
* });
* var authorizedRoutine = new Gcp.BigQuery.DatasetAccess("authorized_routine", new()
* {
* DatasetId = @private.DatasetId,
* Routine = new Gcp.BigQuery.Inputs.DatasetAccessRoutineArgs
* {
* ProjectId = publicRoutine.Project,
* DatasetId = publicRoutine.DatasetId,
* RoutineId = publicRoutine.RoutineId,
* },
* });
* });
* ```
* ```go
* package main
* import (
* "encoding/json"
* "github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigquery"
* "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
* )
* func main() {
* pulumi.Run(func(ctx *pulumi.Context) error {
* public, err := bigquery.NewDataset(ctx, "public", &bigquery.DatasetArgs{
* DatasetId: pulumi.String("public_dataset"),
* Description: pulumi.String("This dataset is public"),
* })
* if err != nil {
* return err
* }
* tmpJSON0, err := json.Marshal(map[string]interface{}{
* "typeKind": "INT64",
* })
* if err != nil {
* return err
* }
* json0 := string(tmpJSON0)
* tmpJSON1, err := json.Marshal(map[string]interface{}{
* "columns": []map[string]interface{}{
* map[string]interface{}{
* "name": "value",
* "type": map[string]interface{}{
* "typeKind": "INT64",
* },
* },
* },
* })
* if err != nil {
* return err
* }
* json1 := string(tmpJSON1)
* publicRoutine, err := bigquery.NewRoutine(ctx, "public", &bigquery.RoutineArgs{
* DatasetId: public.DatasetId,
* RoutineId: pulumi.String("public_routine"),
* RoutineType: pulumi.String("TABLE_VALUED_FUNCTION"),
* Language: pulumi.String("SQL"),
* DefinitionBody: pulumi.String("SELECT 1 + value AS value\n"),
* Arguments: bigquery.RoutineArgumentArray{
* &bigquery.RoutineArgumentArgs{
* Name: pulumi.String("value"),
* ArgumentKind: pulumi.String("FIXED_TYPE"),
* DataType: pulumi.String(json0),
* },
* },
* ReturnTableType: pulumi.String(json1),
* })
* if err != nil {
* return err
* }
* private, err := bigquery.NewDataset(ctx, "private", &bigquery.DatasetArgs{
* DatasetId: pulumi.String("private_dataset"),
* Description: pulumi.String("This dataset is private"),
* })
* if err != nil {
* return err
* }
* _, err = bigquery.NewDatasetAccess(ctx, "authorized_routine", &bigquery.DatasetAccessArgs{
* DatasetId: private.DatasetId,
* Routine: &bigquery.DatasetAccessRoutineArgs{
* ProjectId: publicRoutine.Project,
* DatasetId: publicRoutine.DatasetId,
* RoutineId: publicRoutine.RoutineId,
* },
* })
* if err != nil {
* return err
* }
* return nil
* })
* }
* ```
* ```java
* 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.Routine;
* import com.pulumi.gcp.bigquery.RoutineArgs;
* import com.pulumi.gcp.bigquery.inputs.RoutineArgumentArgs;
* import com.pulumi.gcp.bigquery.DatasetAccess;
* import com.pulumi.gcp.bigquery.DatasetAccessArgs;
* import com.pulumi.gcp.bigquery.inputs.DatasetAccessRoutineArgs;
* import static com.pulumi.codegen.internal.Serialization.*;
* 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 public_ = new Dataset("public", DatasetArgs.builder()
* .datasetId("public_dataset")
* .description("This dataset is public")
* .build());
* var publicRoutine = new Routine("publicRoutine", RoutineArgs.builder()
* .datasetId(public_.datasetId())
* .routineId("public_routine")
* .routineType("TABLE_VALUED_FUNCTION")
* .language("SQL")
* .definitionBody("""
* SELECT 1 + value AS value
* """)
* .arguments(RoutineArgumentArgs.builder()
* .name("value")
* .argumentKind("FIXED_TYPE")
* .dataType(serializeJson(
* jsonObject(
* jsonProperty("typeKind", "INT64")
* )))
* .build())
* .returnTableType(serializeJson(
* jsonObject(
* jsonProperty("columns", jsonArray(jsonObject(
* jsonProperty("name", "value"),
* jsonProperty("type", jsonObject(
* jsonProperty("typeKind", "INT64")
* ))
* )))
* )))
* .build());
* var private_ = new Dataset("private", DatasetArgs.builder()
* .datasetId("private_dataset")
* .description("This dataset is private")
* .build());
* var authorizedRoutine = new DatasetAccess("authorizedRoutine", DatasetAccessArgs.builder()
* .datasetId(private_.datasetId())
* .routine(DatasetAccessRoutineArgs.builder()
* .projectId(publicRoutine.project())
* .datasetId(publicRoutine.datasetId())
* .routineId(publicRoutine.routineId())
* .build())
* .build());
* }
* }
* ```
* ```yaml
* resources:
* public:
* type: gcp:bigquery:Dataset
* properties:
* datasetId: public_dataset
* description: This dataset is public
* publicRoutine:
* type: gcp:bigquery:Routine
* name: public
* properties:
* datasetId: ${public.datasetId}
* routineId: public_routine
* routineType: TABLE_VALUED_FUNCTION
* language: SQL
* definitionBody: |
* SELECT 1 + value AS value
* arguments:
* - name: value
* argumentKind: FIXED_TYPE
* dataType:
* fn::toJSON:
* typeKind: INT64
* returnTableType:
* fn::toJSON:
* columns:
* - name: value
* type:
* typeKind: INT64
* private:
* type: gcp:bigquery:Dataset
* properties:
* datasetId: private_dataset
* description: This dataset is private
* authorizedRoutine:
* type: gcp:bigquery:DatasetAccess
* name: authorized_routine
* properties:
* datasetId: ${private.datasetId}
* routine:
* projectId: ${publicRoutine.project}
* datasetId: ${publicRoutine.datasetId}
* routineId: ${publicRoutine.routineId}
* ```
*
* ## Import
* This resource does not support import.
*/
public class DatasetAccess internal constructor(
override val javaResource: com.pulumi.gcp.bigquery.DatasetAccess,
) : KotlinCustomResource(javaResource, DatasetAccessMapper) {
/**
* 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
*/
public val apiUpdatedMember: Output
get() = javaResource.apiUpdatedMember().applyValue({ args0 -> args0 })
/**
* Grants all resources of particular types in a particular dataset read access to the current dataset.
* Structure is documented below.
*/
public val authorizedDataset: Output?
get() = javaResource.authorizedDataset().applyValue({ args0 ->
args0.map({ args0 ->
args0.let({ args0 -> datasetAccessAuthorizedDatasetToKotlin(args0) })
}).orElse(null)
})
/**
* A unique ID for this dataset, without the project name. The ID
* must contain only letters (a-z, A-Z), numbers (0-9), or
* underscores (_). The maximum length is 1,024 characters.
* - - -
*/
public val datasetId: Output
get() = javaResource.datasetId().applyValue({ args0 -> args0 })
/**
* A domain to grant access to. Any users signed in with the
* domain specified will be granted the specified access
*/
public val domain: Output?
get() = javaResource.domain().applyValue({ args0 -> args0.map({ args0 -> args0 }).orElse(null) })
/**
* An email address of a Google Group to grant access to.
*/
public val groupByEmail: Output?
get() = javaResource.groupByEmail().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* Some other type of member that appears in the IAM Policy but isn't a user,
* group, domain, or special group. For example: `allUsers`
*/
public val iamMember: Output?
get() = javaResource.iamMember().applyValue({ args0 -> args0.map({ args0 -> args0 }).orElse(null) })
/**
* The ID of the project in which the resource belongs.
* If it is not provided, the provider project is used.
*/
public val project: Output
get() = javaResource.project().applyValue({ args0 -> args0 })
/**
* Describes the rights granted to the user specified by the other
* member of the access object. Basic, predefined, and custom roles are
* supported. Predefined roles that have equivalent basic roles are
* swapped by the API to their basic counterparts, and will show a diff
* post-create. See
* [official docs](https://cloud.google.com/bigquery/docs/access-control).
*/
public val role: Output?
get() = javaResource.role().applyValue({ args0 -> args0.map({ args0 -> args0 }).orElse(null) })
/**
* A routine from a different dataset to grant access to. Queries
* executed against that routine will have read access to tables in
* this dataset. The role field is not required when this field is
* set. If that routine is updated by any user, access to the routine
* needs to be granted again via an update operation.
* Structure is documented below.
*/
public val routine: Output?
get() = javaResource.routine().applyValue({ args0 ->
args0.map({ args0 ->
args0.let({ args0 ->
datasetAccessRoutineToKotlin(args0)
})
}).orElse(null)
})
/**
* A special group to grant access to. Possible values include:
* * `projectOwners`: Owners of the enclosing project.
* * `projectReaders`: Readers of the enclosing project.
* * `projectWriters`: Writers of the enclosing project.
* * `allAuthenticatedUsers`: All authenticated BigQuery users.
*/
public val specialGroup: Output?
get() = javaResource.specialGroup().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* An email address of a user to grant access to. For example:
* [email protected]
*/
public val userByEmail: Output?
get() = javaResource.userByEmail().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* A view from a different dataset to grant access to. Queries
* executed against that view will have read access to tables in
* this dataset. The role field is not required when this field is
* set. If that view is updated by any user, access to the view
* needs to be granted again via an update operation.
* Structure is documented below.
*/
public val view: Output?
get() = javaResource.view().applyValue({ args0 ->
args0.map({ args0 ->
args0.let({ args0 ->
datasetAccessViewToKotlin(args0)
})
}).orElse(null)
})
}
public object DatasetAccessMapper : ResourceMapper {
override fun supportsMappingOfType(javaResource: Resource): Boolean =
com.pulumi.gcp.bigquery.DatasetAccess::class == javaResource::class
override fun map(javaResource: Resource): DatasetAccess = DatasetAccess(
javaResource as
com.pulumi.gcp.bigquery.DatasetAccess,
)
}
/**
* @see [DatasetAccess].
* @param name The _unique_ name of the resulting resource.
* @param block Builder for [DatasetAccess].
*/
public suspend fun datasetAccess(
name: String,
block: suspend DatasetAccessResourceBuilder.() -> Unit,
): DatasetAccess {
val builder = DatasetAccessResourceBuilder()
builder.name(name)
block(builder)
return builder.build()
}
/**
* @see [DatasetAccess].
* @param name The _unique_ name of the resulting resource.
*/
public fun datasetAccess(name: String): DatasetAccess {
val builder = DatasetAccessResourceBuilder()
builder.name(name)
return builder.build()
}
