1. Packages
  2. AWS Classic
  3. API Docs
  4. quicksight
  5. DataSet

Try AWS Native preview for resources not in the classic version.

AWS Classic v6.41.0 published on Tuesday, Jun 18, 2024 by Pulumi

aws.quicksight.DataSet

Explore with Pulumi AI

aws logo

Try AWS Native preview for resources not in the classic version.

AWS Classic v6.41.0 published on Tuesday, Jun 18, 2024 by Pulumi

    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",
                },
            },
        }],
    });
    
    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",
                ),
            ),
        )])
    
    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
    	})
    }
    
    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",
                        },
                    },
                },
            },
        });
    
    });
    
    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());
    
        }
    }
    
    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
    

    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],
        }],
    });
    
    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"]],
        )])
    
    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
    	})
    }
    
    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,
                    },
                },
            },
        });
    
    });
    
    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());
    
        }
    }
    
    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}
    

    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",
        }],
    });
    
    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",
        )])
    
    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
    	})
    }
    
    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",
                },
            },
        });
    
    });
    
    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());
    
        }
    }
    
    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
    

    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,
        }],
    });
    
    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"],
        )])
    
    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
    	})
    }
    
    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,
                },
            },
        });
    
    });
    
    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());
    
        }
    }
    
    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}
    

    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: ",",
            }],
        },
    });
    
    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=",",
            )],
        ))
    
    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
    	})
    }
    
    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 = ",",
                    },
                },
            },
        });
    
    });
    
    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());
    
        }
    }
    
    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: ','
    

    Create DataSet Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new DataSet(name: string, args: DataSetArgs, opts?: CustomResourceOptions);
    @overload
    def DataSet(resource_name: str,
                args: DataSetArgs,
                opts: Optional[ResourceOptions] = None)
    
    @overload
    def DataSet(resource_name: str,
                opts: Optional[ResourceOptions] = None,
                import_mode: Optional[str] = None,
                data_set_id: Optional[str] = None,
                name: Optional[str] = None,
                column_level_permission_rules: Optional[Sequence[DataSetColumnLevelPermissionRuleArgs]] = None,
                data_set_usage_configuration: Optional[DataSetDataSetUsageConfigurationArgs] = None,
                field_folders: Optional[Sequence[DataSetFieldFolderArgs]] = None,
                column_groups: Optional[Sequence[DataSetColumnGroupArgs]] = None,
                logical_table_maps: Optional[Sequence[DataSetLogicalTableMapArgs]] = None,
                aws_account_id: Optional[str] = None,
                permissions: Optional[Sequence[DataSetPermissionArgs]] = None,
                physical_table_maps: Optional[Sequence[DataSetPhysicalTableMapArgs]] = None,
                refresh_properties: Optional[DataSetRefreshPropertiesArgs] = None,
                row_level_permission_data_set: Optional[DataSetRowLevelPermissionDataSetArgs] = None,
                row_level_permission_tag_configuration: Optional[DataSetRowLevelPermissionTagConfigurationArgs] = None,
                tags: Optional[Mapping[str, str]] = None)
    func NewDataSet(ctx *Context, name string, args DataSetArgs, opts ...ResourceOption) (*DataSet, error)
    public DataSet(string name, DataSetArgs args, CustomResourceOptions? opts = null)
    public DataSet(String name, DataSetArgs args)
    public DataSet(String name, DataSetArgs args, CustomResourceOptions options)
    
    type: aws:quicksight:DataSet
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    

    Parameters

    name string
    The unique name of the resource.
    args DataSetArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args DataSetArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args DataSetArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args DataSetArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args DataSetArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Example

    The following reference example uses placeholder values for all input properties.

    var awsDataSetResource = new Aws.Quicksight.DataSet("awsDataSetResource", new()
    {
        ImportMode = "string",
        DataSetId = "string",
        Name = "string",
        ColumnLevelPermissionRules = new[]
        {
            new Aws.Quicksight.Inputs.DataSetColumnLevelPermissionRuleArgs
            {
                ColumnNames = new[]
                {
                    "string",
                },
                Principals = new[]
                {
                    "string",
                },
            },
        },
        DataSetUsageConfiguration = new Aws.Quicksight.Inputs.DataSetDataSetUsageConfigurationArgs
        {
            DisableUseAsDirectQuerySource = false,
            DisableUseAsImportedSource = false,
        },
        FieldFolders = new[]
        {
            new Aws.Quicksight.Inputs.DataSetFieldFolderArgs
            {
                FieldFoldersId = "string",
                Columns = new[]
                {
                    "string",
                },
                Description = "string",
            },
        },
        ColumnGroups = new[]
        {
            new Aws.Quicksight.Inputs.DataSetColumnGroupArgs
            {
                GeoSpatialColumnGroup = new Aws.Quicksight.Inputs.DataSetColumnGroupGeoSpatialColumnGroupArgs
                {
                    Columns = new[]
                    {
                        "string",
                    },
                    CountryCode = "string",
                    Name = "string",
                },
            },
        },
        LogicalTableMaps = new[]
        {
            new Aws.Quicksight.Inputs.DataSetLogicalTableMapArgs
            {
                Alias = "string",
                LogicalTableMapId = "string",
                Source = new Aws.Quicksight.Inputs.DataSetLogicalTableMapSourceArgs
                {
                    DataSetArn = "string",
                    JoinInstruction = new Aws.Quicksight.Inputs.DataSetLogicalTableMapSourceJoinInstructionArgs
                    {
                        LeftOperand = "string",
                        OnClause = "string",
                        RightOperand = "string",
                        Type = "string",
                        LeftJoinKeyProperties = new Aws.Quicksight.Inputs.DataSetLogicalTableMapSourceJoinInstructionLeftJoinKeyPropertiesArgs
                        {
                            UniqueKey = false,
                        },
                        RightJoinKeyProperties = new Aws.Quicksight.Inputs.DataSetLogicalTableMapSourceJoinInstructionRightJoinKeyPropertiesArgs
                        {
                            UniqueKey = false,
                        },
                    },
                    PhysicalTableId = "string",
                },
                DataTransforms = new[]
                {
                    new Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformArgs
                    {
                        CastColumnTypeOperation = new Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformCastColumnTypeOperationArgs
                        {
                            ColumnName = "string",
                            NewColumnType = "string",
                            Format = "string",
                        },
                        CreateColumnsOperation = new Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformCreateColumnsOperationArgs
                        {
                            Columns = new[]
                            {
                                new Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformCreateColumnsOperationColumnArgs
                                {
                                    ColumnId = "string",
                                    ColumnName = "string",
                                    Expression = "string",
                                },
                            },
                        },
                        FilterOperation = new Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformFilterOperationArgs
                        {
                            ConditionExpression = "string",
                        },
                        ProjectOperation = new Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformProjectOperationArgs
                        {
                            ProjectedColumns = new[]
                            {
                                "string",
                            },
                        },
                        RenameColumnOperation = new Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformRenameColumnOperationArgs
                        {
                            ColumnName = "string",
                            NewColumnName = "string",
                        },
                        TagColumnOperation = new Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformTagColumnOperationArgs
                        {
                            ColumnName = "string",
                            Tags = new[]
                            {
                                new Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformTagColumnOperationTagArgs
                                {
                                    ColumnDescription = new Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformTagColumnOperationTagColumnDescriptionArgs
                                    {
                                        Text = "string",
                                    },
                                    ColumnGeographicRole = "string",
                                },
                            },
                        },
                        UntagColumnOperation = new Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformUntagColumnOperationArgs
                        {
                            ColumnName = "string",
                            TagNames = new[]
                            {
                                "string",
                            },
                        },
                    },
                },
            },
        },
        AwsAccountId = "string",
        Permissions = new[]
        {
            new Aws.Quicksight.Inputs.DataSetPermissionArgs
            {
                Actions = new[]
                {
                    "string",
                },
                Principal = "string",
            },
        },
        PhysicalTableMaps = new[]
        {
            new Aws.Quicksight.Inputs.DataSetPhysicalTableMapArgs
            {
                PhysicalTableMapId = "string",
                CustomSql = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapCustomSqlArgs
                {
                    DataSourceArn = "string",
                    Name = "string",
                    SqlQuery = "string",
                    Columns = new[]
                    {
                        new Aws.Quicksight.Inputs.DataSetPhysicalTableMapCustomSqlColumnArgs
                        {
                            Name = "string",
                            Type = "string",
                        },
                    },
                },
                RelationalTable = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapRelationalTableArgs
                {
                    DataSourceArn = "string",
                    InputColumns = new[]
                    {
                        new Aws.Quicksight.Inputs.DataSetPhysicalTableMapRelationalTableInputColumnArgs
                        {
                            Name = "string",
                            Type = "string",
                        },
                    },
                    Name = "string",
                    Catalog = "string",
                    Schema = "string",
                },
                S3Source = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceArgs
                {
                    DataSourceArn = "string",
                    InputColumns = new[]
                    {
                        new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceInputColumnArgs
                        {
                            Name = "string",
                            Type = "string",
                        },
                    },
                    UploadSettings = new Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceUploadSettingsArgs
                    {
                        ContainsHeader = false,
                        Delimiter = "string",
                        Format = "string",
                        StartFromRow = 0,
                        TextQualifier = "string",
                    },
                },
            },
        },
        RefreshProperties = new Aws.Quicksight.Inputs.DataSetRefreshPropertiesArgs
        {
            RefreshConfiguration = new Aws.Quicksight.Inputs.DataSetRefreshPropertiesRefreshConfigurationArgs
            {
                IncrementalRefresh = new Aws.Quicksight.Inputs.DataSetRefreshPropertiesRefreshConfigurationIncrementalRefreshArgs
                {
                    LookbackWindow = new Aws.Quicksight.Inputs.DataSetRefreshPropertiesRefreshConfigurationIncrementalRefreshLookbackWindowArgs
                    {
                        ColumnName = "string",
                        Size = 0,
                        SizeUnit = "string",
                    },
                },
            },
        },
        RowLevelPermissionDataSet = new Aws.Quicksight.Inputs.DataSetRowLevelPermissionDataSetArgs
        {
            Arn = "string",
            PermissionPolicy = "string",
            FormatVersion = "string",
            Namespace = "string",
            Status = "string",
        },
        RowLevelPermissionTagConfiguration = new Aws.Quicksight.Inputs.DataSetRowLevelPermissionTagConfigurationArgs
        {
            TagRules = new[]
            {
                new Aws.Quicksight.Inputs.DataSetRowLevelPermissionTagConfigurationTagRuleArgs
                {
                    ColumnName = "string",
                    TagKey = "string",
                    MatchAllValue = "string",
                    TagMultiValueDelimiter = "string",
                },
            },
            Status = "string",
        },
        Tags = 
        {
            { "string", "string" },
        },
    });
    
    example, err := quicksight.NewDataSet(ctx, "awsDataSetResource", &quicksight.DataSetArgs{
    	ImportMode: pulumi.String("string"),
    	DataSetId:  pulumi.String("string"),
    	Name:       pulumi.String("string"),
    	ColumnLevelPermissionRules: quicksight.DataSetColumnLevelPermissionRuleArray{
    		&quicksight.DataSetColumnLevelPermissionRuleArgs{
    			ColumnNames: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			Principals: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    		},
    	},
    	DataSetUsageConfiguration: &quicksight.DataSetDataSetUsageConfigurationArgs{
    		DisableUseAsDirectQuerySource: pulumi.Bool(false),
    		DisableUseAsImportedSource:    pulumi.Bool(false),
    	},
    	FieldFolders: quicksight.DataSetFieldFolderArray{
    		&quicksight.DataSetFieldFolderArgs{
    			FieldFoldersId: pulumi.String("string"),
    			Columns: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			Description: pulumi.String("string"),
    		},
    	},
    	ColumnGroups: quicksight.DataSetColumnGroupArray{
    		&quicksight.DataSetColumnGroupArgs{
    			GeoSpatialColumnGroup: &quicksight.DataSetColumnGroupGeoSpatialColumnGroupArgs{
    				Columns: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				CountryCode: pulumi.String("string"),
    				Name:        pulumi.String("string"),
    			},
    		},
    	},
    	LogicalTableMaps: quicksight.DataSetLogicalTableMapArray{
    		&quicksight.DataSetLogicalTableMapArgs{
    			Alias:             pulumi.String("string"),
    			LogicalTableMapId: pulumi.String("string"),
    			Source: &quicksight.DataSetLogicalTableMapSourceArgs{
    				DataSetArn: pulumi.String("string"),
    				JoinInstruction: &quicksight.DataSetLogicalTableMapSourceJoinInstructionArgs{
    					LeftOperand:  pulumi.String("string"),
    					OnClause:     pulumi.String("string"),
    					RightOperand: pulumi.String("string"),
    					Type:         pulumi.String("string"),
    					LeftJoinKeyProperties: &quicksight.DataSetLogicalTableMapSourceJoinInstructionLeftJoinKeyPropertiesArgs{
    						UniqueKey: pulumi.Bool(false),
    					},
    					RightJoinKeyProperties: &quicksight.DataSetLogicalTableMapSourceJoinInstructionRightJoinKeyPropertiesArgs{
    						UniqueKey: pulumi.Bool(false),
    					},
    				},
    				PhysicalTableId: pulumi.String("string"),
    			},
    			DataTransforms: quicksight.DataSetLogicalTableMapDataTransformArray{
    				&quicksight.DataSetLogicalTableMapDataTransformArgs{
    					CastColumnTypeOperation: &quicksight.DataSetLogicalTableMapDataTransformCastColumnTypeOperationArgs{
    						ColumnName:    pulumi.String("string"),
    						NewColumnType: pulumi.String("string"),
    						Format:        pulumi.String("string"),
    					},
    					CreateColumnsOperation: &quicksight.DataSetLogicalTableMapDataTransformCreateColumnsOperationArgs{
    						Columns: quicksight.DataSetLogicalTableMapDataTransformCreateColumnsOperationColumnArray{
    							&quicksight.DataSetLogicalTableMapDataTransformCreateColumnsOperationColumnArgs{
    								ColumnId:   pulumi.String("string"),
    								ColumnName: pulumi.String("string"),
    								Expression: pulumi.String("string"),
    							},
    						},
    					},
    					FilterOperation: &quicksight.DataSetLogicalTableMapDataTransformFilterOperationArgs{
    						ConditionExpression: pulumi.String("string"),
    					},
    					ProjectOperation: &quicksight.DataSetLogicalTableMapDataTransformProjectOperationArgs{
    						ProjectedColumns: pulumi.StringArray{
    							pulumi.String("string"),
    						},
    					},
    					RenameColumnOperation: &quicksight.DataSetLogicalTableMapDataTransformRenameColumnOperationArgs{
    						ColumnName:    pulumi.String("string"),
    						NewColumnName: pulumi.String("string"),
    					},
    					TagColumnOperation: &quicksight.DataSetLogicalTableMapDataTransformTagColumnOperationArgs{
    						ColumnName: pulumi.String("string"),
    						Tags: quicksight.DataSetLogicalTableMapDataTransformTagColumnOperationTagArray{
    							&quicksight.DataSetLogicalTableMapDataTransformTagColumnOperationTagArgs{
    								ColumnDescription: &quicksight.DataSetLogicalTableMapDataTransformTagColumnOperationTagColumnDescriptionArgs{
    									Text: pulumi.String("string"),
    								},
    								ColumnGeographicRole: pulumi.String("string"),
    							},
    						},
    					},
    					UntagColumnOperation: &quicksight.DataSetLogicalTableMapDataTransformUntagColumnOperationArgs{
    						ColumnName: pulumi.String("string"),
    						TagNames: pulumi.StringArray{
    							pulumi.String("string"),
    						},
    					},
    				},
    			},
    		},
    	},
    	AwsAccountId: pulumi.String("string"),
    	Permissions: quicksight.DataSetPermissionArray{
    		&quicksight.DataSetPermissionArgs{
    			Actions: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			Principal: pulumi.String("string"),
    		},
    	},
    	PhysicalTableMaps: quicksight.DataSetPhysicalTableMapArray{
    		&quicksight.DataSetPhysicalTableMapArgs{
    			PhysicalTableMapId: pulumi.String("string"),
    			CustomSql: &quicksight.DataSetPhysicalTableMapCustomSqlArgs{
    				DataSourceArn: pulumi.String("string"),
    				Name:          pulumi.String("string"),
    				SqlQuery:      pulumi.String("string"),
    				Columns: quicksight.DataSetPhysicalTableMapCustomSqlColumnArray{
    					&quicksight.DataSetPhysicalTableMapCustomSqlColumnArgs{
    						Name: pulumi.String("string"),
    						Type: pulumi.String("string"),
    					},
    				},
    			},
    			RelationalTable: &quicksight.DataSetPhysicalTableMapRelationalTableArgs{
    				DataSourceArn: pulumi.String("string"),
    				InputColumns: quicksight.DataSetPhysicalTableMapRelationalTableInputColumnArray{
    					&quicksight.DataSetPhysicalTableMapRelationalTableInputColumnArgs{
    						Name: pulumi.String("string"),
    						Type: pulumi.String("string"),
    					},
    				},
    				Name:    pulumi.String("string"),
    				Catalog: pulumi.String("string"),
    				Schema:  pulumi.String("string"),
    			},
    			S3Source: &quicksight.DataSetPhysicalTableMapS3SourceArgs{
    				DataSourceArn: pulumi.String("string"),
    				InputColumns: quicksight.DataSetPhysicalTableMapS3SourceInputColumnArray{
    					&quicksight.DataSetPhysicalTableMapS3SourceInputColumnArgs{
    						Name: pulumi.String("string"),
    						Type: pulumi.String("string"),
    					},
    				},
    				UploadSettings: &quicksight.DataSetPhysicalTableMapS3SourceUploadSettingsArgs{
    					ContainsHeader: pulumi.Bool(false),
    					Delimiter:      pulumi.String("string"),
    					Format:         pulumi.String("string"),
    					StartFromRow:   pulumi.Int(0),
    					TextQualifier:  pulumi.String("string"),
    				},
    			},
    		},
    	},
    	RefreshProperties: &quicksight.DataSetRefreshPropertiesArgs{
    		RefreshConfiguration: &quicksight.DataSetRefreshPropertiesRefreshConfigurationArgs{
    			IncrementalRefresh: &quicksight.DataSetRefreshPropertiesRefreshConfigurationIncrementalRefreshArgs{
    				LookbackWindow: &quicksight.DataSetRefreshPropertiesRefreshConfigurationIncrementalRefreshLookbackWindowArgs{
    					ColumnName: pulumi.String("string"),
    					Size:       pulumi.Int(0),
    					SizeUnit:   pulumi.String("string"),
    				},
    			},
    		},
    	},
    	RowLevelPermissionDataSet: &quicksight.DataSetRowLevelPermissionDataSetArgs{
    		Arn:              pulumi.String("string"),
    		PermissionPolicy: pulumi.String("string"),
    		FormatVersion:    pulumi.String("string"),
    		Namespace:        pulumi.String("string"),
    		Status:           pulumi.String("string"),
    	},
    	RowLevelPermissionTagConfiguration: &quicksight.DataSetRowLevelPermissionTagConfigurationArgs{
    		TagRules: quicksight.DataSetRowLevelPermissionTagConfigurationTagRuleArray{
    			&quicksight.DataSetRowLevelPermissionTagConfigurationTagRuleArgs{
    				ColumnName:             pulumi.String("string"),
    				TagKey:                 pulumi.String("string"),
    				MatchAllValue:          pulumi.String("string"),
    				TagMultiValueDelimiter: pulumi.String("string"),
    			},
    		},
    		Status: pulumi.String("string"),
    	},
    	Tags: pulumi.StringMap{
    		"string": pulumi.String("string"),
    	},
    })
    
    var awsDataSetResource = new DataSet("awsDataSetResource", DataSetArgs.builder()
        .importMode("string")
        .dataSetId("string")
        .name("string")
        .columnLevelPermissionRules(DataSetColumnLevelPermissionRuleArgs.builder()
            .columnNames("string")
            .principals("string")
            .build())
        .dataSetUsageConfiguration(DataSetDataSetUsageConfigurationArgs.builder()
            .disableUseAsDirectQuerySource(false)
            .disableUseAsImportedSource(false)
            .build())
        .fieldFolders(DataSetFieldFolderArgs.builder()
            .fieldFoldersId("string")
            .columns("string")
            .description("string")
            .build())
        .columnGroups(DataSetColumnGroupArgs.builder()
            .geoSpatialColumnGroup(DataSetColumnGroupGeoSpatialColumnGroupArgs.builder()
                .columns("string")
                .countryCode("string")
                .name("string")
                .build())
            .build())
        .logicalTableMaps(DataSetLogicalTableMapArgs.builder()
            .alias("string")
            .logicalTableMapId("string")
            .source(DataSetLogicalTableMapSourceArgs.builder()
                .dataSetArn("string")
                .joinInstruction(DataSetLogicalTableMapSourceJoinInstructionArgs.builder()
                    .leftOperand("string")
                    .onClause("string")
                    .rightOperand("string")
                    .type("string")
                    .leftJoinKeyProperties(DataSetLogicalTableMapSourceJoinInstructionLeftJoinKeyPropertiesArgs.builder()
                        .uniqueKey(false)
                        .build())
                    .rightJoinKeyProperties(DataSetLogicalTableMapSourceJoinInstructionRightJoinKeyPropertiesArgs.builder()
                        .uniqueKey(false)
                        .build())
                    .build())
                .physicalTableId("string")
                .build())
            .dataTransforms(DataSetLogicalTableMapDataTransformArgs.builder()
                .castColumnTypeOperation(DataSetLogicalTableMapDataTransformCastColumnTypeOperationArgs.builder()
                    .columnName("string")
                    .newColumnType("string")
                    .format("string")
                    .build())
                .createColumnsOperation(DataSetLogicalTableMapDataTransformCreateColumnsOperationArgs.builder()
                    .columns(DataSetLogicalTableMapDataTransformCreateColumnsOperationColumnArgs.builder()
                        .columnId("string")
                        .columnName("string")
                        .expression("string")
                        .build())
                    .build())
                .filterOperation(DataSetLogicalTableMapDataTransformFilterOperationArgs.builder()
                    .conditionExpression("string")
                    .build())
                .projectOperation(DataSetLogicalTableMapDataTransformProjectOperationArgs.builder()
                    .projectedColumns("string")
                    .build())
                .renameColumnOperation(DataSetLogicalTableMapDataTransformRenameColumnOperationArgs.builder()
                    .columnName("string")
                    .newColumnName("string")
                    .build())
                .tagColumnOperation(DataSetLogicalTableMapDataTransformTagColumnOperationArgs.builder()
                    .columnName("string")
                    .tags(DataSetLogicalTableMapDataTransformTagColumnOperationTagArgs.builder()
                        .columnDescription(DataSetLogicalTableMapDataTransformTagColumnOperationTagColumnDescriptionArgs.builder()
                            .text("string")
                            .build())
                        .columnGeographicRole("string")
                        .build())
                    .build())
                .untagColumnOperation(DataSetLogicalTableMapDataTransformUntagColumnOperationArgs.builder()
                    .columnName("string")
                    .tagNames("string")
                    .build())
                .build())
            .build())
        .awsAccountId("string")
        .permissions(DataSetPermissionArgs.builder()
            .actions("string")
            .principal("string")
            .build())
        .physicalTableMaps(DataSetPhysicalTableMapArgs.builder()
            .physicalTableMapId("string")
            .customSql(DataSetPhysicalTableMapCustomSqlArgs.builder()
                .dataSourceArn("string")
                .name("string")
                .sqlQuery("string")
                .columns(DataSetPhysicalTableMapCustomSqlColumnArgs.builder()
                    .name("string")
                    .type("string")
                    .build())
                .build())
            .relationalTable(DataSetPhysicalTableMapRelationalTableArgs.builder()
                .dataSourceArn("string")
                .inputColumns(DataSetPhysicalTableMapRelationalTableInputColumnArgs.builder()
                    .name("string")
                    .type("string")
                    .build())
                .name("string")
                .catalog("string")
                .schema("string")
                .build())
            .s3Source(DataSetPhysicalTableMapS3SourceArgs.builder()
                .dataSourceArn("string")
                .inputColumns(DataSetPhysicalTableMapS3SourceInputColumnArgs.builder()
                    .name("string")
                    .type("string")
                    .build())
                .uploadSettings(DataSetPhysicalTableMapS3SourceUploadSettingsArgs.builder()
                    .containsHeader(false)
                    .delimiter("string")
                    .format("string")
                    .startFromRow(0)
                    .textQualifier("string")
                    .build())
                .build())
            .build())
        .refreshProperties(DataSetRefreshPropertiesArgs.builder()
            .refreshConfiguration(DataSetRefreshPropertiesRefreshConfigurationArgs.builder()
                .incrementalRefresh(DataSetRefreshPropertiesRefreshConfigurationIncrementalRefreshArgs.builder()
                    .lookbackWindow(DataSetRefreshPropertiesRefreshConfigurationIncrementalRefreshLookbackWindowArgs.builder()
                        .columnName("string")
                        .size(0)
                        .sizeUnit("string")
                        .build())
                    .build())
                .build())
            .build())
        .rowLevelPermissionDataSet(DataSetRowLevelPermissionDataSetArgs.builder()
            .arn("string")
            .permissionPolicy("string")
            .formatVersion("string")
            .namespace("string")
            .status("string")
            .build())
        .rowLevelPermissionTagConfiguration(DataSetRowLevelPermissionTagConfigurationArgs.builder()
            .tagRules(DataSetRowLevelPermissionTagConfigurationTagRuleArgs.builder()
                .columnName("string")
                .tagKey("string")
                .matchAllValue("string")
                .tagMultiValueDelimiter("string")
                .build())
            .status("string")
            .build())
        .tags(Map.of("string", "string"))
        .build());
    
    aws_data_set_resource = aws.quicksight.DataSet("awsDataSetResource",
        import_mode="string",
        data_set_id="string",
        name="string",
        column_level_permission_rules=[aws.quicksight.DataSetColumnLevelPermissionRuleArgs(
            column_names=["string"],
            principals=["string"],
        )],
        data_set_usage_configuration=aws.quicksight.DataSetDataSetUsageConfigurationArgs(
            disable_use_as_direct_query_source=False,
            disable_use_as_imported_source=False,
        ),
        field_folders=[aws.quicksight.DataSetFieldFolderArgs(
            field_folders_id="string",
            columns=["string"],
            description="string",
        )],
        column_groups=[aws.quicksight.DataSetColumnGroupArgs(
            geo_spatial_column_group=aws.quicksight.DataSetColumnGroupGeoSpatialColumnGroupArgs(
                columns=["string"],
                country_code="string",
                name="string",
            ),
        )],
        logical_table_maps=[aws.quicksight.DataSetLogicalTableMapArgs(
            alias="string",
            logical_table_map_id="string",
            source=aws.quicksight.DataSetLogicalTableMapSourceArgs(
                data_set_arn="string",
                join_instruction=aws.quicksight.DataSetLogicalTableMapSourceJoinInstructionArgs(
                    left_operand="string",
                    on_clause="string",
                    right_operand="string",
                    type="string",
                    left_join_key_properties=aws.quicksight.DataSetLogicalTableMapSourceJoinInstructionLeftJoinKeyPropertiesArgs(
                        unique_key=False,
                    ),
                    right_join_key_properties=aws.quicksight.DataSetLogicalTableMapSourceJoinInstructionRightJoinKeyPropertiesArgs(
                        unique_key=False,
                    ),
                ),
                physical_table_id="string",
            ),
            data_transforms=[aws.quicksight.DataSetLogicalTableMapDataTransformArgs(
                cast_column_type_operation=aws.quicksight.DataSetLogicalTableMapDataTransformCastColumnTypeOperationArgs(
                    column_name="string",
                    new_column_type="string",
                    format="string",
                ),
                create_columns_operation=aws.quicksight.DataSetLogicalTableMapDataTransformCreateColumnsOperationArgs(
                    columns=[aws.quicksight.DataSetLogicalTableMapDataTransformCreateColumnsOperationColumnArgs(
                        column_id="string",
                        column_name="string",
                        expression="string",
                    )],
                ),
                filter_operation=aws.quicksight.DataSetLogicalTableMapDataTransformFilterOperationArgs(
                    condition_expression="string",
                ),
                project_operation=aws.quicksight.DataSetLogicalTableMapDataTransformProjectOperationArgs(
                    projected_columns=["string"],
                ),
                rename_column_operation=aws.quicksight.DataSetLogicalTableMapDataTransformRenameColumnOperationArgs(
                    column_name="string",
                    new_column_name="string",
                ),
                tag_column_operation=aws.quicksight.DataSetLogicalTableMapDataTransformTagColumnOperationArgs(
                    column_name="string",
                    tags=[aws.quicksight.DataSetLogicalTableMapDataTransformTagColumnOperationTagArgs(
                        column_description=aws.quicksight.DataSetLogicalTableMapDataTransformTagColumnOperationTagColumnDescriptionArgs(
                            text="string",
                        ),
                        column_geographic_role="string",
                    )],
                ),
                untag_column_operation=aws.quicksight.DataSetLogicalTableMapDataTransformUntagColumnOperationArgs(
                    column_name="string",
                    tag_names=["string"],
                ),
            )],
        )],
        aws_account_id="string",
        permissions=[aws.quicksight.DataSetPermissionArgs(
            actions=["string"],
            principal="string",
        )],
        physical_table_maps=[aws.quicksight.DataSetPhysicalTableMapArgs(
            physical_table_map_id="string",
            custom_sql=aws.quicksight.DataSetPhysicalTableMapCustomSqlArgs(
                data_source_arn="string",
                name="string",
                sql_query="string",
                columns=[aws.quicksight.DataSetPhysicalTableMapCustomSqlColumnArgs(
                    name="string",
                    type="string",
                )],
            ),
            relational_table=aws.quicksight.DataSetPhysicalTableMapRelationalTableArgs(
                data_source_arn="string",
                input_columns=[aws.quicksight.DataSetPhysicalTableMapRelationalTableInputColumnArgs(
                    name="string",
                    type="string",
                )],
                name="string",
                catalog="string",
                schema="string",
            ),
            s3_source=aws.quicksight.DataSetPhysicalTableMapS3SourceArgs(
                data_source_arn="string",
                input_columns=[aws.quicksight.DataSetPhysicalTableMapS3SourceInputColumnArgs(
                    name="string",
                    type="string",
                )],
                upload_settings=aws.quicksight.DataSetPhysicalTableMapS3SourceUploadSettingsArgs(
                    contains_header=False,
                    delimiter="string",
                    format="string",
                    start_from_row=0,
                    text_qualifier="string",
                ),
            ),
        )],
        refresh_properties=aws.quicksight.DataSetRefreshPropertiesArgs(
            refresh_configuration=aws.quicksight.DataSetRefreshPropertiesRefreshConfigurationArgs(
                incremental_refresh=aws.quicksight.DataSetRefreshPropertiesRefreshConfigurationIncrementalRefreshArgs(
                    lookback_window=aws.quicksight.DataSetRefreshPropertiesRefreshConfigurationIncrementalRefreshLookbackWindowArgs(
                        column_name="string",
                        size=0,
                        size_unit="string",
                    ),
                ),
            ),
        ),
        row_level_permission_data_set=aws.quicksight.DataSetRowLevelPermissionDataSetArgs(
            arn="string",
            permission_policy="string",
            format_version="string",
            namespace="string",
            status="string",
        ),
        row_level_permission_tag_configuration=aws.quicksight.DataSetRowLevelPermissionTagConfigurationArgs(
            tag_rules=[aws.quicksight.DataSetRowLevelPermissionTagConfigurationTagRuleArgs(
                column_name="string",
                tag_key="string",
                match_all_value="string",
                tag_multi_value_delimiter="string",
            )],
            status="string",
        ),
        tags={
            "string": "string",
        })
    
    const awsDataSetResource = new aws.quicksight.DataSet("awsDataSetResource", {
        importMode: "string",
        dataSetId: "string",
        name: "string",
        columnLevelPermissionRules: [{
            columnNames: ["string"],
            principals: ["string"],
        }],
        dataSetUsageConfiguration: {
            disableUseAsDirectQuerySource: false,
            disableUseAsImportedSource: false,
        },
        fieldFolders: [{
            fieldFoldersId: "string",
            columns: ["string"],
            description: "string",
        }],
        columnGroups: [{
            geoSpatialColumnGroup: {
                columns: ["string"],
                countryCode: "string",
                name: "string",
            },
        }],
        logicalTableMaps: [{
            alias: "string",
            logicalTableMapId: "string",
            source: {
                dataSetArn: "string",
                joinInstruction: {
                    leftOperand: "string",
                    onClause: "string",
                    rightOperand: "string",
                    type: "string",
                    leftJoinKeyProperties: {
                        uniqueKey: false,
                    },
                    rightJoinKeyProperties: {
                        uniqueKey: false,
                    },
                },
                physicalTableId: "string",
            },
            dataTransforms: [{
                castColumnTypeOperation: {
                    columnName: "string",
                    newColumnType: "string",
                    format: "string",
                },
                createColumnsOperation: {
                    columns: [{
                        columnId: "string",
                        columnName: "string",
                        expression: "string",
                    }],
                },
                filterOperation: {
                    conditionExpression: "string",
                },
                projectOperation: {
                    projectedColumns: ["string"],
                },
                renameColumnOperation: {
                    columnName: "string",
                    newColumnName: "string",
                },
                tagColumnOperation: {
                    columnName: "string",
                    tags: [{
                        columnDescription: {
                            text: "string",
                        },
                        columnGeographicRole: "string",
                    }],
                },
                untagColumnOperation: {
                    columnName: "string",
                    tagNames: ["string"],
                },
            }],
        }],
        awsAccountId: "string",
        permissions: [{
            actions: ["string"],
            principal: "string",
        }],
        physicalTableMaps: [{
            physicalTableMapId: "string",
            customSql: {
                dataSourceArn: "string",
                name: "string",
                sqlQuery: "string",
                columns: [{
                    name: "string",
                    type: "string",
                }],
            },
            relationalTable: {
                dataSourceArn: "string",
                inputColumns: [{
                    name: "string",
                    type: "string",
                }],
                name: "string",
                catalog: "string",
                schema: "string",
            },
            s3Source: {
                dataSourceArn: "string",
                inputColumns: [{
                    name: "string",
                    type: "string",
                }],
                uploadSettings: {
                    containsHeader: false,
                    delimiter: "string",
                    format: "string",
                    startFromRow: 0,
                    textQualifier: "string",
                },
            },
        }],
        refreshProperties: {
            refreshConfiguration: {
                incrementalRefresh: {
                    lookbackWindow: {
                        columnName: "string",
                        size: 0,
                        sizeUnit: "string",
                    },
                },
            },
        },
        rowLevelPermissionDataSet: {
            arn: "string",
            permissionPolicy: "string",
            formatVersion: "string",
            namespace: "string",
            status: "string",
        },
        rowLevelPermissionTagConfiguration: {
            tagRules: [{
                columnName: "string",
                tagKey: "string",
                matchAllValue: "string",
                tagMultiValueDelimiter: "string",
            }],
            status: "string",
        },
        tags: {
            string: "string",
        },
    });
    
    type: aws:quicksight:DataSet
    properties:
        awsAccountId: string
        columnGroups:
            - geoSpatialColumnGroup:
                columns:
                    - string
                countryCode: string
                name: string
        columnLevelPermissionRules:
            - columnNames:
                - string
              principals:
                - string
        dataSetId: string
        dataSetUsageConfiguration:
            disableUseAsDirectQuerySource: false
            disableUseAsImportedSource: false
        fieldFolders:
            - columns:
                - string
              description: string
              fieldFoldersId: string
        importMode: string
        logicalTableMaps:
            - alias: string
              dataTransforms:
                - castColumnTypeOperation:
                    columnName: string
                    format: string
                    newColumnType: string
                  createColumnsOperation:
                    columns:
                        - columnId: string
                          columnName: string
                          expression: string
                  filterOperation:
                    conditionExpression: string
                  projectOperation:
                    projectedColumns:
                        - string
                  renameColumnOperation:
                    columnName: string
                    newColumnName: string
                  tagColumnOperation:
                    columnName: string
                    tags:
                        - columnDescription:
                            text: string
                          columnGeographicRole: string
                  untagColumnOperation:
                    columnName: string
                    tagNames:
                        - string
              logicalTableMapId: string
              source:
                dataSetArn: string
                joinInstruction:
                    leftJoinKeyProperties:
                        uniqueKey: false
                    leftOperand: string
                    onClause: string
                    rightJoinKeyProperties:
                        uniqueKey: false
                    rightOperand: string
                    type: string
                physicalTableId: string
        name: string
        permissions:
            - actions:
                - string
              principal: string
        physicalTableMaps:
            - customSql:
                columns:
                    - name: string
                      type: string
                dataSourceArn: string
                name: string
                sqlQuery: string
              physicalTableMapId: string
              relationalTable:
                catalog: string
                dataSourceArn: string
                inputColumns:
                    - name: string
                      type: string
                name: string
                schema: string
              s3Source:
                dataSourceArn: string
                inputColumns:
                    - name: string
                      type: string
                uploadSettings:
                    containsHeader: false
                    delimiter: string
                    format: string
                    startFromRow: 0
                    textQualifier: string
        refreshProperties:
            refreshConfiguration:
                incrementalRefresh:
                    lookbackWindow:
                        columnName: string
                        size: 0
                        sizeUnit: string
        rowLevelPermissionDataSet:
            arn: string
            formatVersion: string
            namespace: string
            permissionPolicy: string
            status: string
        rowLevelPermissionTagConfiguration:
            status: string
            tagRules:
                - columnName: string
                  matchAllValue: string
                  tagKey: string
                  tagMultiValueDelimiter: string
        tags:
            string: string
    

    DataSet Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    The DataSet resource accepts the following input properties:

    DataSetId string
    Identifier for the data set.
    ImportMode string
    Indicates whether you want to import the data into SPICE. Valid values are SPICE and DIRECT_QUERY.
    AwsAccountId string
    AWS account ID.
    ColumnGroups List<Pulumi.Aws.Quicksight.Inputs.DataSetColumnGroup>
    Groupings of columns that work together in certain Amazon QuickSight features. Currently, only geospatial hierarchy is supported. See column_groups.
    ColumnLevelPermissionRules List<Pulumi.Aws.Quicksight.Inputs.DataSetColumnLevelPermissionRule>
    A set of 1 or more definitions of a ColumnLevelPermissionRule. See column_level_permission_rules.
    DataSetUsageConfiguration Pulumi.Aws.Quicksight.Inputs.DataSetDataSetUsageConfiguration
    The usage configuration to apply to child datasets that reference this dataset as a source. See data_set_usage_configuration.
    FieldFolders List<Pulumi.Aws.Quicksight.Inputs.DataSetFieldFolder>
    The folder that contains fields and nested subfolders for your dataset. See field_folders.
    LogicalTableMaps List<Pulumi.Aws.Quicksight.Inputs.DataSetLogicalTableMap>
    Configures the combination and transformation of the data from the physical tables. Maximum of 1 entry. See logical_table_map.
    Name string
    Display name for the dataset.
    Permissions List<Pulumi.Aws.Quicksight.Inputs.DataSetPermission>
    A set of resource permissions on the data source. Maximum of 64 items. See permissions.
    PhysicalTableMaps List<Pulumi.Aws.Quicksight.Inputs.DataSetPhysicalTableMap>

    Declares the physical tables that are available in the underlying data sources. See physical_table_map.

    The following arguments are optional:

    RefreshProperties Pulumi.Aws.Quicksight.Inputs.DataSetRefreshProperties
    The refresh properties for the data set. NOTE: Only valid when import_mode is set to SPICE. See refresh_properties.
    RowLevelPermissionDataSet Pulumi.Aws.Quicksight.Inputs.DataSetRowLevelPermissionDataSet
    The row-level security configuration for the data that you want to create. See row_level_permission_data_set.
    RowLevelPermissionTagConfiguration Pulumi.Aws.Quicksight.Inputs.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.
    Tags Dictionary<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.
    DataSetId string
    Identifier for the data set.
    ImportMode string
    Indicates whether you want to import the data into SPICE. Valid values are SPICE and DIRECT_QUERY.
    AwsAccountId string
    AWS account ID.
    ColumnGroups []DataSetColumnGroupArgs
    Groupings of columns that work together in certain Amazon QuickSight features. Currently, only geospatial hierarchy is supported. See column_groups.
    ColumnLevelPermissionRules []DataSetColumnLevelPermissionRuleArgs
    A set of 1 or more definitions of a ColumnLevelPermissionRule. See column_level_permission_rules.
    DataSetUsageConfiguration DataSetDataSetUsageConfigurationArgs
    The usage configuration to apply to child datasets that reference this dataset as a source. See data_set_usage_configuration.
    FieldFolders []DataSetFieldFolderArgs
    The folder that contains fields and nested subfolders for your dataset. See field_folders.
    LogicalTableMaps []DataSetLogicalTableMapArgs
    Configures the combination and transformation of the data from the physical tables. Maximum of 1 entry. See logical_table_map.
    Name string
    Display name for the dataset.
    Permissions []DataSetPermissionArgs
    A set of resource permissions on the data source. Maximum of 64 items. See permissions.
    PhysicalTableMaps []DataSetPhysicalTableMapArgs

    Declares the physical tables that are available in the underlying data sources. See physical_table_map.

    The following arguments are optional:

    RefreshProperties DataSetRefreshPropertiesArgs
    The refresh properties for the data set. NOTE: Only valid when import_mode is set to SPICE. See refresh_properties.
    RowLevelPermissionDataSet DataSetRowLevelPermissionDataSetArgs
    The row-level security configuration for the data that you want to create. See row_level_permission_data_set.
    RowLevelPermissionTagConfiguration DataSetRowLevelPermissionTagConfigurationArgs
    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.
    Tags 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.
    dataSetId String
    Identifier for the data set.
    importMode String
    Indicates whether you want to import the data into SPICE. Valid values are SPICE and DIRECT_QUERY.
    awsAccountId String
    AWS account ID.
    columnGroups List<DataSetColumnGroup>
    Groupings of columns that work together in certain Amazon QuickSight features. Currently, only geospatial hierarchy is supported. See column_groups.
    columnLevelPermissionRules List<DataSetColumnLevelPermissionRule>
    A set of 1 or more definitions of a ColumnLevelPermissionRule. See column_level_permission_rules.
    dataSetUsageConfiguration DataSetDataSetUsageConfiguration
    The usage configuration to apply to child datasets that reference this dataset as a source. See data_set_usage_configuration.
    fieldFolders List<DataSetFieldFolder>
    The folder that contains fields and nested subfolders for your dataset. See field_folders.
    logicalTableMaps List<DataSetLogicalTableMap>
    Configures the combination and transformation of the data from the physical tables. Maximum of 1 entry. See logical_table_map.
    name String
    Display name for the dataset.
    permissions List<DataSetPermission>
    A set of resource permissions on the data source. Maximum of 64 items. See permissions.
    physicalTableMaps List<DataSetPhysicalTableMap>

    Declares the physical tables that are available in the underlying data sources. See physical_table_map.

    The following arguments are optional:

    refreshProperties DataSetRefreshProperties
    The refresh properties for the data set. NOTE: Only valid when import_mode is set to SPICE. See refresh_properties.
    rowLevelPermissionDataSet DataSetRowLevelPermissionDataSet
    The row-level security configuration for the data that you want to create. See row_level_permission_data_set.
    rowLevelPermissionTagConfiguration 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.
    tags 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.
    dataSetId string
    Identifier for the data set.
    importMode string
    Indicates whether you want to import the data into SPICE. Valid values are SPICE and DIRECT_QUERY.
    awsAccountId string
    AWS account ID.
    columnGroups DataSetColumnGroup[]
    Groupings of columns that work together in certain Amazon QuickSight features. Currently, only geospatial hierarchy is supported. See column_groups.
    columnLevelPermissionRules DataSetColumnLevelPermissionRule[]
    A set of 1 or more definitions of a ColumnLevelPermissionRule. See column_level_permission_rules.
    dataSetUsageConfiguration DataSetDataSetUsageConfiguration
    The usage configuration to apply to child datasets that reference this dataset as a source. See data_set_usage_configuration.
    fieldFolders DataSetFieldFolder[]
    The folder that contains fields and nested subfolders for your dataset. See field_folders.
    logicalTableMaps DataSetLogicalTableMap[]
    Configures the combination and transformation of the data from the physical tables. Maximum of 1 entry. See logical_table_map.
    name string
    Display name for the dataset.
    permissions DataSetPermission[]
    A set of resource permissions on the data source. Maximum of 64 items. See permissions.
    physicalTableMaps DataSetPhysicalTableMap[]

    Declares the physical tables that are available in the underlying data sources. See physical_table_map.

    The following arguments are optional:

    refreshProperties DataSetRefreshProperties
    The refresh properties for the data set. NOTE: Only valid when import_mode is set to SPICE. See refresh_properties.
    rowLevelPermissionDataSet DataSetRowLevelPermissionDataSet
    The row-level security configuration for the data that you want to create. See row_level_permission_data_set.
    rowLevelPermissionTagConfiguration 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.
    tags {[key: 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.
    data_set_id str
    Identifier for the data set.
    import_mode str
    Indicates whether you want to import the data into SPICE. Valid values are SPICE and DIRECT_QUERY.
    aws_account_id str
    AWS account ID.
    column_groups Sequence[DataSetColumnGroupArgs]
    Groupings of columns that work together in certain Amazon QuickSight features. Currently, only geospatial hierarchy is supported. See column_groups.
    column_level_permission_rules Sequence[DataSetColumnLevelPermissionRuleArgs]
    A set of 1 or more definitions of a ColumnLevelPermissionRule. See column_level_permission_rules.
    data_set_usage_configuration DataSetDataSetUsageConfigurationArgs
    The usage configuration to apply to child datasets that reference this dataset as a source. See data_set_usage_configuration.
    field_folders Sequence[DataSetFieldFolderArgs]
    The folder that contains fields and nested subfolders for your dataset. See field_folders.
    logical_table_maps Sequence[DataSetLogicalTableMapArgs]
    Configures the combination and transformation of the data from the physical tables. Maximum of 1 entry. See logical_table_map.
    name str
    Display name for the dataset.
    permissions Sequence[DataSetPermissionArgs]
    A set of resource permissions on the data source. Maximum of 64 items. See permissions.
    physical_table_maps Sequence[DataSetPhysicalTableMapArgs]

    Declares the physical tables that are available in the underlying data sources. See physical_table_map.

    The following arguments are optional:

    refresh_properties DataSetRefreshPropertiesArgs
    The refresh properties for the data set. NOTE: Only valid when import_mode is set to SPICE. See refresh_properties.
    row_level_permission_data_set DataSetRowLevelPermissionDataSetArgs
    The row-level security configuration for the data that you want to create. See row_level_permission_data_set.
    row_level_permission_tag_configuration DataSetRowLevelPermissionTagConfigurationArgs
    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.
    tags Mapping[str, str]
    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.
    dataSetId String
    Identifier for the data set.
    importMode String
    Indicates whether you want to import the data into SPICE. Valid values are SPICE and DIRECT_QUERY.
    awsAccountId String
    AWS account ID.
    columnGroups List<Property Map>
    Groupings of columns that work together in certain Amazon QuickSight features. Currently, only geospatial hierarchy is supported. See column_groups.
    columnLevelPermissionRules List<Property Map>
    A set of 1 or more definitions of a ColumnLevelPermissionRule. See column_level_permission_rules.
    dataSetUsageConfiguration Property Map
    The usage configuration to apply to child datasets that reference this dataset as a source. See data_set_usage_configuration.
    fieldFolders List<Property Map>
    The folder that contains fields and nested subfolders for your dataset. See field_folders.
    logicalTableMaps List<Property Map>
    Configures the combination and transformation of the data from the physical tables. Maximum of 1 entry. See logical_table_map.
    name String
    Display name for the dataset.
    permissions List<Property Map>
    A set of resource permissions on the data source. Maximum of 64 items. See permissions.
    physicalTableMaps List<Property Map>

    Declares the physical tables that are available in the underlying data sources. See physical_table_map.

    The following arguments are optional:

    refreshProperties Property Map
    The refresh properties for the data set. NOTE: Only valid when import_mode is set to SPICE. See refresh_properties.
    rowLevelPermissionDataSet Property Map
    The row-level security configuration for the data that you want to create. See row_level_permission_data_set.
    rowLevelPermissionTagConfiguration Property Map
    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.
    tags Map<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.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the DataSet resource produces the following output properties:

    Arn string
    Amazon Resource Name (ARN) of the data set.
    Id string
    The provider-assigned unique ID for this managed resource.
    OutputColumns List<Pulumi.Aws.Quicksight.Outputs.DataSetOutputColumn>
    TagsAll Dictionary<string, string>
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    Arn string
    Amazon Resource Name (ARN) of the data set.
    Id string
    The provider-assigned unique ID for this managed resource.
    OutputColumns []DataSetOutputColumn
    TagsAll map[string]string
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    arn String
    Amazon Resource Name (ARN) of the data set.
    id String
    The provider-assigned unique ID for this managed resource.
    outputColumns List<DataSetOutputColumn>
    tagsAll Map<String,String>
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    arn string
    Amazon Resource Name (ARN) of the data set.
    id string
    The provider-assigned unique ID for this managed resource.
    outputColumns DataSetOutputColumn[]
    tagsAll {[key: string]: string}
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    arn str
    Amazon Resource Name (ARN) of the data set.
    id str
    The provider-assigned unique ID for this managed resource.
    output_columns Sequence[DataSetOutputColumn]
    tags_all Mapping[str, str]
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    arn String
    Amazon Resource Name (ARN) of the data set.
    id String
    The provider-assigned unique ID for this managed resource.
    outputColumns List<Property Map>
    tagsAll Map<String>
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    Look up Existing DataSet Resource

    Get an existing DataSet resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: DataSetState, opts?: CustomResourceOptions): DataSet
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            arn: Optional[str] = None,
            aws_account_id: Optional[str] = None,
            column_groups: Optional[Sequence[DataSetColumnGroupArgs]] = None,
            column_level_permission_rules: Optional[Sequence[DataSetColumnLevelPermissionRuleArgs]] = None,
            data_set_id: Optional[str] = None,
            data_set_usage_configuration: Optional[DataSetDataSetUsageConfigurationArgs] = None,
            field_folders: Optional[Sequence[DataSetFieldFolderArgs]] = None,
            import_mode: Optional[str] = None,
            logical_table_maps: Optional[Sequence[DataSetLogicalTableMapArgs]] = None,
            name: Optional[str] = None,
            output_columns: Optional[Sequence[DataSetOutputColumnArgs]] = None,
            permissions: Optional[Sequence[DataSetPermissionArgs]] = None,
            physical_table_maps: Optional[Sequence[DataSetPhysicalTableMapArgs]] = None,
            refresh_properties: Optional[DataSetRefreshPropertiesArgs] = None,
            row_level_permission_data_set: Optional[DataSetRowLevelPermissionDataSetArgs] = None,
            row_level_permission_tag_configuration: Optional[DataSetRowLevelPermissionTagConfigurationArgs] = None,
            tags: Optional[Mapping[str, str]] = None,
            tags_all: Optional[Mapping[str, str]] = None) -> DataSet
    func GetDataSet(ctx *Context, name string, id IDInput, state *DataSetState, opts ...ResourceOption) (*DataSet, error)
    public static DataSet Get(string name, Input<string> id, DataSetState? state, CustomResourceOptions? opts = null)
    public static DataSet get(String name, Output<String> id, DataSetState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    Arn string
    Amazon Resource Name (ARN) of the data set.
    AwsAccountId string
    AWS account ID.
    ColumnGroups List<Pulumi.Aws.Quicksight.Inputs.DataSetColumnGroup>
    Groupings of columns that work together in certain Amazon QuickSight features. Currently, only geospatial hierarchy is supported. See column_groups.
    ColumnLevelPermissionRules List<Pulumi.Aws.Quicksight.Inputs.DataSetColumnLevelPermissionRule>
    A set of 1 or more definitions of a ColumnLevelPermissionRule. See column_level_permission_rules.
    DataSetId string
    Identifier for the data set.
    DataSetUsageConfiguration Pulumi.Aws.Quicksight.Inputs.DataSetDataSetUsageConfiguration
    The usage configuration to apply to child datasets that reference this dataset as a source. See data_set_usage_configuration.
    FieldFolders List<Pulumi.Aws.Quicksight.Inputs.DataSetFieldFolder>
    The folder that contains fields and nested subfolders for your dataset. See field_folders.
    ImportMode string
    Indicates whether you want to import the data into SPICE. Valid values are SPICE and DIRECT_QUERY.
    LogicalTableMaps List<Pulumi.Aws.Quicksight.Inputs.DataSetLogicalTableMap>
    Configures the combination and transformation of the data from the physical tables. Maximum of 1 entry. See logical_table_map.
    Name string
    Display name for the dataset.
    OutputColumns List<Pulumi.Aws.Quicksight.Inputs.DataSetOutputColumn>
    Permissions List<Pulumi.Aws.Quicksight.Inputs.DataSetPermission>
    A set of resource permissions on the data source. Maximum of 64 items. See permissions.
    PhysicalTableMaps List<Pulumi.Aws.Quicksight.Inputs.DataSetPhysicalTableMap>

    Declares the physical tables that are available in the underlying data sources. See physical_table_map.

    The following arguments are optional:

    RefreshProperties Pulumi.Aws.Quicksight.Inputs.DataSetRefreshProperties
    The refresh properties for the data set. NOTE: Only valid when import_mode is set to SPICE. See refresh_properties.
    RowLevelPermissionDataSet Pulumi.Aws.Quicksight.Inputs.DataSetRowLevelPermissionDataSet
    The row-level security configuration for the data that you want to create. See row_level_permission_data_set.
    RowLevelPermissionTagConfiguration Pulumi.Aws.Quicksight.Inputs.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.
    Tags Dictionary<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.
    TagsAll Dictionary<string, string>
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    Arn string
    Amazon Resource Name (ARN) of the data set.
    AwsAccountId string
    AWS account ID.
    ColumnGroups []DataSetColumnGroupArgs
    Groupings of columns that work together in certain Amazon QuickSight features. Currently, only geospatial hierarchy is supported. See column_groups.
    ColumnLevelPermissionRules []DataSetColumnLevelPermissionRuleArgs
    A set of 1 or more definitions of a ColumnLevelPermissionRule. See column_level_permission_rules.
    DataSetId string
    Identifier for the data set.
    DataSetUsageConfiguration DataSetDataSetUsageConfigurationArgs
    The usage configuration to apply to child datasets that reference this dataset as a source. See data_set_usage_configuration.
    FieldFolders []DataSetFieldFolderArgs
    The folder that contains fields and nested subfolders for your dataset. See field_folders.
    ImportMode string
    Indicates whether you want to import the data into SPICE. Valid values are SPICE and DIRECT_QUERY.
    LogicalTableMaps []DataSetLogicalTableMapArgs
    Configures the combination and transformation of the data from the physical tables. Maximum of 1 entry. See logical_table_map.
    Name string
    Display name for the dataset.
    OutputColumns []DataSetOutputColumnArgs
    Permissions []DataSetPermissionArgs
    A set of resource permissions on the data source. Maximum of 64 items. See permissions.
    PhysicalTableMaps []DataSetPhysicalTableMapArgs

    Declares the physical tables that are available in the underlying data sources. See physical_table_map.

    The following arguments are optional:

    RefreshProperties DataSetRefreshPropertiesArgs
    The refresh properties for the data set. NOTE: Only valid when import_mode is set to SPICE. See refresh_properties.
    RowLevelPermissionDataSet DataSetRowLevelPermissionDataSetArgs
    The row-level security configuration for the data that you want to create. See row_level_permission_data_set.
    RowLevelPermissionTagConfiguration DataSetRowLevelPermissionTagConfigurationArgs
    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.
    Tags 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.
    TagsAll map[string]string
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    arn String
    Amazon Resource Name (ARN) of the data set.
    awsAccountId String
    AWS account ID.
    columnGroups List<DataSetColumnGroup>
    Groupings of columns that work together in certain Amazon QuickSight features. Currently, only geospatial hierarchy is supported. See column_groups.
    columnLevelPermissionRules List<DataSetColumnLevelPermissionRule>
    A set of 1 or more definitions of a ColumnLevelPermissionRule. See column_level_permission_rules.
    dataSetId String
    Identifier for the data set.
    dataSetUsageConfiguration DataSetDataSetUsageConfiguration
    The usage configuration to apply to child datasets that reference this dataset as a source. See data_set_usage_configuration.
    fieldFolders List<DataSetFieldFolder>
    The folder that contains fields and nested subfolders for your dataset. See field_folders.
    importMode String
    Indicates whether you want to import the data into SPICE. Valid values are SPICE and DIRECT_QUERY.
    logicalTableMaps List<DataSetLogicalTableMap>
    Configures the combination and transformation of the data from the physical tables. Maximum of 1 entry. See logical_table_map.
    name String
    Display name for the dataset.
    outputColumns List<DataSetOutputColumn>
    permissions List<DataSetPermission>
    A set of resource permissions on the data source. Maximum of 64 items. See permissions.
    physicalTableMaps List<DataSetPhysicalTableMap>

    Declares the physical tables that are available in the underlying data sources. See physical_table_map.

    The following arguments are optional:

    refreshProperties DataSetRefreshProperties
    The refresh properties for the data set. NOTE: Only valid when import_mode is set to SPICE. See refresh_properties.
    rowLevelPermissionDataSet DataSetRowLevelPermissionDataSet
    The row-level security configuration for the data that you want to create. See row_level_permission_data_set.
    rowLevelPermissionTagConfiguration 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.
    tags 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.
    tagsAll Map<String,String>
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    arn string
    Amazon Resource Name (ARN) of the data set.
    awsAccountId string
    AWS account ID.
    columnGroups DataSetColumnGroup[]
    Groupings of columns that work together in certain Amazon QuickSight features. Currently, only geospatial hierarchy is supported. See column_groups.
    columnLevelPermissionRules DataSetColumnLevelPermissionRule[]
    A set of 1 or more definitions of a ColumnLevelPermissionRule. See column_level_permission_rules.
    dataSetId string
    Identifier for the data set.
    dataSetUsageConfiguration DataSetDataSetUsageConfiguration
    The usage configuration to apply to child datasets that reference this dataset as a source. See data_set_usage_configuration.
    fieldFolders DataSetFieldFolder[]
    The folder that contains fields and nested subfolders for your dataset. See field_folders.
    importMode string
    Indicates whether you want to import the data into SPICE. Valid values are SPICE and DIRECT_QUERY.
    logicalTableMaps DataSetLogicalTableMap[]
    Configures the combination and transformation of the data from the physical tables. Maximum of 1 entry. See logical_table_map.
    name string
    Display name for the dataset.
    outputColumns DataSetOutputColumn[]
    permissions DataSetPermission[]
    A set of resource permissions on the data source. Maximum of 64 items. See permissions.
    physicalTableMaps DataSetPhysicalTableMap[]

    Declares the physical tables that are available in the underlying data sources. See physical_table_map.

    The following arguments are optional:

    refreshProperties DataSetRefreshProperties
    The refresh properties for the data set. NOTE: Only valid when import_mode is set to SPICE. See refresh_properties.
    rowLevelPermissionDataSet DataSetRowLevelPermissionDataSet
    The row-level security configuration for the data that you want to create. See row_level_permission_data_set.
    rowLevelPermissionTagConfiguration 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.
    tags {[key: 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.
    tagsAll {[key: string]: string}
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    arn str
    Amazon Resource Name (ARN) of the data set.
    aws_account_id str
    AWS account ID.
    column_groups Sequence[DataSetColumnGroupArgs]
    Groupings of columns that work together in certain Amazon QuickSight features. Currently, only geospatial hierarchy is supported. See column_groups.
    column_level_permission_rules Sequence[DataSetColumnLevelPermissionRuleArgs]
    A set of 1 or more definitions of a ColumnLevelPermissionRule. See column_level_permission_rules.
    data_set_id str
    Identifier for the data set.
    data_set_usage_configuration DataSetDataSetUsageConfigurationArgs
    The usage configuration to apply to child datasets that reference this dataset as a source. See data_set_usage_configuration.
    field_folders Sequence[DataSetFieldFolderArgs]
    The folder that contains fields and nested subfolders for your dataset. See field_folders.
    import_mode str
    Indicates whether you want to import the data into SPICE. Valid values are SPICE and DIRECT_QUERY.
    logical_table_maps Sequence[DataSetLogicalTableMapArgs]
    Configures the combination and transformation of the data from the physical tables. Maximum of 1 entry. See logical_table_map.
    name str
    Display name for the dataset.
    output_columns Sequence[DataSetOutputColumnArgs]
    permissions Sequence[DataSetPermissionArgs]
    A set of resource permissions on the data source. Maximum of 64 items. See permissions.
    physical_table_maps Sequence[DataSetPhysicalTableMapArgs]

    Declares the physical tables that are available in the underlying data sources. See physical_table_map.

    The following arguments are optional:

    refresh_properties DataSetRefreshPropertiesArgs
    The refresh properties for the data set. NOTE: Only valid when import_mode is set to SPICE. See refresh_properties.
    row_level_permission_data_set DataSetRowLevelPermissionDataSetArgs
    The row-level security configuration for the data that you want to create. See row_level_permission_data_set.
    row_level_permission_tag_configuration DataSetRowLevelPermissionTagConfigurationArgs
    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.
    tags Mapping[str, str]
    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.
    tags_all Mapping[str, str]
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    arn String
    Amazon Resource Name (ARN) of the data set.
    awsAccountId String
    AWS account ID.
    columnGroups List<Property Map>
    Groupings of columns that work together in certain Amazon QuickSight features. Currently, only geospatial hierarchy is supported. See column_groups.
    columnLevelPermissionRules List<Property Map>
    A set of 1 or more definitions of a ColumnLevelPermissionRule. See column_level_permission_rules.
    dataSetId String
    Identifier for the data set.
    dataSetUsageConfiguration Property Map
    The usage configuration to apply to child datasets that reference this dataset as a source. See data_set_usage_configuration.
    fieldFolders List<Property Map>
    The folder that contains fields and nested subfolders for your dataset. See field_folders.
    importMode String
    Indicates whether you want to import the data into SPICE. Valid values are SPICE and DIRECT_QUERY.
    logicalTableMaps List<Property Map>
    Configures the combination and transformation of the data from the physical tables. Maximum of 1 entry. See logical_table_map.
    name String
    Display name for the dataset.
    outputColumns List<Property Map>
    permissions List<Property Map>
    A set of resource permissions on the data source. Maximum of 64 items. See permissions.
    physicalTableMaps List<Property Map>

    Declares the physical tables that are available in the underlying data sources. See physical_table_map.

    The following arguments are optional:

    refreshProperties Property Map
    The refresh properties for the data set. NOTE: Only valid when import_mode is set to SPICE. See refresh_properties.
    rowLevelPermissionDataSet Property Map
    The row-level security configuration for the data that you want to create. See row_level_permission_data_set.
    rowLevelPermissionTagConfiguration Property Map
    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.
    tags Map<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.
    tagsAll Map<String>
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    Supporting Types

    DataSetColumnGroup, DataSetColumnGroupArgs

    GeoSpatialColumnGroup Pulumi.Aws.Quicksight.Inputs.DataSetColumnGroupGeoSpatialColumnGroup
    Geospatial column group that denotes a hierarchy. See geo_spatial_column_group.
    GeoSpatialColumnGroup DataSetColumnGroupGeoSpatialColumnGroup
    Geospatial column group that denotes a hierarchy. See geo_spatial_column_group.
    geoSpatialColumnGroup DataSetColumnGroupGeoSpatialColumnGroup
    Geospatial column group that denotes a hierarchy. See geo_spatial_column_group.
    geoSpatialColumnGroup DataSetColumnGroupGeoSpatialColumnGroup
    Geospatial column group that denotes a hierarchy. See geo_spatial_column_group.
    geo_spatial_column_group DataSetColumnGroupGeoSpatialColumnGroup
    Geospatial column group that denotes a hierarchy. See geo_spatial_column_group.
    geoSpatialColumnGroup Property Map
    Geospatial column group that denotes a hierarchy. See geo_spatial_column_group.

    DataSetColumnGroupGeoSpatialColumnGroup, DataSetColumnGroupGeoSpatialColumnGroupArgs

    Columns List<string>
    Columns in this hierarchy.
    CountryCode string
    Country code. Valid values are US.
    Name string
    A display name for the hierarchy.
    Columns []string
    Columns in this hierarchy.
    CountryCode string
    Country code. Valid values are US.
    Name string
    A display name for the hierarchy.
    columns List<String>
    Columns in this hierarchy.
    countryCode String
    Country code. Valid values are US.
    name String
    A display name for the hierarchy.
    columns string[]
    Columns in this hierarchy.
    countryCode string
    Country code. Valid values are US.
    name string
    A display name for the hierarchy.
    columns Sequence[str]
    Columns in this hierarchy.
    country_code str
    Country code. Valid values are US.
    name str
    A display name for the hierarchy.
    columns List<String>
    Columns in this hierarchy.
    countryCode String
    Country code. Valid values are US.
    name String
    A display name for the hierarchy.

    DataSetColumnLevelPermissionRule, DataSetColumnLevelPermissionRuleArgs

    ColumnNames List<string>
    An array of column names.
    Principals List<string>
    An array of ARNs for Amazon QuickSight users or groups.
    ColumnNames []string
    An array of column names.
    Principals []string
    An array of ARNs for Amazon QuickSight users or groups.
    columnNames List<String>
    An array of column names.
    principals List<String>
    An array of ARNs for Amazon QuickSight users or groups.
    columnNames string[]
    An array of column names.
    principals string[]
    An array of ARNs for Amazon QuickSight users or groups.
    column_names Sequence[str]
    An array of column names.
    principals Sequence[str]
    An array of ARNs for Amazon QuickSight users or groups.
    columnNames List<String>
    An array of column names.
    principals List<String>
    An array of ARNs for Amazon QuickSight users or groups.

    DataSetDataSetUsageConfiguration, DataSetDataSetUsageConfigurationArgs

    DisableUseAsDirectQuerySource bool
    Controls whether a child dataset of a direct query can use this dataset as a source.
    DisableUseAsImportedSource bool
    Controls whether a child dataset that's stored in QuickSight can use this dataset as a source.
    DisableUseAsDirectQuerySource bool
    Controls whether a child dataset of a direct query can use this dataset as a source.
    DisableUseAsImportedSource bool
    Controls whether a child dataset that's stored in QuickSight can use this dataset as a source.
    disableUseAsDirectQuerySource Boolean
    Controls whether a child dataset of a direct query can use this dataset as a source.
    disableUseAsImportedSource Boolean
    Controls whether a child dataset that's stored in QuickSight can use this dataset as a source.
    disableUseAsDirectQuerySource boolean
    Controls whether a child dataset of a direct query can use this dataset as a source.
    disableUseAsImportedSource boolean
    Controls whether a child dataset that's stored in QuickSight can use this dataset as a source.
    disable_use_as_direct_query_source bool
    Controls whether a child dataset of a direct query can use this dataset as a source.
    disable_use_as_imported_source bool
    Controls whether a child dataset that's stored in QuickSight can use this dataset as a source.
    disableUseAsDirectQuerySource Boolean
    Controls whether a child dataset of a direct query can use this dataset as a source.
    disableUseAsImportedSource Boolean
    Controls whether a child dataset that's stored in QuickSight can use this dataset as a source.

    DataSetFieldFolder, DataSetFieldFolderArgs

    FieldFoldersId string
    Key of the field folder map.
    Columns List<string>
    An array of column names to add to the folder. A column can only be in one folder.
    Description string
    Field folder description.
    FieldFoldersId string
    Key of the field folder map.
    Columns []string
    An array of column names to add to the folder. A column can only be in one folder.
    Description string
    Field folder description.
    fieldFoldersId String
    Key of the field folder map.
    columns List<String>
    An array of column names to add to the folder. A column can only be in one folder.
    description String
    Field folder description.
    fieldFoldersId string
    Key of the field folder map.
    columns string[]
    An array of column names to add to the folder. A column can only be in one folder.
    description string
    Field folder description.
    field_folders_id str
    Key of the field folder map.
    columns Sequence[str]
    An array of column names to add to the folder. A column can only be in one folder.
    description str
    Field folder description.
    fieldFoldersId String
    Key of the field folder map.
    columns List<String>
    An array of column names to add to the folder. A column can only be in one folder.
    description String
    Field folder description.

    DataSetLogicalTableMap, DataSetLogicalTableMapArgs

    Alias string
    A display name for the logical table.
    LogicalTableMapId string
    Key of the logical table map.
    Source Pulumi.Aws.Quicksight.Inputs.DataSetLogicalTableMapSource
    Source of this logical table. See source.
    DataTransforms List<Pulumi.Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransform>
    Transform operations that act on this logical table. For this structure to be valid, only one of the attributes can be non-null. See data_transforms.
    Alias string
    A display name for the logical table.
    LogicalTableMapId string
    Key of the logical table map.
    Source DataSetLogicalTableMapSource
    Source of this logical table. See source.
    DataTransforms []DataSetLogicalTableMapDataTransform
    Transform operations that act on this logical table. For this structure to be valid, only one of the attributes can be non-null. See data_transforms.
    alias String
    A display name for the logical table.
    logicalTableMapId String
    Key of the logical table map.
    source DataSetLogicalTableMapSource
    Source of this logical table. See source.
    dataTransforms List<DataSetLogicalTableMapDataTransform>
    Transform operations that act on this logical table. For this structure to be valid, only one of the attributes can be non-null. See data_transforms.
    alias string
    A display name for the logical table.
    logicalTableMapId string
    Key of the logical table map.
    source DataSetLogicalTableMapSource
    Source of this logical table. See source.
    dataTransforms DataSetLogicalTableMapDataTransform[]
    Transform operations that act on this logical table. For this structure to be valid, only one of the attributes can be non-null. See data_transforms.
    alias str
    A display name for the logical table.
    logical_table_map_id str
    Key of the logical table map.
    source DataSetLogicalTableMapSource
    Source of this logical table. See source.
    data_transforms Sequence[DataSetLogicalTableMapDataTransform]
    Transform operations that act on this logical table. For this structure to be valid, only one of the attributes can be non-null. See data_transforms.
    alias String
    A display name for the logical table.
    logicalTableMapId String
    Key of the logical table map.
    source Property Map
    Source of this logical table. See source.
    dataTransforms List<Property Map>
    Transform operations that act on this logical table. For this structure to be valid, only one of the attributes can be non-null. See data_transforms.

    DataSetLogicalTableMapDataTransform, DataSetLogicalTableMapDataTransformArgs

    CastColumnTypeOperation Pulumi.Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformCastColumnTypeOperation
    A transform operation that casts a column to a different type. See cast_column_type_operation.
    CreateColumnsOperation Pulumi.Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformCreateColumnsOperation
    An operation that creates calculated columns. Columns created in one such operation form a lexical closure. See create_columns_operation.
    FilterOperation Pulumi.Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformFilterOperation
    An operation that filters rows based on some condition. See filter_operation.
    ProjectOperation Pulumi.Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformProjectOperation
    An operation that projects columns. Operations that come after a projection can only refer to projected columns. See project_operation.
    RenameColumnOperation Pulumi.Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformRenameColumnOperation
    An operation that renames a column. See rename_column_operation.
    TagColumnOperation Pulumi.Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformTagColumnOperation
    An operation that tags a column with additional information. See tag_column_operation.
    UntagColumnOperation Pulumi.Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformUntagColumnOperation
    A transform operation that removes tags associated with a column. See untag_column_operation.
    CastColumnTypeOperation DataSetLogicalTableMapDataTransformCastColumnTypeOperation
    A transform operation that casts a column to a different type. See cast_column_type_operation.
    CreateColumnsOperation DataSetLogicalTableMapDataTransformCreateColumnsOperation
    An operation that creates calculated columns. Columns created in one such operation form a lexical closure. See create_columns_operation.
    FilterOperation DataSetLogicalTableMapDataTransformFilterOperation
    An operation that filters rows based on some condition. See filter_operation.
    ProjectOperation DataSetLogicalTableMapDataTransformProjectOperation
    An operation that projects columns. Operations that come after a projection can only refer to projected columns. See project_operation.
    RenameColumnOperation DataSetLogicalTableMapDataTransformRenameColumnOperation
    An operation that renames a column. See rename_column_operation.
    TagColumnOperation DataSetLogicalTableMapDataTransformTagColumnOperation
    An operation that tags a column with additional information. See tag_column_operation.
    UntagColumnOperation DataSetLogicalTableMapDataTransformUntagColumnOperation
    A transform operation that removes tags associated with a column. See untag_column_operation.
    castColumnTypeOperation DataSetLogicalTableMapDataTransformCastColumnTypeOperation
    A transform operation that casts a column to a different type. See cast_column_type_operation.
    createColumnsOperation DataSetLogicalTableMapDataTransformCreateColumnsOperation
    An operation that creates calculated columns. Columns created in one such operation form a lexical closure. See create_columns_operation.
    filterOperation DataSetLogicalTableMapDataTransformFilterOperation
    An operation that filters rows based on some condition. See filter_operation.
    projectOperation DataSetLogicalTableMapDataTransformProjectOperation
    An operation that projects columns. Operations that come after a projection can only refer to projected columns. See project_operation.
    renameColumnOperation DataSetLogicalTableMapDataTransformRenameColumnOperation
    An operation that renames a column. See rename_column_operation.
    tagColumnOperation DataSetLogicalTableMapDataTransformTagColumnOperation
    An operation that tags a column with additional information. See tag_column_operation.
    untagColumnOperation DataSetLogicalTableMapDataTransformUntagColumnOperation
    A transform operation that removes tags associated with a column. See untag_column_operation.
    castColumnTypeOperation DataSetLogicalTableMapDataTransformCastColumnTypeOperation
    A transform operation that casts a column to a different type. See cast_column_type_operation.
    createColumnsOperation DataSetLogicalTableMapDataTransformCreateColumnsOperation
    An operation that creates calculated columns. Columns created in one such operation form a lexical closure. See create_columns_operation.
    filterOperation DataSetLogicalTableMapDataTransformFilterOperation
    An operation that filters rows based on some condition. See filter_operation.
    projectOperation DataSetLogicalTableMapDataTransformProjectOperation
    An operation that projects columns. Operations that come after a projection can only refer to projected columns. See project_operation.
    renameColumnOperation DataSetLogicalTableMapDataTransformRenameColumnOperation
    An operation that renames a column. See rename_column_operation.
    tagColumnOperation DataSetLogicalTableMapDataTransformTagColumnOperation
    An operation that tags a column with additional information. See tag_column_operation.
    untagColumnOperation DataSetLogicalTableMapDataTransformUntagColumnOperation
    A transform operation that removes tags associated with a column. See untag_column_operation.
    cast_column_type_operation DataSetLogicalTableMapDataTransformCastColumnTypeOperation
    A transform operation that casts a column to a different type. See cast_column_type_operation.
    create_columns_operation DataSetLogicalTableMapDataTransformCreateColumnsOperation
    An operation that creates calculated columns. Columns created in one such operation form a lexical closure. See create_columns_operation.
    filter_operation DataSetLogicalTableMapDataTransformFilterOperation
    An operation that filters rows based on some condition. See filter_operation.
    project_operation DataSetLogicalTableMapDataTransformProjectOperation
    An operation that projects columns. Operations that come after a projection can only refer to projected columns. See project_operation.
    rename_column_operation DataSetLogicalTableMapDataTransformRenameColumnOperation
    An operation that renames a column. See rename_column_operation.
    tag_column_operation DataSetLogicalTableMapDataTransformTagColumnOperation
    An operation that tags a column with additional information. See tag_column_operation.
    untag_column_operation DataSetLogicalTableMapDataTransformUntagColumnOperation
    A transform operation that removes tags associated with a column. See untag_column_operation.
    castColumnTypeOperation Property Map
    A transform operation that casts a column to a different type. See cast_column_type_operation.
    createColumnsOperation Property Map
    An operation that creates calculated columns. Columns created in one such operation form a lexical closure. See create_columns_operation.
    filterOperation Property Map
    An operation that filters rows based on some condition. See filter_operation.
    projectOperation Property Map
    An operation that projects columns. Operations that come after a projection can only refer to projected columns. See project_operation.
    renameColumnOperation Property Map
    An operation that renames a column. See rename_column_operation.
    tagColumnOperation Property Map
    An operation that tags a column with additional information. See tag_column_operation.
    untagColumnOperation Property Map
    A transform operation that removes tags associated with a column. See untag_column_operation.

    DataSetLogicalTableMapDataTransformCastColumnTypeOperation, DataSetLogicalTableMapDataTransformCastColumnTypeOperationArgs

    ColumnName string
    Column name.
    NewColumnType string
    New column data type. Valid values are STRING, INTEGER, DECIMAL, DATETIME.
    Format string
    When casting a column from string to datetime type, you can supply a string in a format supported by Amazon QuickSight to denote the source data format.
    ColumnName string
    Column name.
    NewColumnType string
    New column data type. Valid values are STRING, INTEGER, DECIMAL, DATETIME.
    Format string
    When casting a column from string to datetime type, you can supply a string in a format supported by Amazon QuickSight to denote the source data format.
    columnName String
    Column name.
    newColumnType String
    New column data type. Valid values are STRING, INTEGER, DECIMAL, DATETIME.
    format String
    When casting a column from string to datetime type, you can supply a string in a format supported by Amazon QuickSight to denote the source data format.
    columnName string
    Column name.
    newColumnType string
    New column data type. Valid values are STRING, INTEGER, DECIMAL, DATETIME.
    format string
    When casting a column from string to datetime type, you can supply a string in a format supported by Amazon QuickSight to denote the source data format.
    column_name str
    Column name.
    new_column_type str
    New column data type. Valid values are STRING, INTEGER, DECIMAL, DATETIME.
    format str
    When casting a column from string to datetime type, you can supply a string in a format supported by Amazon QuickSight to denote the source data format.
    columnName String
    Column name.
    newColumnType String
    New column data type. Valid values are STRING, INTEGER, DECIMAL, DATETIME.
    format String
    When casting a column from string to datetime type, you can supply a string in a format supported by Amazon QuickSight to denote the source data format.

    DataSetLogicalTableMapDataTransformCreateColumnsOperation, DataSetLogicalTableMapDataTransformCreateColumnsOperationArgs

    columns List<Property Map>
    Calculated columns to create. See columns.

    DataSetLogicalTableMapDataTransformCreateColumnsOperationColumn, DataSetLogicalTableMapDataTransformCreateColumnsOperationColumnArgs

    ColumnId string
    A unique ID to identify a calculated column. During a dataset update, if the column ID of a calculated column matches that of an existing calculated column, Amazon QuickSight preserves the existing calculated column.
    ColumnName string
    Column name.
    Expression string
    An expression that defines the calculated column.
    ColumnId string
    A unique ID to identify a calculated column. During a dataset update, if the column ID of a calculated column matches that of an existing calculated column, Amazon QuickSight preserves the existing calculated column.
    ColumnName string
    Column name.
    Expression string
    An expression that defines the calculated column.
    columnId String
    A unique ID to identify a calculated column. During a dataset update, if the column ID of a calculated column matches that of an existing calculated column, Amazon QuickSight preserves the existing calculated column.
    columnName String
    Column name.
    expression String
    An expression that defines the calculated column.
    columnId string
    A unique ID to identify a calculated column. During a dataset update, if the column ID of a calculated column matches that of an existing calculated column, Amazon QuickSight preserves the existing calculated column.
    columnName string
    Column name.
    expression string
    An expression that defines the calculated column.
    column_id str
    A unique ID to identify a calculated column. During a dataset update, if the column ID of a calculated column matches that of an existing calculated column, Amazon QuickSight preserves the existing calculated column.
    column_name str
    Column name.
    expression str
    An expression that defines the calculated column.
    columnId String
    A unique ID to identify a calculated column. During a dataset update, if the column ID of a calculated column matches that of an existing calculated column, Amazon QuickSight preserves the existing calculated column.
    columnName String
    Column name.
    expression String
    An expression that defines the calculated column.

    DataSetLogicalTableMapDataTransformFilterOperation, DataSetLogicalTableMapDataTransformFilterOperationArgs

    ConditionExpression string
    An expression that must evaluate to a Boolean value. Rows for which the expression evaluates to true are kept in the dataset.
    ConditionExpression string
    An expression that must evaluate to a Boolean value. Rows for which the expression evaluates to true are kept in the dataset.
    conditionExpression String
    An expression that must evaluate to a Boolean value. Rows for which the expression evaluates to true are kept in the dataset.
    conditionExpression string
    An expression that must evaluate to a Boolean value. Rows for which the expression evaluates to true are kept in the dataset.
    condition_expression str
    An expression that must evaluate to a Boolean value. Rows for which the expression evaluates to true are kept in the dataset.
    conditionExpression String
    An expression that must evaluate to a Boolean value. Rows for which the expression evaluates to true are kept in the dataset.

    DataSetLogicalTableMapDataTransformProjectOperation, DataSetLogicalTableMapDataTransformProjectOperationArgs

    ProjectedColumns List<string>
    Projected columns.
    ProjectedColumns []string
    Projected columns.
    projectedColumns List<String>
    Projected columns.
    projectedColumns string[]
    Projected columns.
    projected_columns Sequence[str]
    Projected columns.
    projectedColumns List<String>
    Projected columns.

    DataSetLogicalTableMapDataTransformRenameColumnOperation, DataSetLogicalTableMapDataTransformRenameColumnOperationArgs

    ColumnName string
    Column to be renamed.
    NewColumnName string
    New name for the column.
    ColumnName string
    Column to be renamed.
    NewColumnName string
    New name for the column.
    columnName String
    Column to be renamed.
    newColumnName String
    New name for the column.
    columnName string
    Column to be renamed.
    newColumnName string
    New name for the column.
    column_name str
    Column to be renamed.
    new_column_name str
    New name for the column.
    columnName String
    Column to be renamed.
    newColumnName String
    New name for the column.

    DataSetLogicalTableMapDataTransformTagColumnOperation, DataSetLogicalTableMapDataTransformTagColumnOperationArgs

    ColumnName string
    Column name.
    Tags List<Pulumi.Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformTagColumnOperationTag>
    The dataset column tag, currently only used for geospatial type tagging. See tags.
    ColumnName string
    Column name.
    Tags []DataSetLogicalTableMapDataTransformTagColumnOperationTag
    The dataset column tag, currently only used for geospatial type tagging. See tags.
    columnName String
    Column name.
    tags List<DataSetLogicalTableMapDataTransformTagColumnOperationTag>
    The dataset column tag, currently only used for geospatial type tagging. See tags.
    columnName string
    Column name.
    tags DataSetLogicalTableMapDataTransformTagColumnOperationTag[]
    The dataset column tag, currently only used for geospatial type tagging. See tags.
    column_name str
    Column name.
    tags Sequence[DataSetLogicalTableMapDataTransformTagColumnOperationTag]
    The dataset column tag, currently only used for geospatial type tagging. See tags.
    columnName String
    Column name.
    tags List<Property Map>
    The dataset column tag, currently only used for geospatial type tagging. See tags.

    DataSetLogicalTableMapDataTransformTagColumnOperationTag, DataSetLogicalTableMapDataTransformTagColumnOperationTagArgs

    ColumnDescription Pulumi.Aws.Quicksight.Inputs.DataSetLogicalTableMapDataTransformTagColumnOperationTagColumnDescription
    A description for a column. See column_description.
    ColumnGeographicRole string
    A geospatial role for a column. Valid values are COUNTRY, STATE, COUNTY, CITY, POSTCODE, LONGITUDE, and LATITUDE.
    ColumnDescription DataSetLogicalTableMapDataTransformTagColumnOperationTagColumnDescription
    A description for a column. See column_description.
    ColumnGeographicRole string
    A geospatial role for a column. Valid values are COUNTRY, STATE, COUNTY, CITY, POSTCODE, LONGITUDE, and LATITUDE.
    columnDescription DataSetLogicalTableMapDataTransformTagColumnOperationTagColumnDescription
    A description for a column. See column_description.
    columnGeographicRole String
    A geospatial role for a column. Valid values are COUNTRY, STATE, COUNTY, CITY, POSTCODE, LONGITUDE, and LATITUDE.
    columnDescription DataSetLogicalTableMapDataTransformTagColumnOperationTagColumnDescription
    A description for a column. See column_description.
    columnGeographicRole string
    A geospatial role for a column. Valid values are COUNTRY, STATE, COUNTY, CITY, POSTCODE, LONGITUDE, and LATITUDE.
    column_description DataSetLogicalTableMapDataTransformTagColumnOperationTagColumnDescription
    A description for a column. See column_description.
    column_geographic_role str
    A geospatial role for a column. Valid values are COUNTRY, STATE, COUNTY, CITY, POSTCODE, LONGITUDE, and LATITUDE.
    columnDescription Property Map
    A description for a column. See column_description.
    columnGeographicRole String
    A geospatial role for a column. Valid values are COUNTRY, STATE, COUNTY, CITY, POSTCODE, LONGITUDE, and LATITUDE.

    DataSetLogicalTableMapDataTransformTagColumnOperationTagColumnDescription, DataSetLogicalTableMapDataTransformTagColumnOperationTagColumnDescriptionArgs

    Text string
    The text of a description for a column.
    Text string
    The text of a description for a column.
    text String
    The text of a description for a column.
    text string
    The text of a description for a column.
    text str
    The text of a description for a column.
    text String
    The text of a description for a column.

    DataSetLogicalTableMapDataTransformUntagColumnOperation, DataSetLogicalTableMapDataTransformUntagColumnOperationArgs

    ColumnName string
    Column name.
    TagNames List<string>
    The column tags to remove from this column.
    ColumnName string
    Column name.
    TagNames []string
    The column tags to remove from this column.
    columnName String
    Column name.
    tagNames List<String>
    The column tags to remove from this column.
    columnName string
    Column name.
    tagNames string[]
    The column tags to remove from this column.
    column_name str
    Column name.
    tag_names Sequence[str]
    The column tags to remove from this column.
    columnName String
    Column name.
    tagNames List<String>
    The column tags to remove from this column.

    DataSetLogicalTableMapSource, DataSetLogicalTableMapSourceArgs

    DataSetArn string
    ARN of the parent data set.
    JoinInstruction Pulumi.Aws.Quicksight.Inputs.DataSetLogicalTableMapSourceJoinInstruction
    Specifies the result of a join of two logical tables. See join_instruction.
    PhysicalTableId string
    Physical table ID.
    DataSetArn string
    ARN of the parent data set.
    JoinInstruction DataSetLogicalTableMapSourceJoinInstruction
    Specifies the result of a join of two logical tables. See join_instruction.
    PhysicalTableId string
    Physical table ID.
    dataSetArn String
    ARN of the parent data set.
    joinInstruction DataSetLogicalTableMapSourceJoinInstruction
    Specifies the result of a join of two logical tables. See join_instruction.
    physicalTableId String
    Physical table ID.
    dataSetArn string
    ARN of the parent data set.
    joinInstruction DataSetLogicalTableMapSourceJoinInstruction
    Specifies the result of a join of two logical tables. See join_instruction.
    physicalTableId string
    Physical table ID.
    data_set_arn str
    ARN of the parent data set.
    join_instruction DataSetLogicalTableMapSourceJoinInstruction
    Specifies the result of a join of two logical tables. See join_instruction.
    physical_table_id str
    Physical table ID.
    dataSetArn String
    ARN of the parent data set.
    joinInstruction Property Map
    Specifies the result of a join of two logical tables. See join_instruction.
    physicalTableId String
    Physical table ID.

    DataSetLogicalTableMapSourceJoinInstruction, DataSetLogicalTableMapSourceJoinInstructionArgs

    LeftOperand string
    Operand on the left side of a join.
    OnClause string
    Join instructions provided in the ON clause of a join.
    RightOperand string
    Operand on the right side of a join.
    Type string
    Type of join. Valid values are INNER, OUTER, LEFT, and RIGHT.
    LeftJoinKeyProperties Pulumi.Aws.Quicksight.Inputs.DataSetLogicalTableMapSourceJoinInstructionLeftJoinKeyProperties
    Join key properties of the left operand. See left_join_key_properties.
    RightJoinKeyProperties Pulumi.Aws.Quicksight.Inputs.DataSetLogicalTableMapSourceJoinInstructionRightJoinKeyProperties
    Join key properties of the right operand. See right_join_key_properties.
    LeftOperand string
    Operand on the left side of a join.
    OnClause string
    Join instructions provided in the ON clause of a join.
    RightOperand string
    Operand on the right side of a join.
    Type string
    Type of join. Valid values are INNER, OUTER, LEFT, and RIGHT.
    LeftJoinKeyProperties DataSetLogicalTableMapSourceJoinInstructionLeftJoinKeyProperties
    Join key properties of the left operand. See left_join_key_properties.
    RightJoinKeyProperties DataSetLogicalTableMapSourceJoinInstructionRightJoinKeyProperties
    Join key properties of the right operand. See right_join_key_properties.
    leftOperand String
    Operand on the left side of a join.
    onClause String
    Join instructions provided in the ON clause of a join.
    rightOperand String
    Operand on the right side of a join.
    type String
    Type of join. Valid values are INNER, OUTER, LEFT, and RIGHT.
    leftJoinKeyProperties DataSetLogicalTableMapSourceJoinInstructionLeftJoinKeyProperties
    Join key properties of the left operand. See left_join_key_properties.
    rightJoinKeyProperties DataSetLogicalTableMapSourceJoinInstructionRightJoinKeyProperties
    Join key properties of the right operand. See right_join_key_properties.
    leftOperand string
    Operand on the left side of a join.
    onClause string
    Join instructions provided in the ON clause of a join.
    rightOperand string
    Operand on the right side of a join.
    type string
    Type of join. Valid values are INNER, OUTER, LEFT, and RIGHT.
    leftJoinKeyProperties DataSetLogicalTableMapSourceJoinInstructionLeftJoinKeyProperties
    Join key properties of the left operand. See left_join_key_properties.
    rightJoinKeyProperties DataSetLogicalTableMapSourceJoinInstructionRightJoinKeyProperties
    Join key properties of the right operand. See right_join_key_properties.
    left_operand str
    Operand on the left side of a join.
    on_clause str
    Join instructions provided in the ON clause of a join.
    right_operand str
    Operand on the right side of a join.
    type str
    Type of join. Valid values are INNER, OUTER, LEFT, and RIGHT.
    left_join_key_properties DataSetLogicalTableMapSourceJoinInstructionLeftJoinKeyProperties
    Join key properties of the left operand. See left_join_key_properties.
    right_join_key_properties DataSetLogicalTableMapSourceJoinInstructionRightJoinKeyProperties
    Join key properties of the right operand. See right_join_key_properties.
    leftOperand String
    Operand on the left side of a join.
    onClause String
    Join instructions provided in the ON clause of a join.
    rightOperand String
    Operand on the right side of a join.
    type String
    Type of join. Valid values are INNER, OUTER, LEFT, and RIGHT.
    leftJoinKeyProperties Property Map
    Join key properties of the left operand. See left_join_key_properties.
    rightJoinKeyProperties Property Map
    Join key properties of the right operand. See right_join_key_properties.

    DataSetLogicalTableMapSourceJoinInstructionLeftJoinKeyProperties, DataSetLogicalTableMapSourceJoinInstructionLeftJoinKeyPropertiesArgs

    UniqueKey bool
    A value that indicates that a row in a table is uniquely identified by the columns in a join key. This is used by Amazon QuickSight to optimize query performance.
    UniqueKey bool
    A value that indicates that a row in a table is uniquely identified by the columns in a join key. This is used by Amazon QuickSight to optimize query performance.
    uniqueKey Boolean
    A value that indicates that a row in a table is uniquely identified by the columns in a join key. This is used by Amazon QuickSight to optimize query performance.
    uniqueKey boolean
    A value that indicates that a row in a table is uniquely identified by the columns in a join key. This is used by Amazon QuickSight to optimize query performance.
    unique_key bool
    A value that indicates that a row in a table is uniquely identified by the columns in a join key. This is used by Amazon QuickSight to optimize query performance.
    uniqueKey Boolean
    A value that indicates that a row in a table is uniquely identified by the columns in a join key. This is used by Amazon QuickSight to optimize query performance.

    DataSetLogicalTableMapSourceJoinInstructionRightJoinKeyProperties, DataSetLogicalTableMapSourceJoinInstructionRightJoinKeyPropertiesArgs

    UniqueKey bool
    A value that indicates that a row in a table is uniquely identified by the columns in a join key. This is used by Amazon QuickSight to optimize query performance.
    UniqueKey bool
    A value that indicates that a row in a table is uniquely identified by the columns in a join key. This is used by Amazon QuickSight to optimize query performance.
    uniqueKey Boolean
    A value that indicates that a row in a table is uniquely identified by the columns in a join key. This is used by Amazon QuickSight to optimize query performance.
    uniqueKey boolean
    A value that indicates that a row in a table is uniquely identified by the columns in a join key. This is used by Amazon QuickSight to optimize query performance.
    unique_key bool
    A value that indicates that a row in a table is uniquely identified by the columns in a join key. This is used by Amazon QuickSight to optimize query performance.
    uniqueKey Boolean
    A value that indicates that a row in a table is uniquely identified by the columns in a join key. This is used by Amazon QuickSight to optimize query performance.

    DataSetOutputColumn, DataSetOutputColumnArgs

    Description string
    Name string
    Display name for the dataset.
    Type string
    Description string
    Name string
    Display name for the dataset.
    Type string
    description String
    name String
    Display name for the dataset.
    type String
    description string
    name string
    Display name for the dataset.
    type string
    description str
    name str
    Display name for the dataset.
    type str
    description String
    name String
    Display name for the dataset.
    type String

    DataSetPermission, DataSetPermissionArgs

    Actions List<string>
    List of IAM actions to grant or revoke permissions on.
    Principal string
    ARN of the principal. See the ResourcePermission documentation for the applicable ARN values.
    Actions []string
    List of IAM actions to grant or revoke permissions on.
    Principal string
    ARN of the principal. See the ResourcePermission documentation for the applicable ARN values.
    actions List<String>
    List of IAM actions to grant or revoke permissions on.
    principal String
    ARN of the principal. See the ResourcePermission documentation for the applicable ARN values.
    actions string[]
    List of IAM actions to grant or revoke permissions on.
    principal string
    ARN of the principal. See the ResourcePermission documentation for the applicable ARN values.
    actions Sequence[str]
    List of IAM actions to grant or revoke permissions on.
    principal str
    ARN of the principal. See the ResourcePermission documentation for the applicable ARN values.
    actions List<String>
    List of IAM actions to grant or revoke permissions on.
    principal String
    ARN of the principal. See the ResourcePermission documentation for the applicable ARN values.

    DataSetPhysicalTableMap, DataSetPhysicalTableMapArgs

    PhysicalTableMapId string
    Key of the physical table map.
    CustomSql Pulumi.Aws.Quicksight.Inputs.DataSetPhysicalTableMapCustomSql
    A physical table type built from the results of the custom SQL query. See custom_sql.
    RelationalTable Pulumi.Aws.Quicksight.Inputs.DataSetPhysicalTableMapRelationalTable
    A physical table type for relational data sources. See relational_table.
    S3Source Pulumi.Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3Source
    A physical table type for as S3 data source. See s3_source.
    PhysicalTableMapId string
    Key of the physical table map.
    CustomSql DataSetPhysicalTableMapCustomSql
    A physical table type built from the results of the custom SQL query. See custom_sql.
    RelationalTable DataSetPhysicalTableMapRelationalTable
    A physical table type for relational data sources. See relational_table.
    S3Source DataSetPhysicalTableMapS3Source
    A physical table type for as S3 data source. See s3_source.
    physicalTableMapId String
    Key of the physical table map.
    customSql DataSetPhysicalTableMapCustomSql
    A physical table type built from the results of the custom SQL query. See custom_sql.
    relationalTable DataSetPhysicalTableMapRelationalTable
    A physical table type for relational data sources. See relational_table.
    s3Source DataSetPhysicalTableMapS3Source
    A physical table type for as S3 data source. See s3_source.
    physicalTableMapId string
    Key of the physical table map.
    customSql DataSetPhysicalTableMapCustomSql
    A physical table type built from the results of the custom SQL query. See custom_sql.
    relationalTable DataSetPhysicalTableMapRelationalTable
    A physical table type for relational data sources. See relational_table.
    s3Source DataSetPhysicalTableMapS3Source
    A physical table type for as S3 data source. See s3_source.
    physical_table_map_id str
    Key of the physical table map.
    custom_sql DataSetPhysicalTableMapCustomSql
    A physical table type built from the results of the custom SQL query. See custom_sql.
    relational_table DataSetPhysicalTableMapRelationalTable
    A physical table type for relational data sources. See relational_table.
    s3_source DataSetPhysicalTableMapS3Source
    A physical table type for as S3 data source. See s3_source.
    physicalTableMapId String
    Key of the physical table map.
    customSql Property Map
    A physical table type built from the results of the custom SQL query. See custom_sql.
    relationalTable Property Map
    A physical table type for relational data sources. See relational_table.
    s3Source Property Map
    A physical table type for as S3 data source. See s3_source.

    DataSetPhysicalTableMapCustomSql, DataSetPhysicalTableMapCustomSqlArgs

    DataSourceArn string
    ARN of the data source.
    Name string
    Display name for the SQL query result.
    SqlQuery string
    SQL query.
    Columns List<Pulumi.Aws.Quicksight.Inputs.DataSetPhysicalTableMapCustomSqlColumn>
    Column schema from the SQL query result set. See columns.
    DataSourceArn string
    ARN of the data source.
    Name string
    Display name for the SQL query result.
    SqlQuery string
    SQL query.
    Columns []DataSetPhysicalTableMapCustomSqlColumn
    Column schema from the SQL query result set. See columns.
    dataSourceArn String
    ARN of the data source.
    name String
    Display name for the SQL query result.
    sqlQuery String
    SQL query.
    columns List<DataSetPhysicalTableMapCustomSqlColumn>
    Column schema from the SQL query result set. See columns.
    dataSourceArn string
    ARN of the data source.
    name string
    Display name for the SQL query result.
    sqlQuery string
    SQL query.
    columns DataSetPhysicalTableMapCustomSqlColumn[]
    Column schema from the SQL query result set. See columns.
    data_source_arn str
    ARN of the data source.
    name str
    Display name for the SQL query result.
    sql_query str
    SQL query.
    columns Sequence[DataSetPhysicalTableMapCustomSqlColumn]
    Column schema from the SQL query result set. See columns.
    dataSourceArn String
    ARN of the data source.
    name String
    Display name for the SQL query result.
    sqlQuery String
    SQL query.
    columns List<Property Map>
    Column schema from the SQL query result set. See columns.

    DataSetPhysicalTableMapCustomSqlColumn, DataSetPhysicalTableMapCustomSqlColumnArgs

    Name string
    Name of this column in the underlying data source.
    Type string
    Data type of the column.
    Name string
    Name of this column in the underlying data source.
    Type string
    Data type of the column.
    name String
    Name of this column in the underlying data source.
    type String
    Data type of the column.
    name string
    Name of this column in the underlying data source.
    type string
    Data type of the column.
    name str
    Name of this column in the underlying data source.
    type str
    Data type of the column.
    name String
    Name of this column in the underlying data source.
    type String
    Data type of the column.

    DataSetPhysicalTableMapRelationalTable, DataSetPhysicalTableMapRelationalTableArgs

    DataSourceArn string
    ARN of the data source.
    InputColumns List<Pulumi.Aws.Quicksight.Inputs.DataSetPhysicalTableMapRelationalTableInputColumn>
    Column schema of the table. See input_columns.
    Name string
    Name of the relational table.
    Catalog string
    Catalog associated with the table.
    Schema string
    Schema name. This name applies to certain relational database engines.
    DataSourceArn string
    ARN of the data source.
    InputColumns []DataSetPhysicalTableMapRelationalTableInputColumn
    Column schema of the table. See input_columns.
    Name string
    Name of the relational table.
    Catalog string
    Catalog associated with the table.
    Schema string
    Schema name. This name applies to certain relational database engines.
    dataSourceArn String
    ARN of the data source.
    inputColumns List<DataSetPhysicalTableMapRelationalTableInputColumn>
    Column schema of the table. See input_columns.
    name String
    Name of the relational table.
    catalog String
    Catalog associated with the table.
    schema String
    Schema name. This name applies to certain relational database engines.
    dataSourceArn string
    ARN of the data source.
    inputColumns DataSetPhysicalTableMapRelationalTableInputColumn[]
    Column schema of the table. See input_columns.
    name string
    Name of the relational table.
    catalog string
    Catalog associated with the table.
    schema string
    Schema name. This name applies to certain relational database engines.
    data_source_arn str
    ARN of the data source.
    input_columns Sequence[DataSetPhysicalTableMapRelationalTableInputColumn]
    Column schema of the table. See input_columns.
    name str
    Name of the relational table.
    catalog str
    Catalog associated with the table.
    schema str
    Schema name. This name applies to certain relational database engines.
    dataSourceArn String
    ARN of the data source.
    inputColumns List<Property Map>
    Column schema of the table. See input_columns.
    name String
    Name of the relational table.
    catalog String
    Catalog associated with the table.
    schema String
    Schema name. This name applies to certain relational database engines.

    DataSetPhysicalTableMapRelationalTableInputColumn, DataSetPhysicalTableMapRelationalTableInputColumnArgs

    Name string
    Name of this column in the underlying data source.
    Type string
    Data type of the column.
    Name string
    Name of this column in the underlying data source.
    Type string
    Data type of the column.
    name String
    Name of this column in the underlying data source.
    type String
    Data type of the column.
    name string
    Name of this column in the underlying data source.
    type string
    Data type of the column.
    name str
    Name of this column in the underlying data source.
    type str
    Data type of the column.
    name String
    Name of this column in the underlying data source.
    type String
    Data type of the column.

    DataSetPhysicalTableMapS3Source, DataSetPhysicalTableMapS3SourceArgs

    DataSourceArn string
    ARN of the data source.
    InputColumns List<Pulumi.Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceInputColumn>
    Column schema of the table. See input_columns.
    UploadSettings Pulumi.Aws.Quicksight.Inputs.DataSetPhysicalTableMapS3SourceUploadSettings
    Information about the format for the S3 source file or files. See upload_settings.
    DataSourceArn string
    ARN of the data source.
    InputColumns []DataSetPhysicalTableMapS3SourceInputColumn
    Column schema of the table. See input_columns.
    UploadSettings DataSetPhysicalTableMapS3SourceUploadSettings
    Information about the format for the S3 source file or files. See upload_settings.
    dataSourceArn String
    ARN of the data source.
    inputColumns List<DataSetPhysicalTableMapS3SourceInputColumn>
    Column schema of the table. See input_columns.
    uploadSettings DataSetPhysicalTableMapS3SourceUploadSettings
    Information about the format for the S3 source file or files. See upload_settings.
    dataSourceArn string
    ARN of the data source.
    inputColumns DataSetPhysicalTableMapS3SourceInputColumn[]
    Column schema of the table. See input_columns.
    uploadSettings DataSetPhysicalTableMapS3SourceUploadSettings
    Information about the format for the S3 source file or files. See upload_settings.
    data_source_arn str
    ARN of the data source.
    input_columns Sequence[DataSetPhysicalTableMapS3SourceInputColumn]
    Column schema of the table. See input_columns.
    upload_settings DataSetPhysicalTableMapS3SourceUploadSettings
    Information about the format for the S3 source file or files. See upload_settings.
    dataSourceArn String
    ARN of the data source.
    inputColumns List<Property Map>
    Column schema of the table. See input_columns.
    uploadSettings Property Map
    Information about the format for the S3 source file or files. See upload_settings.

    DataSetPhysicalTableMapS3SourceInputColumn, DataSetPhysicalTableMapS3SourceInputColumnArgs

    Name string
    Name of this column in the underlying data source.
    Type string
    Data type of the column.
    Name string
    Name of this column in the underlying data source.
    Type string
    Data type of the column.
    name String
    Name of this column in the underlying data source.
    type String
    Data type of the column.
    name string
    Name of this column in the underlying data source.
    type string
    Data type of the column.
    name str
    Name of this column in the underlying data source.
    type str
    Data type of the column.
    name String
    Name of this column in the underlying data source.
    type String
    Data type of the column.

    DataSetPhysicalTableMapS3SourceUploadSettings, DataSetPhysicalTableMapS3SourceUploadSettingsArgs

    ContainsHeader bool
    Whether the file has a header row, or the files each have a header row.
    Delimiter string
    Delimiter between values in the file.
    Format string
    File format. Valid values are CSV, TSV, CLF, ELF, XLSX, and JSON.
    StartFromRow int
    A row number to start reading data from.
    TextQualifier string
    Text qualifier. Valid values are DOUBLE_QUOTE and SINGLE_QUOTE.
    ContainsHeader bool
    Whether the file has a header row, or the files each have a header row.
    Delimiter string
    Delimiter between values in the file.
    Format string
    File format. Valid values are CSV, TSV, CLF, ELF, XLSX, and JSON.
    StartFromRow int
    A row number to start reading data from.
    TextQualifier string
    Text qualifier. Valid values are DOUBLE_QUOTE and SINGLE_QUOTE.
    containsHeader Boolean
    Whether the file has a header row, or the files each have a header row.
    delimiter String
    Delimiter between values in the file.
    format String
    File format. Valid values are CSV, TSV, CLF, ELF, XLSX, and JSON.
    startFromRow Integer
    A row number to start reading data from.
    textQualifier String
    Text qualifier. Valid values are DOUBLE_QUOTE and SINGLE_QUOTE.
    containsHeader boolean
    Whether the file has a header row, or the files each have a header row.
    delimiter string
    Delimiter between values in the file.
    format string
    File format. Valid values are CSV, TSV, CLF, ELF, XLSX, and JSON.
    startFromRow number
    A row number to start reading data from.
    textQualifier string
    Text qualifier. Valid values are DOUBLE_QUOTE and SINGLE_QUOTE.
    contains_header bool
    Whether the file has a header row, or the files each have a header row.
    delimiter str
    Delimiter between values in the file.
    format str
    File format. Valid values are CSV, TSV, CLF, ELF, XLSX, and JSON.
    start_from_row int
    A row number to start reading data from.
    text_qualifier str
    Text qualifier. Valid values are DOUBLE_QUOTE and SINGLE_QUOTE.
    containsHeader Boolean
    Whether the file has a header row, or the files each have a header row.
    delimiter String
    Delimiter between values in the file.
    format String
    File format. Valid values are CSV, TSV, CLF, ELF, XLSX, and JSON.
    startFromRow Number
    A row number to start reading data from.
    textQualifier String
    Text qualifier. Valid values are DOUBLE_QUOTE and SINGLE_QUOTE.

    DataSetRefreshProperties, DataSetRefreshPropertiesArgs

    RefreshConfiguration Pulumi.Aws.Quicksight.Inputs.DataSetRefreshPropertiesRefreshConfiguration
    The refresh configuration for the data set. See refresh_configuration.
    RefreshConfiguration DataSetRefreshPropertiesRefreshConfiguration
    The refresh configuration for the data set. See refresh_configuration.
    refreshConfiguration DataSetRefreshPropertiesRefreshConfiguration
    The refresh configuration for the data set. See refresh_configuration.
    refreshConfiguration DataSetRefreshPropertiesRefreshConfiguration
    The refresh configuration for the data set. See refresh_configuration.
    refresh_configuration DataSetRefreshPropertiesRefreshConfiguration
    The refresh configuration for the data set. See refresh_configuration.
    refreshConfiguration Property Map
    The refresh configuration for the data set. See refresh_configuration.

    DataSetRefreshPropertiesRefreshConfiguration, DataSetRefreshPropertiesRefreshConfigurationArgs

    IncrementalRefresh DataSetRefreshPropertiesRefreshConfigurationIncrementalRefresh
    The incremental refresh for the data set. See incremental_refresh.
    incrementalRefresh DataSetRefreshPropertiesRefreshConfigurationIncrementalRefresh
    The incremental refresh for the data set. See incremental_refresh.
    incrementalRefresh DataSetRefreshPropertiesRefreshConfigurationIncrementalRefresh
    The incremental refresh for the data set. See incremental_refresh.
    incremental_refresh DataSetRefreshPropertiesRefreshConfigurationIncrementalRefresh
    The incremental refresh for the data set. See incremental_refresh.
    incrementalRefresh Property Map
    The incremental refresh for the data set. See incremental_refresh.

    DataSetRefreshPropertiesRefreshConfigurationIncrementalRefresh, DataSetRefreshPropertiesRefreshConfigurationIncrementalRefreshArgs

    LookbackWindow Pulumi.Aws.Quicksight.Inputs.DataSetRefreshPropertiesRefreshConfigurationIncrementalRefreshLookbackWindow
    The lookback window setup for an incremental refresh configuration. See lookback_window.
    LookbackWindow DataSetRefreshPropertiesRefreshConfigurationIncrementalRefreshLookbackWindow
    The lookback window setup for an incremental refresh configuration. See lookback_window.
    lookbackWindow DataSetRefreshPropertiesRefreshConfigurationIncrementalRefreshLookbackWindow
    The lookback window setup for an incremental refresh configuration. See lookback_window.
    lookbackWindow DataSetRefreshPropertiesRefreshConfigurationIncrementalRefreshLookbackWindow
    The lookback window setup for an incremental refresh configuration. See lookback_window.
    lookback_window DataSetRefreshPropertiesRefreshConfigurationIncrementalRefreshLookbackWindow
    The lookback window setup for an incremental refresh configuration. See lookback_window.
    lookbackWindow Property Map
    The lookback window setup for an incremental refresh configuration. See lookback_window.

    DataSetRefreshPropertiesRefreshConfigurationIncrementalRefreshLookbackWindow, DataSetRefreshPropertiesRefreshConfigurationIncrementalRefreshLookbackWindowArgs

    ColumnName string
    The name of the lookback window column.
    Size int
    The lookback window column size.
    SizeUnit string
    The size unit that is used for the lookback window column. Valid values for this structure are HOUR, DAY, and WEEK.
    ColumnName string
    The name of the lookback window column.
    Size int
    The lookback window column size.
    SizeUnit string
    The size unit that is used for the lookback window column. Valid values for this structure are HOUR, DAY, and WEEK.
    columnName String
    The name of the lookback window column.
    size Integer
    The lookback window column size.
    sizeUnit String
    The size unit that is used for the lookback window column. Valid values for this structure are HOUR, DAY, and WEEK.
    columnName string
    The name of the lookback window column.
    size number
    The lookback window column size.
    sizeUnit string
    The size unit that is used for the lookback window column. Valid values for this structure are HOUR, DAY, and WEEK.
    column_name str
    The name of the lookback window column.
    size int
    The lookback window column size.
    size_unit str
    The size unit that is used for the lookback window column. Valid values for this structure are HOUR, DAY, and WEEK.
    columnName String
    The name of the lookback window column.
    size Number
    The lookback window column size.
    sizeUnit String
    The size unit that is used for the lookback window column. Valid values for this structure are HOUR, DAY, and WEEK.

    DataSetRowLevelPermissionDataSet, DataSetRowLevelPermissionDataSetArgs

    Arn string
    ARN of the dataset that contains permissions for RLS.
    PermissionPolicy string
    Type of permissions to use when interpreting the permissions for RLS. Valid values are GRANT_ACCESS and DENY_ACCESS.
    FormatVersion string
    User or group rules associated with the dataset that contains permissions for RLS.
    Namespace string
    Namespace associated with the dataset that contains permissions for RLS.
    Status string
    Status of the row-level security permission dataset. If enabled, the status is ENABLED. If disabled, the status is DISABLED.
    Arn string
    ARN of the dataset that contains permissions for RLS.
    PermissionPolicy string
    Type of permissions to use when interpreting the permissions for RLS. Valid values are GRANT_ACCESS and DENY_ACCESS.
    FormatVersion string
    User or group rules associated with the dataset that contains permissions for RLS.
    Namespace string
    Namespace associated with the dataset that contains permissions for RLS.
    Status string
    Status of the row-level security permission dataset. If enabled, the status is ENABLED. If disabled, the status is DISABLED.
    arn String
    ARN of the dataset that contains permissions for RLS.
    permissionPolicy String
    Type of permissions to use when interpreting the permissions for RLS. Valid values are GRANT_ACCESS and DENY_ACCESS.
    formatVersion String
    User or group rules associated with the dataset that contains permissions for RLS.
    namespace String
    Namespace associated with the dataset that contains permissions for RLS.
    status String
    Status of the row-level security permission dataset. If enabled, the status is ENABLED. If disabled, the status is DISABLED.
    arn string
    ARN of the dataset that contains permissions for RLS.
    permissionPolicy string
    Type of permissions to use when interpreting the permissions for RLS. Valid values are GRANT_ACCESS and DENY_ACCESS.
    formatVersion string
    User or group rules associated with the dataset that contains permissions for RLS.
    namespace string
    Namespace associated with the dataset that contains permissions for RLS.
    status string
    Status of the row-level security permission dataset. If enabled, the status is ENABLED. If disabled, the status is DISABLED.
    arn str
    ARN of the dataset that contains permissions for RLS.
    permission_policy str
    Type of permissions to use when interpreting the permissions for RLS. Valid values are GRANT_ACCESS and DENY_ACCESS.
    format_version str
    User or group rules associated with the dataset that contains permissions for RLS.
    namespace str
    Namespace associated with the dataset that contains permissions for RLS.
    status str
    Status of the row-level security permission dataset. If enabled, the status is ENABLED. If disabled, the status is DISABLED.
    arn String
    ARN of the dataset that contains permissions for RLS.
    permissionPolicy String
    Type of permissions to use when interpreting the permissions for RLS. Valid values are GRANT_ACCESS and DENY_ACCESS.
    formatVersion String
    User or group rules associated with the dataset that contains permissions for RLS.
    namespace String
    Namespace associated with the dataset that contains permissions for RLS.
    status String
    Status of the row-level security permission dataset. If enabled, the status is ENABLED. If disabled, the status is DISABLED.

    DataSetRowLevelPermissionTagConfiguration, DataSetRowLevelPermissionTagConfigurationArgs

    TagRules List<Pulumi.Aws.Quicksight.Inputs.DataSetRowLevelPermissionTagConfigurationTagRule>
    A set of rules associated with row-level security, such as the tag names and columns that they are assigned to. See tag_rules.
    Status string
    The status of row-level security tags. If enabled, the status is ENABLED. If disabled, the status is DISABLED.
    TagRules []DataSetRowLevelPermissionTagConfigurationTagRule
    A set of rules associated with row-level security, such as the tag names and columns that they are assigned to. See tag_rules.
    Status string
    The status of row-level security tags. If enabled, the status is ENABLED. If disabled, the status is DISABLED.
    tagRules List<DataSetRowLevelPermissionTagConfigurationTagRule>
    A set of rules associated with row-level security, such as the tag names and columns that they are assigned to. See tag_rules.
    status String
    The status of row-level security tags. If enabled, the status is ENABLED. If disabled, the status is DISABLED.
    tagRules DataSetRowLevelPermissionTagConfigurationTagRule[]
    A set of rules associated with row-level security, such as the tag names and columns that they are assigned to. See tag_rules.
    status string
    The status of row-level security tags. If enabled, the status is ENABLED. If disabled, the status is DISABLED.
    tag_rules Sequence[DataSetRowLevelPermissionTagConfigurationTagRule]
    A set of rules associated with row-level security, such as the tag names and columns that they are assigned to. See tag_rules.
    status str
    The status of row-level security tags. If enabled, the status is ENABLED. If disabled, the status is DISABLED.
    tagRules List<Property Map>
    A set of rules associated with row-level security, such as the tag names and columns that they are assigned to. See tag_rules.
    status String
    The status of row-level security tags. If enabled, the status is ENABLED. If disabled, the status is DISABLED.

    DataSetRowLevelPermissionTagConfigurationTagRule, DataSetRowLevelPermissionTagConfigurationTagRuleArgs

    ColumnName string
    Column name that a tag key is assigned to.
    TagKey string
    Unique key for a tag.
    MatchAllValue string
    A string that you want to use to filter by all the values in a column in the dataset and don’t want to list the values one by one.
    TagMultiValueDelimiter string
    A string that you want to use to delimit the values when you pass the values at run time.
    ColumnName string
    Column name that a tag key is assigned to.
    TagKey string
    Unique key for a tag.
    MatchAllValue string
    A string that you want to use to filter by all the values in a column in the dataset and don’t want to list the values one by one.
    TagMultiValueDelimiter string
    A string that you want to use to delimit the values when you pass the values at run time.
    columnName String
    Column name that a tag key is assigned to.
    tagKey String
    Unique key for a tag.
    matchAllValue String
    A string that you want to use to filter by all the values in a column in the dataset and don’t want to list the values one by one.
    tagMultiValueDelimiter String
    A string that you want to use to delimit the values when you pass the values at run time.
    columnName string
    Column name that a tag key is assigned to.
    tagKey string
    Unique key for a tag.
    matchAllValue string
    A string that you want to use to filter by all the values in a column in the dataset and don’t want to list the values one by one.
    tagMultiValueDelimiter string
    A string that you want to use to delimit the values when you pass the values at run time.
    column_name str
    Column name that a tag key is assigned to.
    tag_key str
    Unique key for a tag.
    match_all_value str
    A string that you want to use to filter by all the values in a column in the dataset and don’t want to list the values one by one.
    tag_multi_value_delimiter str
    A string that you want to use to delimit the values when you pass the values at run time.
    columnName String
    Column name that a tag key is assigned to.
    tagKey String
    Unique key for a tag.
    matchAllValue String
    A string that you want to use to filter by all the values in a column in the dataset and don’t want to list the values one by one.
    tagMultiValueDelimiter String
    A string that you want to use to delimit the values when you pass the values at run time.

    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
    

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    AWS Classic pulumi/pulumi-aws
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the aws Terraform Provider.
    aws logo

    Try AWS Native preview for resources not in the classic version.

    AWS Classic v6.41.0 published on Tuesday, Jun 18, 2024 by Pulumi