DataSet class

Resource for managing a QuickSight Data Set.

Example Usage

Basic Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.quicksight.DataSet("example", {
    physicalTableMaps: [{
        s3Source: {
            uploadSettings: {
                format: "JSON",
            },
            inputColumns: [{
                name: "Column1",
                type: "STRING",
            }],
            dataSourceArn: exampleAwsQuicksightDataSource.arn,
        },
        physicalTableMapId: "example-id",
    }],
    dataSetId: "example-id",
    name: "example-name",
    importMode: "SPICE",
});
import pulumi
import pulumi_aws as aws

example = aws.quicksight.DataSet("example",
    physical_table_maps=[{
        "s3_source": {
            "upload_settings": {
                "format": "JSON",
            },
            "input_columns": [{
                "name": "Column1",
                "type": "STRING",
            }],
            "data_source_arn": example_aws_quicksight_data_source["arn"],
        },
        "physical_table_map_id": "example-id",
    }],
    data_set_id="example-id",
    name="example-name",
    import_mode="SPICE")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Quicksight.DataSet("example", new()
    {
        PhysicalTableMaps = new[]
        {
            new Aws.Quicksight.Inputs.DataSetPhysicalTableMapArgs
            {
                S3Source = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceArgs
                {
                    UploadSettings = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceUploadSettingsArgs
                    {
                        Format = "JSON",
                    },
                    InputColumns = new[]
                    {
                        new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceInputColumnArgs
                        {
                            Name = "Column1",
                            Type = "STRING",
                        },
                    },
                    DataSourceArn = exampleAwsQuicksightDataSource.Arn,
                },
                PhysicalTableMapId = "example-id",
            },
        },
        DataSetId = "example-id",
        Name = "example-name",
        ImportMode = "SPICE",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/quicksight"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := quicksight.NewDataSet(ctx, "example", &quicksight.DataSetArgs{
			PhysicalTableMaps: quicksight.DataSetPhysicalTableMapArray{
				&quicksight.DataSetPhysicalTableMapArgs{
					S3Source: &quicksight.DataSetPhysicalTableMapS3SourceArgs{
						UploadSettings: &quicksight.DataSetPhysicalTableMapS3SourceUploadSettingsArgs{
							Format: pulumi.String("JSON"),
						},
						InputColumns: quicksight.DataSetPhysicalTableMapS3SourceInputColumnArray{
							&quicksight.DataSetPhysicalTableMapS3SourceInputColumnArgs{
								Name: pulumi.String("Column1"),
								Type: pulumi.String("STRING"),
							},
						},
						DataSourceArn: pulumi.Any(exampleAwsQuicksightDataSource.Arn),
					},
					PhysicalTableMapId: pulumi.String("example-id"),
				},
			},
			DataSetId:  pulumi.String("example-id"),
			Name:       pulumi.String("example-name"),
			ImportMode: pulumi.String("SPICE"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_quicksight_dataset" "example" {
  physical_table_maps {
    s3_source = {
      upload_settings = {
        format = "JSON"
      }
      input_columns = [{
        "name" = "Column1"
        "type" = "STRING"
      }]
      data_source_arn = exampleAwsQuicksightDataSource.arn
    }
    physical_table_map_id = "example-id"
  }
  data_set_id = "example-id"
  name        = "example-name"
  import_mode = "SPICE"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.quicksight.DataSet;
import com.pulumi.aws.quicksight.DataSetArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapS3SourceArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapS3SourceUploadSettingsArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapS3SourceInputColumnArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 example = new DataSet("example", DataSetArgs.builder()
            .physicalTableMaps(DataSetPhysicalTableMapArgs.builder()
                .s3Source(DataSetPhysicalTableMapS3SourceArgs.builder()
                    .uploadSettings(DataSetPhysicalTableMapS3SourceUploadSettingsArgs.builder()
                        .format("JSON")
                        .build())
                    .inputColumns(DataSetPhysicalTableMapS3SourceInputColumnArgs.builder()
                        .name("Column1")
                        .type("STRING")
                        .build())
                    .dataSourceArn(exampleAwsQuicksightDataSource.arn())
                    .build())
                .physicalTableMapId("example-id")
                .build())
            .dataSetId("example-id")
            .name("example-name")
            .importMode("SPICE")
            .build());

    }
}
resources:
  example:
    type: aws:quicksight:DataSet
    properties:
      physicalTableMaps:
        - s3Source:
            uploadSettings:
              format: JSON
            inputColumns:
              - name: Column1
                type: STRING
            dataSourceArn: ${exampleAwsQuicksightDataSource.arn}
          physicalTableMapId: example-id
      dataSetId: example-id
      name: example-name
      importMode: SPICE

With useAs

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.quicksight.DataSet("example", {
    physicalTableMaps: [{
        s3Source: {
            uploadSettings: {
                format: "JSON",
            },
            inputColumns: [{
                name: "UserName",
                type: "STRING",
            }],
            dataSourceArn: exampleAwsQuicksightDataSource.arn,
        },
        physicalTableMapId: "example-id",
    }],
    dataSetId: "example-id",
    name: "example-name",
    importMode: "SPICE",
    useAs: "RLS_RULES",
});
import pulumi
import pulumi_aws as aws

example = aws.quicksight.DataSet("example",
    physical_table_maps=[{
        "s3_source": {
            "upload_settings": {
                "format": "JSON",
            },
            "input_columns": [{
                "name": "UserName",
                "type": "STRING",
            }],
            "data_source_arn": example_aws_quicksight_data_source["arn"],
        },
        "physical_table_map_id": "example-id",
    }],
    data_set_id="example-id",
    name="example-name",
    import_mode="SPICE",
    use_as="RLS_RULES")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Quicksight.DataSet("example", new()
    {
        PhysicalTableMaps = new[]
        {
            new Aws.Quicksight.Inputs.DataSetPhysicalTableMapArgs
            {
                S3Source = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceArgs
                {
                    UploadSettings = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceUploadSettingsArgs
                    {
                        Format = "JSON",
                    },
                    InputColumns = new[]
                    {
                        new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceInputColumnArgs
                        {
                            Name = "UserName",
                            Type = "STRING",
                        },
                    },
                    DataSourceArn = exampleAwsQuicksightDataSource.Arn,
                },
                PhysicalTableMapId = "example-id",
            },
        },
        DataSetId = "example-id",
        Name = "example-name",
        ImportMode = "SPICE",
        UseAs = "RLS_RULES",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/quicksight"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := quicksight.NewDataSet(ctx, "example", &quicksight.DataSetArgs{
			PhysicalTableMaps: quicksight.DataSetPhysicalTableMapArray{
				&quicksight.DataSetPhysicalTableMapArgs{
					S3Source: &quicksight.DataSetPhysicalTableMapS3SourceArgs{
						UploadSettings: &quicksight.DataSetPhysicalTableMapS3SourceUploadSettingsArgs{
							Format: pulumi.String("JSON"),
						},
						InputColumns: quicksight.DataSetPhysicalTableMapS3SourceInputColumnArray{
							&quicksight.DataSetPhysicalTableMapS3SourceInputColumnArgs{
								Name: pulumi.String("UserName"),
								Type: pulumi.String("STRING"),
							},
						},
						DataSourceArn: pulumi.Any(exampleAwsQuicksightDataSource.Arn),
					},
					PhysicalTableMapId: pulumi.String("example-id"),
				},
			},
			DataSetId:  pulumi.String("example-id"),
			Name:       pulumi.String("example-name"),
			ImportMode: pulumi.String("SPICE"),
			UseAs:      pulumi.String("RLS_RULES"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_quicksight_dataset" "example" {
  physical_table_maps {
    s3_source = {
      upload_settings = {
        format = "JSON"
      }
      input_columns = [{
        "name" = "UserName"
        "type" = "STRING"
      }]
      data_source_arn = exampleAwsQuicksightDataSource.arn
    }
    physical_table_map_id = "example-id"
  }
  data_set_id = "example-id"
  name        = "example-name"
  import_mode = "SPICE"
  use_as      = "RLS_RULES"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.quicksight.DataSet;
import com.pulumi.aws.quicksight.DataSetArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapS3SourceArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapS3SourceUploadSettingsArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapS3SourceInputColumnArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 example = new DataSet("example", DataSetArgs.builder()
            .physicalTableMaps(DataSetPhysicalTableMapArgs.builder()
                .s3Source(DataSetPhysicalTableMapS3SourceArgs.builder()
                    .uploadSettings(DataSetPhysicalTableMapS3SourceUploadSettingsArgs.builder()
                        .format("JSON")
                        .build())
                    .inputColumns(DataSetPhysicalTableMapS3SourceInputColumnArgs.builder()
                        .name("UserName")
                        .type("STRING")
                        .build())
                    .dataSourceArn(exampleAwsQuicksightDataSource.arn())
                    .build())
                .physicalTableMapId("example-id")
                .build())
            .dataSetId("example-id")
            .name("example-name")
            .importMode("SPICE")
            .useAs("RLS_RULES")
            .build());

    }
}
resources:
  example:
    type: aws:quicksight:DataSet
    properties:
      physicalTableMaps:
        - s3Source:
            uploadSettings:
              format: JSON
            inputColumns:
              - name: UserName
                type: STRING
            dataSourceArn: ${exampleAwsQuicksightDataSource.arn}
          physicalTableMapId: example-id
      dataSetId: example-id
      name: example-name
      importMode: SPICE
      useAs: RLS_RULES

With Column Level Permission Rules

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.quicksight.DataSet("example", {
    columnLevelPermissionRules: [{
        columnNames: ["Column1"],
        principals: [exampleAwsQuicksightUser.arn],
    }],
    physicalTableMaps: [{
        s3Source: {
            uploadSettings: {
                format: "JSON",
            },
            inputColumns: [{
                name: "Column1",
                type: "STRING",
            }],
            dataSourceArn: exampleAwsQuicksightDataSource.arn,
        },
        physicalTableMapId: "example-id",
    }],
    dataSetId: "example-id",
    name: "example-name",
    importMode: "SPICE",
});
import pulumi
import pulumi_aws as aws

example = aws.quicksight.DataSet("example",
    column_level_permission_rules=[{
        "column_names": ["Column1"],
        "principals": [example_aws_quicksight_user["arn"]],
    }],
    physical_table_maps=[{
        "s3_source": {
            "upload_settings": {
                "format": "JSON",
            },
            "input_columns": [{
                "name": "Column1",
                "type": "STRING",
            }],
            "data_source_arn": example_aws_quicksight_data_source["arn"],
        },
        "physical_table_map_id": "example-id",
    }],
    data_set_id="example-id",
    name="example-name",
    import_mode="SPICE")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Quicksight.DataSet("example", new()
    {
        ColumnLevelPermissionRules = new[]
        {
            new Aws.Quicksight.Inputs.DataSetColumnLevelPermissionRuleArgs
            {
                ColumnNames = new[]
                {
                    "Column1",
                },
                Principals = new[]
                {
                    exampleAwsQuicksightUser.Arn,
                },
            },
        },
        PhysicalTableMaps = new[]
        {
            new Aws.Quicksight.Inputs.DataSetPhysicalTableMapArgs
            {
                S3Source = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceArgs
                {
                    UploadSettings = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceUploadSettingsArgs
                    {
                        Format = "JSON",
                    },
                    InputColumns = new[]
                    {
                        new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceInputColumnArgs
                        {
                            Name = "Column1",
                            Type = "STRING",
                        },
                    },
                    DataSourceArn = exampleAwsQuicksightDataSource.Arn,
                },
                PhysicalTableMapId = "example-id",
            },
        },
        DataSetId = "example-id",
        Name = "example-name",
        ImportMode = "SPICE",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/quicksight"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := quicksight.NewDataSet(ctx, "example", &quicksight.DataSetArgs{
			ColumnLevelPermissionRules: quicksight.DataSetColumnLevelPermissionRuleArray{
				&quicksight.DataSetColumnLevelPermissionRuleArgs{
					ColumnNames: pulumi.StringArray{
						pulumi.String("Column1"),
					},
					Principals: pulumi.StringArray{
						exampleAwsQuicksightUser.Arn,
					},
				},
			},
			PhysicalTableMaps: quicksight.DataSetPhysicalTableMapArray{
				&quicksight.DataSetPhysicalTableMapArgs{
					S3Source: &quicksight.DataSetPhysicalTableMapS3SourceArgs{
						UploadSettings: &quicksight.DataSetPhysicalTableMapS3SourceUploadSettingsArgs{
							Format: pulumi.String("JSON"),
						},
						InputColumns: quicksight.DataSetPhysicalTableMapS3SourceInputColumnArray{
							&quicksight.DataSetPhysicalTableMapS3SourceInputColumnArgs{
								Name: pulumi.String("Column1"),
								Type: pulumi.String("STRING"),
							},
						},
						DataSourceArn: pulumi.Any(exampleAwsQuicksightDataSource.Arn),
					},
					PhysicalTableMapId: pulumi.String("example-id"),
				},
			},
			DataSetId:  pulumi.String("example-id"),
			Name:       pulumi.String("example-name"),
			ImportMode: pulumi.String("SPICE"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_quicksight_dataset" "example" {
  column_level_permission_rules {
    column_names = ["Column1"]
    principals   = [exampleAwsQuicksightUser.arn]
  }
  physical_table_maps {
    s3_source = {
      upload_settings = {
        format = "JSON"
      }
      input_columns = [{
        "name" = "Column1"
        "type" = "STRING"
      }]
      data_source_arn = exampleAwsQuicksightDataSource.arn
    }
    physical_table_map_id = "example-id"
  }
  data_set_id = "example-id"
  name        = "example-name"
  import_mode = "SPICE"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.quicksight.DataSet;
import com.pulumi.aws.quicksight.DataSetArgs;
import com.pulumi.aws.quicksight.inputs.DataSetColumnLevelPermissionRuleArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapS3SourceArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapS3SourceUploadSettingsArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapS3SourceInputColumnArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 example = new DataSet("example", DataSetArgs.builder()
            .columnLevelPermissionRules(DataSetColumnLevelPermissionRuleArgs.builder()
                .columnNames("Column1")
                .principals(exampleAwsQuicksightUser.arn())
                .build())
            .physicalTableMaps(DataSetPhysicalTableMapArgs.builder()
                .s3Source(DataSetPhysicalTableMapS3SourceArgs.builder()
                    .uploadSettings(DataSetPhysicalTableMapS3SourceUploadSettingsArgs.builder()
                        .format("JSON")
                        .build())
                    .inputColumns(DataSetPhysicalTableMapS3SourceInputColumnArgs.builder()
                        .name("Column1")
                        .type("STRING")
                        .build())
                    .dataSourceArn(exampleAwsQuicksightDataSource.arn())
                    .build())
                .physicalTableMapId("example-id")
                .build())
            .dataSetId("example-id")
            .name("example-name")
            .importMode("SPICE")
            .build());

    }
}
resources:
  example:
    type: aws:quicksight:DataSet
    properties:
      columnLevelPermissionRules:
        - columnNames:
            - Column1
          principals:
            - ${exampleAwsQuicksightUser.arn}
      physicalTableMaps:
        - s3Source:
            uploadSettings:
              format: JSON
            inputColumns:
              - name: Column1
                type: STRING
            dataSourceArn: ${exampleAwsQuicksightDataSource.arn}
          physicalTableMapId: example-id
      dataSetId: example-id
      name: example-name
      importMode: SPICE

With Field Folders

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.quicksight.DataSet("example", {
    fieldFolders: [{
        fieldFoldersId: "example-id",
        columns: ["Column1"],
        description: "example description",
    }],
    physicalTableMaps: [{
        s3Source: {
            uploadSettings: {
                format: "JSON",
            },
            inputColumns: [{
                name: "Column1",
                type: "STRING",
            }],
            dataSourceArn: exampleAwsQuicksightDataSource.arn,
        },
        physicalTableMapId: "example-id",
    }],
    dataSetId: "example-id",
    name: "example-name",
    importMode: "SPICE",
});
import pulumi
import pulumi_aws as aws

example = aws.quicksight.DataSet("example",
    field_folders=[{
        "field_folders_id": "example-id",
        "columns": ["Column1"],
        "description": "example description",
    }],
    physical_table_maps=[{
        "s3_source": {
            "upload_settings": {
                "format": "JSON",
            },
            "input_columns": [{
                "name": "Column1",
                "type": "STRING",
            }],
            "data_source_arn": example_aws_quicksight_data_source["arn"],
        },
        "physical_table_map_id": "example-id",
    }],
    data_set_id="example-id",
    name="example-name",
    import_mode="SPICE")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Quicksight.DataSet("example", new()
    {
        FieldFolders = new[]
        {
            new Aws.Quicksight.Inputs.DataSetFieldFolderArgs
            {
                FieldFoldersId = "example-id",
                Columns = new[]
                {
                    "Column1",
                },
                Description = "example description",
            },
        },
        PhysicalTableMaps = new[]
        {
            new Aws.Quicksight.Inputs.DataSetPhysicalTableMapArgs
            {
                S3Source = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceArgs
                {
                    UploadSettings = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceUploadSettingsArgs
                    {
                        Format = "JSON",
                    },
                    InputColumns = new[]
                    {
                        new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceInputColumnArgs
                        {
                            Name = "Column1",
                            Type = "STRING",
                        },
                    },
                    DataSourceArn = exampleAwsQuicksightDataSource.Arn,
                },
                PhysicalTableMapId = "example-id",
            },
        },
        DataSetId = "example-id",
        Name = "example-name",
        ImportMode = "SPICE",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/quicksight"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := quicksight.NewDataSet(ctx, "example", &quicksight.DataSetArgs{
			FieldFolders: quicksight.DataSetFieldFolderArray{
				&quicksight.DataSetFieldFolderArgs{
					FieldFoldersId: pulumi.String("example-id"),
					Columns: pulumi.StringArray{
						pulumi.String("Column1"),
					},
					Description: pulumi.String("example description"),
				},
			},
			PhysicalTableMaps: quicksight.DataSetPhysicalTableMapArray{
				&quicksight.DataSetPhysicalTableMapArgs{
					S3Source: &quicksight.DataSetPhysicalTableMapS3SourceArgs{
						UploadSettings: &quicksight.DataSetPhysicalTableMapS3SourceUploadSettingsArgs{
							Format: pulumi.String("JSON"),
						},
						InputColumns: quicksight.DataSetPhysicalTableMapS3SourceInputColumnArray{
							&quicksight.DataSetPhysicalTableMapS3SourceInputColumnArgs{
								Name: pulumi.String("Column1"),
								Type: pulumi.String("STRING"),
							},
						},
						DataSourceArn: pulumi.Any(exampleAwsQuicksightDataSource.Arn),
					},
					PhysicalTableMapId: pulumi.String("example-id"),
				},
			},
			DataSetId:  pulumi.String("example-id"),
			Name:       pulumi.String("example-name"),
			ImportMode: pulumi.String("SPICE"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_quicksight_dataset" "example" {
  field_folders {
    field_folders_id = "example-id"
    columns          = ["Column1"]
    description      = "example description"
  }
  physical_table_maps {
    s3_source = {
      upload_settings = {
        format = "JSON"
      }
      input_columns = [{
        "name" = "Column1"
        "type" = "STRING"
      }]
      data_source_arn = exampleAwsQuicksightDataSource.arn
    }
    physical_table_map_id = "example-id"
  }
  data_set_id = "example-id"
  name        = "example-name"
  import_mode = "SPICE"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.quicksight.DataSet;
import com.pulumi.aws.quicksight.DataSetArgs;
import com.pulumi.aws.quicksight.inputs.DataSetFieldFolderArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapS3SourceArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapS3SourceUploadSettingsArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapS3SourceInputColumnArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 example = new DataSet("example", DataSetArgs.builder()
            .fieldFolders(DataSetFieldFolderArgs.builder()
                .fieldFoldersId("example-id")
                .columns("Column1")
                .description("example description")
                .build())
            .physicalTableMaps(DataSetPhysicalTableMapArgs.builder()
                .s3Source(DataSetPhysicalTableMapS3SourceArgs.builder()
                    .uploadSettings(DataSetPhysicalTableMapS3SourceUploadSettingsArgs.builder()
                        .format("JSON")
                        .build())
                    .inputColumns(DataSetPhysicalTableMapS3SourceInputColumnArgs.builder()
                        .name("Column1")
                        .type("STRING")
                        .build())
                    .dataSourceArn(exampleAwsQuicksightDataSource.arn())
                    .build())
                .physicalTableMapId("example-id")
                .build())
            .dataSetId("example-id")
            .name("example-name")
            .importMode("SPICE")
            .build());

    }
}
resources:
  example:
    type: aws:quicksight:DataSet
    properties:
      fieldFolders:
        - fieldFoldersId: example-id
          columns:
            - Column1
          description: example description
      physicalTableMaps:
        - s3Source:
            uploadSettings:
              format: JSON
            inputColumns:
              - name: Column1
                type: STRING
            dataSourceArn: ${exampleAwsQuicksightDataSource.arn}
          physicalTableMapId: example-id
      dataSetId: example-id
      name: example-name
      importMode: SPICE

With Permissions

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.quicksight.DataSet("example", {
    permissions: [{
        actions: [
            "quicksight:DescribeDataSet",
            "quicksight:DescribeDataSetPermissions",
            "quicksight:PassDataSet",
            "quicksight:DescribeIngestion",
            "quicksight:ListIngestions",
        ],
        principal: exampleAwsQuicksightUser.arn,
    }],
    physicalTableMaps: [{
        s3Source: {
            uploadSettings: {
                format: "JSON",
            },
            inputColumns: [{
                name: "Column1",
                type: "STRING",
            }],
            dataSourceArn: exampleAwsQuicksightDataSource.arn,
        },
        physicalTableMapId: "example-id",
    }],
    dataSetId: "example-id",
    name: "example-name",
    importMode: "SPICE",
});
import pulumi
import pulumi_aws as aws

example = aws.quicksight.DataSet("example",
    permissions=[{
        "actions": [
            "quicksight:DescribeDataSet",
            "quicksight:DescribeDataSetPermissions",
            "quicksight:PassDataSet",
            "quicksight:DescribeIngestion",
            "quicksight:ListIngestions",
        ],
        "principal": example_aws_quicksight_user["arn"],
    }],
    physical_table_maps=[{
        "s3_source": {
            "upload_settings": {
                "format": "JSON",
            },
            "input_columns": [{
                "name": "Column1",
                "type": "STRING",
            }],
            "data_source_arn": example_aws_quicksight_data_source["arn"],
        },
        "physical_table_map_id": "example-id",
    }],
    data_set_id="example-id",
    name="example-name",
    import_mode="SPICE")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Quicksight.DataSet("example", new()
    {
        Permissions = new[]
        {
            new Aws.Quicksight.Inputs.DataSetPermissionArgs
            {
                Actions = new[]
                {
                    "quicksight:DescribeDataSet",
                    "quicksight:DescribeDataSetPermissions",
                    "quicksight:PassDataSet",
                    "quicksight:DescribeIngestion",
                    "quicksight:ListIngestions",
                },
                Principal = exampleAwsQuicksightUser.Arn,
            },
        },
        PhysicalTableMaps = new[]
        {
            new Aws.Quicksight.Inputs.DataSetPhysicalTableMapArgs
            {
                S3Source = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceArgs
                {
                    UploadSettings = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceUploadSettingsArgs
                    {
                        Format = "JSON",
                    },
                    InputColumns = new[]
                    {
                        new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceInputColumnArgs
                        {
                            Name = "Column1",
                            Type = "STRING",
                        },
                    },
                    DataSourceArn = exampleAwsQuicksightDataSource.Arn,
                },
                PhysicalTableMapId = "example-id",
            },
        },
        DataSetId = "example-id",
        Name = "example-name",
        ImportMode = "SPICE",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/quicksight"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := quicksight.NewDataSet(ctx, "example", &quicksight.DataSetArgs{
			Permissions: quicksight.DataSetPermissionArray{
				&quicksight.DataSetPermissionArgs{
					Actions: pulumi.StringArray{
						pulumi.String("quicksight:DescribeDataSet"),
						pulumi.String("quicksight:DescribeDataSetPermissions"),
						pulumi.String("quicksight:PassDataSet"),
						pulumi.String("quicksight:DescribeIngestion"),
						pulumi.String("quicksight:ListIngestions"),
					},
					Principal: pulumi.Any(exampleAwsQuicksightUser.Arn),
				},
			},
			PhysicalTableMaps: quicksight.DataSetPhysicalTableMapArray{
				&quicksight.DataSetPhysicalTableMapArgs{
					S3Source: &quicksight.DataSetPhysicalTableMapS3SourceArgs{
						UploadSettings: &quicksight.DataSetPhysicalTableMapS3SourceUploadSettingsArgs{
							Format: pulumi.String("JSON"),
						},
						InputColumns: quicksight.DataSetPhysicalTableMapS3SourceInputColumnArray{
							&quicksight.DataSetPhysicalTableMapS3SourceInputColumnArgs{
								Name: pulumi.String("Column1"),
								Type: pulumi.String("STRING"),
							},
						},
						DataSourceArn: pulumi.Any(exampleAwsQuicksightDataSource.Arn),
					},
					PhysicalTableMapId: pulumi.String("example-id"),
				},
			},
			DataSetId:  pulumi.String("example-id"),
			Name:       pulumi.String("example-name"),
			ImportMode: pulumi.String("SPICE"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_quicksight_dataset" "example" {
  permissions {
    actions   = ["quicksight:DescribeDataSet", "quicksight:DescribeDataSetPermissions", "quicksight:PassDataSet", "quicksight:DescribeIngestion", "quicksight:ListIngestions"]
    principal = exampleAwsQuicksightUser.arn
  }
  physical_table_maps {
    s3_source = {
      upload_settings = {
        format = "JSON"
      }
      input_columns = [{
        "name" = "Column1"
        "type" = "STRING"
      }]
      data_source_arn = exampleAwsQuicksightDataSource.arn
    }
    physical_table_map_id = "example-id"
  }
  data_set_id = "example-id"
  name        = "example-name"
  import_mode = "SPICE"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.quicksight.DataSet;
import com.pulumi.aws.quicksight.DataSetArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPermissionArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapS3SourceArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapS3SourceUploadSettingsArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapS3SourceInputColumnArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 example = new DataSet("example", DataSetArgs.builder()
            .permissions(DataSetPermissionArgs.builder()
                .actions(
                    "quicksight:DescribeDataSet",
                    "quicksight:DescribeDataSetPermissions",
                    "quicksight:PassDataSet",
                    "quicksight:DescribeIngestion",
                    "quicksight:ListIngestions")
                .principal(exampleAwsQuicksightUser.arn())
                .build())
            .physicalTableMaps(DataSetPhysicalTableMapArgs.builder()
                .s3Source(DataSetPhysicalTableMapS3SourceArgs.builder()
                    .uploadSettings(DataSetPhysicalTableMapS3SourceUploadSettingsArgs.builder()
                        .format("JSON")
                        .build())
                    .inputColumns(DataSetPhysicalTableMapS3SourceInputColumnArgs.builder()
                        .name("Column1")
                        .type("STRING")
                        .build())
                    .dataSourceArn(exampleAwsQuicksightDataSource.arn())
                    .build())
                .physicalTableMapId("example-id")
                .build())
            .dataSetId("example-id")
            .name("example-name")
            .importMode("SPICE")
            .build());

    }
}
resources:
  example:
    type: aws:quicksight:DataSet
    properties:
      permissions:
        - actions:
            - quicksight:DescribeDataSet
            - quicksight:DescribeDataSetPermissions
            - quicksight:PassDataSet
            - quicksight:DescribeIngestion
            - quicksight:ListIngestions
          principal: ${exampleAwsQuicksightUser.arn}
      physicalTableMaps:
        - s3Source:
            uploadSettings:
              format: JSON
            inputColumns:
              - name: Column1
                type: STRING
            dataSourceArn: ${exampleAwsQuicksightDataSource.arn}
          physicalTableMapId: example-id
      dataSetId: example-id
      name: example-name
      importMode: SPICE

With Row Level Permission Tag Configuration

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.quicksight.DataSet("example", {
    rowLevelPermissionTagConfiguration: {
        tagRules: [{
            columnName: "Column1",
            tagKey: "tagkey",
            matchAllValue: "*",
            tagMultiValueDelimiter: ",",
        }],
        status: "ENABLED",
    },
    physicalTableMaps: [{
        s3Source: {
            uploadSettings: {
                format: "JSON",
            },
            inputColumns: [{
                name: "Column1",
                type: "STRING",
            }],
            dataSourceArn: exampleAwsQuicksightDataSource.arn,
        },
        physicalTableMapId: "example-id",
    }],
    dataSetId: "example-id",
    name: "example-name",
    importMode: "SPICE",
});
import pulumi
import pulumi_aws as aws

example = aws.quicksight.DataSet("example",
    row_level_permission_tag_configuration={
        "tag_rules": [{
            "column_name": "Column1",
            "tag_key": "tagkey",
            "match_all_value": "*",
            "tag_multi_value_delimiter": ",",
        }],
        "status": "ENABLED",
    },
    physical_table_maps=[{
        "s3_source": {
            "upload_settings": {
                "format": "JSON",
            },
            "input_columns": [{
                "name": "Column1",
                "type": "STRING",
            }],
            "data_source_arn": example_aws_quicksight_data_source["arn"],
        },
        "physical_table_map_id": "example-id",
    }],
    data_set_id="example-id",
    name="example-name",
    import_mode="SPICE")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Quicksight.DataSet("example", new()
    {
        RowLevelPermissionTagConfiguration = new Aws.Quicksight.Inputs.DataSetRowLevelPermissionTagConfigurationArgs
        {
            TagRules = new[]
            {
                new Aws.Quicksight.Inputs.DataSetRowLevelPermissionTagConfigurationTagRuleArgs
                {
                    ColumnName = "Column1",
                    TagKey = "tagkey",
                    MatchAllValue = "*",
                    TagMultiValueDelimiter = ",",
                },
            },
            Status = "ENABLED",
        },
        PhysicalTableMaps = new[]
        {
            new Aws.Quicksight.Inputs.DataSetPhysicalTableMapArgs
            {
                S3Source = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceArgs
                {
                    UploadSettings = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceUploadSettingsArgs
                    {
                        Format = "JSON",
                    },
                    InputColumns = new[]
                    {
                        new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceInputColumnArgs
                        {
                            Name = "Column1",
                            Type = "STRING",
                        },
                    },
                    DataSourceArn = exampleAwsQuicksightDataSource.Arn,
                },
                PhysicalTableMapId = "example-id",
            },
        },
        DataSetId = "example-id",
        Name = "example-name",
        ImportMode = "SPICE",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/quicksight"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := quicksight.NewDataSet(ctx, "example", &quicksight.DataSetArgs{
			RowLevelPermissionTagConfiguration: &quicksight.DataSetRowLevelPermissionTagConfigurationArgs{
				TagRules: quicksight.DataSetRowLevelPermissionTagConfigurationTagRuleArray{
					&quicksight.DataSetRowLevelPermissionTagConfigurationTagRuleArgs{
						ColumnName:             pulumi.String("Column1"),
						TagKey:                 pulumi.String("tagkey"),
						MatchAllValue:          pulumi.String("*"),
						TagMultiValueDelimiter: pulumi.String(","),
					},
				},
				Status: pulumi.String("ENABLED"),
			},
			PhysicalTableMaps: quicksight.DataSetPhysicalTableMapArray{
				&quicksight.DataSetPhysicalTableMapArgs{
					S3Source: &quicksight.DataSetPhysicalTableMapS3SourceArgs{
						UploadSettings: &quicksight.DataSetPhysicalTableMapS3SourceUploadSettingsArgs{
							Format: pulumi.String("JSON"),
						},
						InputColumns: quicksight.DataSetPhysicalTableMapS3SourceInputColumnArray{
							&quicksight.DataSetPhysicalTableMapS3SourceInputColumnArgs{
								Name: pulumi.String("Column1"),
								Type: pulumi.String("STRING"),
							},
						},
						DataSourceArn: pulumi.Any(exampleAwsQuicksightDataSource.Arn),
					},
					PhysicalTableMapId: pulumi.String("example-id"),
				},
			},
			DataSetId:  pulumi.String("example-id"),
			Name:       pulumi.String("example-name"),
			ImportMode: pulumi.String("SPICE"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_quicksight_dataset" "example" {
  row_level_permission_tag_configuration = {
    tag_rules = [{
      "columnName"             = "Column1"
      "tagKey"                 = "tagkey"
      "matchAllValue"          = "*"
      "tagMultiValueDelimiter" = ","
    }]
    status = "ENABLED"
  }
  physical_table_maps {
    s3_source = {
      upload_settings = {
        format = "JSON"
      }
      input_columns = [{
        "name" = "Column1"
        "type" = "STRING"
      }]
      data_source_arn = exampleAwsQuicksightDataSource.arn
    }
    physical_table_map_id = "example-id"
  }
  data_set_id = "example-id"
  name        = "example-name"
  import_mode = "SPICE"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.quicksight.DataSet;
import com.pulumi.aws.quicksight.DataSetArgs;
import com.pulumi.aws.quicksight.inputs.DataSetRowLevelPermissionTagConfigurationArgs;
import com.pulumi.aws.quicksight.inputs.DataSetRowLevelPermissionTagConfigurationTagRuleArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapS3SourceArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapS3SourceUploadSettingsArgs;
import com.pulumi.aws.quicksight.inputs.DataSetPhysicalTableMapS3SourceInputColumnArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 example = new DataSet("example", DataSetArgs.builder()
            .rowLevelPermissionTagConfiguration(DataSetRowLevelPermissionTagConfigurationArgs.builder()
                .tagRules(DataSetRowLevelPermissionTagConfigurationTagRuleArgs.builder()
                    .columnName("Column1")
                    .tagKey("tagkey")
                    .matchAllValue("*")
                    .tagMultiValueDelimiter(",")
                    .build())
                .status("ENABLED")
                .build())
            .physicalTableMaps(DataSetPhysicalTableMapArgs.builder()
                .s3Source(DataSetPhysicalTableMapS3SourceArgs.builder()
                    .uploadSettings(DataSetPhysicalTableMapS3SourceUploadSettingsArgs.builder()
                        .format("JSON")
                        .build())
                    .inputColumns(DataSetPhysicalTableMapS3SourceInputColumnArgs.builder()
                        .name("Column1")
                        .type("STRING")
                        .build())
                    .dataSourceArn(exampleAwsQuicksightDataSource.arn())
                    .build())
                .physicalTableMapId("example-id")
                .build())
            .dataSetId("example-id")
            .name("example-name")
            .importMode("SPICE")
            .build());

    }
}
resources:
  example:
    type: aws:quicksight:DataSet
    properties:
      rowLevelPermissionTagConfiguration:
        tagRules:
          - columnName: Column1
            tagKey: tagkey
            matchAllValue: '*'
            tagMultiValueDelimiter: ','
        status: ENABLED
      physicalTableMaps:
        - s3Source:
            uploadSettings:
              format: JSON
            inputColumns:
              - name: Column1
                type: STRING
            dataSourceArn: ${exampleAwsQuicksightDataSource.arn}
          physicalTableMapId: example-id
      dataSetId: example-id
      name: example-name
      importMode: SPICE

Import

Using pulumi import, import a QuickSight Data Set using the AWS account ID and data set ID separated by a comma (,). For example:

$ pulumi import aws:quicksight/dataSet:DataSet example 123456789012,example-id

Constructors

DataSet(String name, {DataSetArgs? args, CustomResourceOptions? options})
Creates a new DataSet. name The Pulumi resource name. args Arguments used to configure this DataSet. The set of arguments for DataSet. options Resource options controlling this resource's behavior.
DataSet.reference(String urn)
Creates a typed reference to an existing DataSet resource.

Properties

arn ↔ Output<String>
ARN of the data set.
latefinal
awsAccountId ↔ Output<String>
AWS account ID. Defaults to automatically determined account ID of the Terraform AWS provider.
latefinal
childResources → Set<Resource>
finalinherited
columnGroups ↔ Output<List<DataSetColumnGroup>?>
Groupings of columns that work together in certain Amazon QuickSight features. Currently, only geospatial hierarchy is supported. See column_groups.
latefinal
columnLevelPermissionRules ↔ Output<List<DataSetColumnLevelPermissionRule>?>
A set of 1 or more definitions of a ColumnLevelPermissionRule. See column_level_permission_rules.
latefinal
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
dataSetId ↔ Output<String>
Identifier for the data set.
latefinal
dataSetUsageConfiguration ↔ Output<DataSetDataSetUsageConfiguration>
The usage configuration to apply to child datasets that reference this dataset as a source. See data_set_usage_configuration.
latefinal
fieldFolders ↔ Output<List<DataSetFieldFolder>?>
The folder that contains fields and nested subfolders for your dataset. See field_folders.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
importMode ↔ Output<String>
Indicates whether you want to import the data into SPICE. Valid values are SPICE and DIRECT_QUERY.
latefinal
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
logicalTableMaps ↔ Output<List<DataSetLogicalTableMap>>
Configures the combination and transformation of the data from the physical tables. Maximum of 1 entry. See logical_table_map.
latefinal
name ↔ Output<String>
Display name for the dataset.
latefinal
outputColumns ↔ Output<List<DataSetOutputColumn>>
The final set of columns available for use in analyses and dashboards after all data preparation and transformation steps have been applied within the data set. See outputColumns Block below.
latefinal
permissions ↔ Output<List<DataSetPermission>?>
A set of resource permissions on the data source. Maximum of 64 items. See permissions.
latefinal
physicalTableMaps ↔ Output<List<DataSetPhysicalTableMap>?>
Declares the physical tables that are available in the underlying data sources. See physical_table_map.
latefinal
refreshProperties ↔ Output<DataSetRefreshProperties?>
The refresh properties for the data set. NOTE: Only valid when importMode is set to SPICE. See refresh_properties.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
rowLevelPermissionDataSet ↔ Output<DataSetRowLevelPermissionDataSet?>
The row-level security configuration for the data that you want to create. See row_level_permission_data_set.
latefinal
rowLevelPermissionTagConfiguration ↔ Output<DataSetRowLevelPermissionTagConfiguration?>
The configuration of tags on a dataset to set row-level security. Row-level security tags are currently supported for anonymous embedding only. See row_level_permission_tag_configuration.
latefinal
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
tags ↔ Output<Map<String, String>?>
Key-value map of resource tags. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
A map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited
useAs ↔ Output<String?>
Specifies the purpose of the data set. The only valid value is RLS_RULES, which designates this data set as a Row Level Security (RLS) rules dataset. An RLS rules dataset is used to control access to data at the row level in QuickSight analyses and dashboards. See the AWS documentation for details.
latefinal

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {DataSetState? state, CustomResourceOptions? options}) → DataSet
Gets an existing DataSet resource's state with the given name and id.