pulumi-aws-kotlin/com.pulumi.aws.quicksight.kotlin/DataSet

DataSet

class DataSet : KotlinCustomResource

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", {
    dataSetId: "example-id",
    name: "example-name",
    importMode: "SPICE",
    physicalTableMaps: [{
        physicalTableMapId: "example-id",
        s3Source: {
            dataSourceArn: exampleAwsQuicksightDataSource.arn,
            inputColumns: [{
                name: "Column1",
                type: "STRING",
            }],
            uploadSettings: {
                format: "JSON",
            },
        },
    }],
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
example = aws.quicksight.DataSet("example",
    data_set_id="example-id",
    name="example-name",
    import_mode="SPICE",
    physical_table_maps=[aws.quicksight.DataSetPhysicalTableMapArgs(
        physical_table_map_id="example-id",
        s3_source=aws.quicksight.DataSetPhysicalTableMapS3SourceArgs(
            data_source_arn=example_aws_quicksight_data_source["arn"],
            input_columns=[aws.quicksight.DataSetPhysicalTableMapS3SourceInputColumnArgs(
                name="Column1",
                type="STRING",
            )],
            upload_settings=aws.quicksight.DataSetPhysicalTableMapS3SourceUploadSettingsArgs(
                format="JSON",
            ),
        ),
    )])
Content copied to clipboard
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()
    {
        DataSetId = "example-id",
        Name = "example-name",
        ImportMode = "SPICE",
        PhysicalTableMaps = new[]
        {
            new Aws.Quicksight.Inputs.DataSetPhysicalTableMapArgs
            {
                PhysicalTableMapId = "example-id",
                S3Source = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceArgs
                {
                    DataSourceArn = exampleAwsQuicksightDataSource.Arn,
                    InputColumns = new[]
                    {
                        new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceInputColumnArgs
                        {
                            Name = "Column1",
                            Type = "STRING",
                        },
                    },
                    UploadSettings = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceUploadSettingsArgs
                    {
                        Format = "JSON",
                    },
                },
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/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{
			DataSetId:  pulumi.String("example-id"),
			Name:       pulumi.String("example-name"),
			ImportMode: pulumi.String("SPICE"),
			PhysicalTableMaps: quicksight.DataSetPhysicalTableMapArray{
				&quicksight.DataSetPhysicalTableMapArgs{
					PhysicalTableMapId: pulumi.String("example-id"),
					S3Source: &quicksight.DataSetPhysicalTableMapS3SourceArgs{
						DataSourceArn: pulumi.Any(exampleAwsQuicksightDataSource.Arn),
						InputColumns: quicksight.DataSetPhysicalTableMapS3SourceInputColumnArray{
							&quicksight.DataSetPhysicalTableMapS3SourceInputColumnArgs{
								Name: pulumi.String("Column1"),
								Type: pulumi.String("STRING"),
							},
						},
						UploadSettings: &quicksight.DataSetPhysicalTableMapS3SourceUploadSettingsArgs{
							Format: pulumi.String("JSON"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
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 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 example = new DataSet("example", DataSetArgs.builder()
            .dataSetId("example-id")
            .name("example-name")
            .importMode("SPICE")
            .physicalTableMaps(DataSetPhysicalTableMapArgs.builder()
                .physicalTableMapId("example-id")
                .s3Source(DataSetPhysicalTableMapS3SourceArgs.builder()
                    .dataSourceArn(exampleAwsQuicksightDataSource.arn())
                    .inputColumns(DataSetPhysicalTableMapS3SourceInputColumnArgs.builder()
                        .name("Column1")
                        .type("STRING")
                        .build())
                    .uploadSettings(DataSetPhysicalTableMapS3SourceUploadSettingsArgs.builder()
                        .format("JSON")
                        .build())
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: aws:quicksight:DataSet
    properties:
      dataSetId: example-id
      name: example-name
      importMode: SPICE
      physicalTableMaps:
        - physicalTableMapId: example-id
          s3Source:
            dataSourceArn: ${exampleAwsQuicksightDataSource.arn}
            inputColumns:
              - name: Column1
                type: STRING
            uploadSettings:
              format: JSON
Content copied to clipboard

With Column Level Permission Rules

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.quicksight.DataSet("example", {
    dataSetId: "example-id",
    name: "example-name",
    importMode: "SPICE",
    physicalTableMaps: [{
        physicalTableMapId: "example-id",
        s3Source: {
            dataSourceArn: exampleAwsQuicksightDataSource.arn,
            inputColumns: [{
                name: "Column1",
                type: "STRING",
            }],
            uploadSettings: {
                format: "JSON",
            },
        },
    }],
    columnLevelPermissionRules: [{
        columnNames: ["Column1"],
        principals: [exampleAwsQuicksightUser.arn],
    }],
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
example = aws.quicksight.DataSet("example",
    data_set_id="example-id",
    name="example-name",
    import_mode="SPICE",
    physical_table_maps=[aws.quicksight.DataSetPhysicalTableMapArgs(
        physical_table_map_id="example-id",
        s3_source=aws.quicksight.DataSetPhysicalTableMapS3SourceArgs(
            data_source_arn=example_aws_quicksight_data_source["arn"],
            input_columns=[aws.quicksight.DataSetPhysicalTableMapS3SourceInputColumnArgs(
                name="Column1",
                type="STRING",
            )],
            upload_settings=aws.quicksight.DataSetPhysicalTableMapS3SourceUploadSettingsArgs(
                format="JSON",
            ),
        ),
    )],
    column_level_permission_rules=[aws.quicksight.DataSetColumnLevelPermissionRuleArgs(
        column_names=["Column1"],
        principals=[example_aws_quicksight_user["arn"]],
    )])
Content copied to clipboard
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()
    {
        DataSetId = "example-id",
        Name = "example-name",
        ImportMode = "SPICE",
        PhysicalTableMaps = new[]
        {
            new Aws.Quicksight.Inputs.DataSetPhysicalTableMapArgs
            {
                PhysicalTableMapId = "example-id",
                S3Source = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceArgs
                {
                    DataSourceArn = exampleAwsQuicksightDataSource.Arn,
                    InputColumns = new[]
                    {
                        new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceInputColumnArgs
                        {
                            Name = "Column1",
                            Type = "STRING",
                        },
                    },
                    UploadSettings = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceUploadSettingsArgs
                    {
                        Format = "JSON",
                    },
                },
            },
        },
        ColumnLevelPermissionRules = new[]
        {
            new Aws.Quicksight.Inputs.DataSetColumnLevelPermissionRuleArgs
            {
                ColumnNames = new[]
                {
                    "Column1",
                },
                Principals = new[]
                {
                    exampleAwsQuicksightUser.Arn,
                },
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/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{
			DataSetId:  pulumi.String("example-id"),
			Name:       pulumi.String("example-name"),
			ImportMode: pulumi.String("SPICE"),
			PhysicalTableMaps: quicksight.DataSetPhysicalTableMapArray{
				&quicksight.DataSetPhysicalTableMapArgs{
					PhysicalTableMapId: pulumi.String("example-id"),
					S3Source: &quicksight.DataSetPhysicalTableMapS3SourceArgs{
						DataSourceArn: pulumi.Any(exampleAwsQuicksightDataSource.Arn),
						InputColumns: quicksight.DataSetPhysicalTableMapS3SourceInputColumnArray{
							&quicksight.DataSetPhysicalTableMapS3SourceInputColumnArgs{
								Name: pulumi.String("Column1"),
								Type: pulumi.String("STRING"),
							},
						},
						UploadSettings: &quicksight.DataSetPhysicalTableMapS3SourceUploadSettingsArgs{
							Format: pulumi.String("JSON"),
						},
					},
				},
			},
			ColumnLevelPermissionRules: quicksight.DataSetColumnLevelPermissionRuleArray{
				&quicksight.DataSetColumnLevelPermissionRuleArgs{
					ColumnNames: pulumi.StringArray{
						pulumi.String("Column1"),
					},
					Principals: pulumi.StringArray{
						exampleAwsQuicksightUser.Arn,
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
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.DataSetColumnLevelPermissionRuleArgs;
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 example = new DataSet("example", DataSetArgs.builder()
            .dataSetId("example-id")
            .name("example-name")
            .importMode("SPICE")
            .physicalTableMaps(DataSetPhysicalTableMapArgs.builder()
                .physicalTableMapId("example-id")
                .s3Source(DataSetPhysicalTableMapS3SourceArgs.builder()
                    .dataSourceArn(exampleAwsQuicksightDataSource.arn())
                    .inputColumns(DataSetPhysicalTableMapS3SourceInputColumnArgs.builder()
                        .name("Column1")
                        .type("STRING")
                        .build())
                    .uploadSettings(DataSetPhysicalTableMapS3SourceUploadSettingsArgs.builder()
                        .format("JSON")
                        .build())
                    .build())
                .build())
            .columnLevelPermissionRules(DataSetColumnLevelPermissionRuleArgs.builder()
                .columnNames("Column1")
                .principals(exampleAwsQuicksightUser.arn())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: aws:quicksight:DataSet
    properties:
      dataSetId: example-id
      name: example-name
      importMode: SPICE
      physicalTableMaps:
        - physicalTableMapId: example-id
          s3Source:
            dataSourceArn: ${exampleAwsQuicksightDataSource.arn}
            inputColumns:
              - name: Column1
                type: STRING
            uploadSettings:
              format: JSON
      columnLevelPermissionRules:
        - columnNames:
            - Column1
          principals:
            - ${exampleAwsQuicksightUser.arn}
Content copied to clipboard

With Field Folders

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.quicksight.DataSet("example", {
    dataSetId: "example-id",
    name: "example-name",
    importMode: "SPICE",
    physicalTableMaps: [{
        physicalTableMapId: "example-id",
        s3Source: {
            dataSourceArn: exampleAwsQuicksightDataSource.arn,
            inputColumns: [{
                name: "Column1",
                type: "STRING",
            }],
            uploadSettings: {
                format: "JSON",
            },
        },
    }],
    fieldFolders: [{
        fieldFoldersId: "example-id",
        columns: ["Column1"],
        description: "example description",
    }],
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
example = aws.quicksight.DataSet("example",
    data_set_id="example-id",
    name="example-name",
    import_mode="SPICE",
    physical_table_maps=[aws.quicksight.DataSetPhysicalTableMapArgs(
        physical_table_map_id="example-id",
        s3_source=aws.quicksight.DataSetPhysicalTableMapS3SourceArgs(
            data_source_arn=example_aws_quicksight_data_source["arn"],
            input_columns=[aws.quicksight.DataSetPhysicalTableMapS3SourceInputColumnArgs(
                name="Column1",
                type="STRING",
            )],
            upload_settings=aws.quicksight.DataSetPhysicalTableMapS3SourceUploadSettingsArgs(
                format="JSON",
            ),
        ),
    )],
    field_folders=[aws.quicksight.DataSetFieldFolderArgs(
        field_folders_id="example-id",
        columns=["Column1"],
        description="example description",
    )])
Content copied to clipboard
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()
    {
        DataSetId = "example-id",
        Name = "example-name",
        ImportMode = "SPICE",
        PhysicalTableMaps = new[]
        {
            new Aws.Quicksight.Inputs.DataSetPhysicalTableMapArgs
            {
                PhysicalTableMapId = "example-id",
                S3Source = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceArgs
                {
                    DataSourceArn = exampleAwsQuicksightDataSource.Arn,
                    InputColumns = new[]
                    {
                        new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceInputColumnArgs
                        {
                            Name = "Column1",
                            Type = "STRING",
                        },
                    },
                    UploadSettings = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceUploadSettingsArgs
                    {
                        Format = "JSON",
                    },
                },
            },
        },
        FieldFolders = new[]
        {
            new Aws.Quicksight.Inputs.DataSetFieldFolderArgs
            {
                FieldFoldersId = "example-id",
                Columns = new[]
                {
                    "Column1",
                },
                Description = "example description",
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/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{
			DataSetId:  pulumi.String("example-id"),
			Name:       pulumi.String("example-name"),
			ImportMode: pulumi.String("SPICE"),
			PhysicalTableMaps: quicksight.DataSetPhysicalTableMapArray{
				&quicksight.DataSetPhysicalTableMapArgs{
					PhysicalTableMapId: pulumi.String("example-id"),
					S3Source: &quicksight.DataSetPhysicalTableMapS3SourceArgs{
						DataSourceArn: pulumi.Any(exampleAwsQuicksightDataSource.Arn),
						InputColumns: quicksight.DataSetPhysicalTableMapS3SourceInputColumnArray{
							&quicksight.DataSetPhysicalTableMapS3SourceInputColumnArgs{
								Name: pulumi.String("Column1"),
								Type: pulumi.String("STRING"),
							},
						},
						UploadSettings: &quicksight.DataSetPhysicalTableMapS3SourceUploadSettingsArgs{
							Format: pulumi.String("JSON"),
						},
					},
				},
			},
			FieldFolders: quicksight.DataSetFieldFolderArray{
				&quicksight.DataSetFieldFolderArgs{
					FieldFoldersId: pulumi.String("example-id"),
					Columns: pulumi.StringArray{
						pulumi.String("Column1"),
					},
					Description: pulumi.String("example description"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
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.DataSetFieldFolderArgs;
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 example = new DataSet("example", DataSetArgs.builder()
            .dataSetId("example-id")
            .name("example-name")
            .importMode("SPICE")
            .physicalTableMaps(DataSetPhysicalTableMapArgs.builder()
                .physicalTableMapId("example-id")
                .s3Source(DataSetPhysicalTableMapS3SourceArgs.builder()
                    .dataSourceArn(exampleAwsQuicksightDataSource.arn())
                    .inputColumns(DataSetPhysicalTableMapS3SourceInputColumnArgs.builder()
                        .name("Column1")
                        .type("STRING")
                        .build())
                    .uploadSettings(DataSetPhysicalTableMapS3SourceUploadSettingsArgs.builder()
                        .format("JSON")
                        .build())
                    .build())
                .build())
            .fieldFolders(DataSetFieldFolderArgs.builder()
                .fieldFoldersId("example-id")
                .columns("Column1")
                .description("example description")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: aws:quicksight:DataSet
    properties:
      dataSetId: example-id
      name: example-name
      importMode: SPICE
      physicalTableMaps:
        - physicalTableMapId: example-id
          s3Source:
            dataSourceArn: ${exampleAwsQuicksightDataSource.arn}
            inputColumns:
              - name: Column1
                type: STRING
            uploadSettings:
              format: JSON
      fieldFolders:
        - fieldFoldersId: example-id
          columns:
            - Column1
          description: example description
Content copied to clipboard

With Permissions

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.quicksight.DataSet("example", {
    dataSetId: "example-id",
    name: "example-name",
    importMode: "SPICE",
    physicalTableMaps: [{
        physicalTableMapId: "example-id",
        s3Source: {
            dataSourceArn: exampleAwsQuicksightDataSource.arn,
            inputColumns: [{
                name: "Column1",
                type: "STRING",
            }],
            uploadSettings: {
                format: "JSON",
            },
        },
    }],
    permissions: [{
        actions: [
            "quicksight:DescribeDataSet",
            "quicksight:DescribeDataSetPermissions",
            "quicksight:PassDataSet",
            "quicksight:DescribeIngestion",
            "quicksight:ListIngestions",
        ],
        principal: exampleAwsQuicksightUser.arn,
    }],
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
example = aws.quicksight.DataSet("example",
    data_set_id="example-id",
    name="example-name",
    import_mode="SPICE",
    physical_table_maps=[aws.quicksight.DataSetPhysicalTableMapArgs(
        physical_table_map_id="example-id",
        s3_source=aws.quicksight.DataSetPhysicalTableMapS3SourceArgs(
            data_source_arn=example_aws_quicksight_data_source["arn"],
            input_columns=[aws.quicksight.DataSetPhysicalTableMapS3SourceInputColumnArgs(
                name="Column1",
                type="STRING",
            )],
            upload_settings=aws.quicksight.DataSetPhysicalTableMapS3SourceUploadSettingsArgs(
                format="JSON",
            ),
        ),
    )],
    permissions=[aws.quicksight.DataSetPermissionArgs(
        actions=[
            "quicksight:DescribeDataSet",
            "quicksight:DescribeDataSetPermissions",
            "quicksight:PassDataSet",
            "quicksight:DescribeIngestion",
            "quicksight:ListIngestions",
        ],
        principal=example_aws_quicksight_user["arn"],
    )])
Content copied to clipboard
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()
    {
        DataSetId = "example-id",
        Name = "example-name",
        ImportMode = "SPICE",
        PhysicalTableMaps = new[]
        {
            new Aws.Quicksight.Inputs.DataSetPhysicalTableMapArgs
            {
                PhysicalTableMapId = "example-id",
                S3Source = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceArgs
                {
                    DataSourceArn = exampleAwsQuicksightDataSource.Arn,
                    InputColumns = new[]
                    {
                        new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceInputColumnArgs
                        {
                            Name = "Column1",
                            Type = "STRING",
                        },
                    },
                    UploadSettings = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceUploadSettingsArgs
                    {
                        Format = "JSON",
                    },
                },
            },
        },
        Permissions = new[]
        {
            new Aws.Quicksight.Inputs.DataSetPermissionArgs
            {
                Actions = new[]
                {
                    "quicksight:DescribeDataSet",
                    "quicksight:DescribeDataSetPermissions",
                    "quicksight:PassDataSet",
                    "quicksight:DescribeIngestion",
                    "quicksight:ListIngestions",
                },
                Principal = exampleAwsQuicksightUser.Arn,
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/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{
			DataSetId:  pulumi.String("example-id"),
			Name:       pulumi.String("example-name"),
			ImportMode: pulumi.String("SPICE"),
			PhysicalTableMaps: quicksight.DataSetPhysicalTableMapArray{
				&quicksight.DataSetPhysicalTableMapArgs{
					PhysicalTableMapId: pulumi.String("example-id"),
					S3Source: &quicksight.DataSetPhysicalTableMapS3SourceArgs{
						DataSourceArn: pulumi.Any(exampleAwsQuicksightDataSource.Arn),
						InputColumns: quicksight.DataSetPhysicalTableMapS3SourceInputColumnArray{
							&quicksight.DataSetPhysicalTableMapS3SourceInputColumnArgs{
								Name: pulumi.String("Column1"),
								Type: pulumi.String("STRING"),
							},
						},
						UploadSettings: &quicksight.DataSetPhysicalTableMapS3SourceUploadSettingsArgs{
							Format: pulumi.String("JSON"),
						},
					},
				},
			},
			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),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
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.DataSetPermissionArgs;
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 example = new DataSet("example", DataSetArgs.builder()
            .dataSetId("example-id")
            .name("example-name")
            .importMode("SPICE")
            .physicalTableMaps(DataSetPhysicalTableMapArgs.builder()
                .physicalTableMapId("example-id")
                .s3Source(DataSetPhysicalTableMapS3SourceArgs.builder()
                    .dataSourceArn(exampleAwsQuicksightDataSource.arn())
                    .inputColumns(DataSetPhysicalTableMapS3SourceInputColumnArgs.builder()
                        .name("Column1")
                        .type("STRING")
                        .build())
                    .uploadSettings(DataSetPhysicalTableMapS3SourceUploadSettingsArgs.builder()
                        .format("JSON")
                        .build())
                    .build())
                .build())
            .permissions(DataSetPermissionArgs.builder()
                .actions(
                    "quicksight:DescribeDataSet",
                    "quicksight:DescribeDataSetPermissions",
                    "quicksight:PassDataSet",
                    "quicksight:DescribeIngestion",
                    "quicksight:ListIngestions")
                .principal(exampleAwsQuicksightUser.arn())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: aws:quicksight:DataSet
    properties:
      dataSetId: example-id
      name: example-name
      importMode: SPICE
      physicalTableMaps:
        - physicalTableMapId: example-id
          s3Source:
            dataSourceArn: ${exampleAwsQuicksightDataSource.arn}
            inputColumns:
              - name: Column1
                type: STRING
            uploadSettings:
              format: JSON
      permissions:
        - actions:
            - quicksight:DescribeDataSet
            - quicksight:DescribeDataSetPermissions
            - quicksight:PassDataSet
            - quicksight:DescribeIngestion
            - quicksight:ListIngestions
          principal: ${exampleAwsQuicksightUser.arn}
Content copied to clipboard

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", {
    dataSetId: "example-id",
    name: "example-name",
    importMode: "SPICE",
    physicalTableMaps: [{
        physicalTableMapId: "example-id",
        s3Source: {
            dataSourceArn: exampleAwsQuicksightDataSource.arn,
            inputColumns: [{
                name: "Column1",
                type: "STRING",
            }],
            uploadSettings: {
                format: "JSON",
            },
        },
    }],
    rowLevelPermissionTagConfiguration: {
        status: "ENABLED",
        tagRules: [{
            columnName: "Column1",
            tagKey: "tagkey",
            matchAllValue: "*",
            tagMultiValueDelimiter: ",",
        }],
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
example = aws.quicksight.DataSet("example",
    data_set_id="example-id",
    name="example-name",
    import_mode="SPICE",
    physical_table_maps=[aws.quicksight.DataSetPhysicalTableMapArgs(
        physical_table_map_id="example-id",
        s3_source=aws.quicksight.DataSetPhysicalTableMapS3SourceArgs(
            data_source_arn=example_aws_quicksight_data_source["arn"],
            input_columns=[aws.quicksight.DataSetPhysicalTableMapS3SourceInputColumnArgs(
                name="Column1",
                type="STRING",
            )],
            upload_settings=aws.quicksight.DataSetPhysicalTableMapS3SourceUploadSettingsArgs(
                format="JSON",
            ),
        ),
    )],
    row_level_permission_tag_configuration=aws.quicksight.DataSetRowLevelPermissionTagConfigurationArgs(
        status="ENABLED",
        tag_rules=[aws.quicksight.DataSetRowLevelPermissionTagConfigurationTagRuleArgs(
            column_name="Column1",
            tag_key="tagkey",
            match_all_value="*",
            tag_multi_value_delimiter=",",
        )],
    ))
Content copied to clipboard
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()
    {
        DataSetId = "example-id",
        Name = "example-name",
        ImportMode = "SPICE",
        PhysicalTableMaps = new[]
        {
            new Aws.Quicksight.Inputs.DataSetPhysicalTableMapArgs
            {
                PhysicalTableMapId = "example-id",
                S3Source = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceArgs
                {
                    DataSourceArn = exampleAwsQuicksightDataSource.Arn,
                    InputColumns = new[]
                    {
                        new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceInputColumnArgs
                        {
                            Name = "Column1",
                            Type = "STRING",
                        },
                    },
                    UploadSettings = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceUploadSettingsArgs
                    {
                        Format = "JSON",
                    },
                },
            },
        },
        RowLevelPermissionTagConfiguration = new Aws.Quicksight.Inputs.DataSetRowLevelPermissionTagConfigurationArgs
        {
            Status = "ENABLED",
            TagRules = new[]
            {
                new Aws.Quicksight.Inputs.DataSetRowLevelPermissionTagConfigurationTagRuleArgs
                {
                    ColumnName = "Column1",
                    TagKey = "tagkey",
                    MatchAllValue = "*",
                    TagMultiValueDelimiter = ",",
                },
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/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{
			DataSetId:  pulumi.String("example-id"),
			Name:       pulumi.String("example-name"),
			ImportMode: pulumi.String("SPICE"),
			PhysicalTableMaps: quicksight.DataSetPhysicalTableMapArray{
				&quicksight.DataSetPhysicalTableMapArgs{
					PhysicalTableMapId: pulumi.String("example-id"),
					S3Source: &quicksight.DataSetPhysicalTableMapS3SourceArgs{
						DataSourceArn: pulumi.Any(exampleAwsQuicksightDataSource.Arn),
						InputColumns: quicksight.DataSetPhysicalTableMapS3SourceInputColumnArray{
							&quicksight.DataSetPhysicalTableMapS3SourceInputColumnArgs{
								Name: pulumi.String("Column1"),
								Type: pulumi.String("STRING"),
							},
						},
						UploadSettings: &quicksight.DataSetPhysicalTableMapS3SourceUploadSettingsArgs{
							Format: pulumi.String("JSON"),
						},
					},
				},
			},
			RowLevelPermissionTagConfiguration: &quicksight.DataSetRowLevelPermissionTagConfigurationArgs{
				Status: pulumi.String("ENABLED"),
				TagRules: quicksight.DataSetRowLevelPermissionTagConfigurationTagRuleArray{
					&quicksight.DataSetRowLevelPermissionTagConfigurationTagRuleArgs{
						ColumnName:             pulumi.String("Column1"),
						TagKey:                 pulumi.String("tagkey"),
						MatchAllValue:          pulumi.String("*"),
						TagMultiValueDelimiter: pulumi.String(","),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
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.DataSetRowLevelPermissionTagConfigurationArgs;
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 example = new DataSet("example", DataSetArgs.builder()
            .dataSetId("example-id")
            .name("example-name")
            .importMode("SPICE")
            .physicalTableMaps(DataSetPhysicalTableMapArgs.builder()
                .physicalTableMapId("example-id")
                .s3Source(DataSetPhysicalTableMapS3SourceArgs.builder()
                    .dataSourceArn(exampleAwsQuicksightDataSource.arn())
                    .inputColumns(DataSetPhysicalTableMapS3SourceInputColumnArgs.builder()
                        .name("Column1")
                        .type("STRING")
                        .build())
                    .uploadSettings(DataSetPhysicalTableMapS3SourceUploadSettingsArgs.builder()
                        .format("JSON")
                        .build())
                    .build())
                .build())
            .rowLevelPermissionTagConfiguration(DataSetRowLevelPermissionTagConfigurationArgs.builder()
                .status("ENABLED")
                .tagRules(DataSetRowLevelPermissionTagConfigurationTagRuleArgs.builder()
                    .columnName("Column1")
                    .tagKey("tagkey")
                    .matchAllValue("*")
                    .tagMultiValueDelimiter(",")
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: aws:quicksight:DataSet
    properties:
      dataSetId: example-id
      name: example-name
      importMode: SPICE
      physicalTableMaps:
        - physicalTableMapId: example-id
          s3Source:
            dataSourceArn: ${exampleAwsQuicksightDataSource.arn}
            inputColumns:
              - name: Column1
                type: STRING
            uploadSettings:
              format: JSON
      rowLevelPermissionTagConfiguration:
        status: ENABLED
        tagRules:
          - columnName: Column1
            tagKey: tagkey
            matchAllValue: '*'
            tagMultiValueDelimiter: ','
Content copied to clipboard

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
Content copied to clipboard

Properties

Link copied to clipboard
val arn: Output<String>

Amazon Resource Name (ARN) of the data set.

Link copied to clipboard
val awsAccountId: Output<String>

AWS account ID.

Link copied to clipboard
val columnGroups: Output<List<DataSetColumnGroup>>?

Groupings of columns that work together in certain Amazon QuickSight features. Currently, only geospatial hierarchy is supported. See column_groups.

Link copied to clipboard
val columnLevelPermissionRules: Output<List<DataSetColumnLevelPermissionRule>>?

A set of 1 or more definitions of a ColumnLevelPermissionRule. See column_level_permission_rules.

Link copied to clipboard
val dataSetId: Output<String>

Identifier for the data set.

Link copied to clipboard
val dataSetUsageConfiguration: Output<DataSetDataSetUsageConfiguration>

The usage configuration to apply to child datasets that reference this dataset as a source. See data_set_usage_configuration.

Link copied to clipboard
val fieldFolders: Output<List<DataSetFieldFolder>>?

The folder that contains fields and nested subfolders for your dataset. See field_folders.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val importMode: Output<String>

Indicates whether you want to import the data into SPICE. Valid values are SPICE and DIRECT_QUERY.

Link copied to clipboard
val logicalTableMaps: Output<List<DataSetLogicalTableMap>>

Configures the combination and transformation of the data from the physical tables. Maximum of 1 entry. See logical_table_map.

Link copied to clipboard
val name: Output<String>

Display name for the dataset.

Link copied to clipboard
Link copied to clipboard
val permissions: Output<List<DataSetPermission>>?

A set of resource permissions on the data source. Maximum of 64 items. See permissions.

Link copied to clipboard
val physicalTableMaps: Output<List<DataSetPhysicalTableMap>>?

Declares the physical tables that are available in the underlying data sources. See physical_table_map. The following arguments are optional:

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val refreshProperties: Output<DataSetRefreshProperties>?

The refresh properties for the data set. NOTE: Only valid when import_mode is set to SPICE. See refresh_properties.

Link copied to clipboard
val rowLevelPermissionDataSet: Output<DataSetRowLevelPermissionDataSet>?

The row-level security configuration for the data that you want to create. See row_level_permission_data_set.

Link copied to clipboard
val 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.

Link copied to clipboard
val tags: Output<Map<String, String>>?

Key-value map of resource tags. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

Link copied to clipboard
val tagsAll: Output<Map<String, String>>

A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

Link copied to clipboard
val urn: Output<String>