aws-cdk-lib.aws_quicksight.CfnDataSetProps

interface CfnDataSetProps

LanguageType name
.NETAmazon.CDK.AWS.QuickSight.CfnDataSetProps
Gogithub.com/aws/aws-cdk-go/awscdk/v2/awsquicksight#CfnDataSetProps
Javasoftware.amazon.awscdk.services.quicksight.CfnDataSetProps
Pythonaws_cdk.aws_quicksight.CfnDataSetProps
TypeScript aws-cdk-lib » aws_quicksight » CfnDataSetProps

Properties for defining a CfnDataSet.

Example

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import { aws_quicksight as quicksight } from 'aws-cdk-lib';

declare const tagRuleConfigurations: any;
const cfnDataSetProps: quicksight.CfnDataSetProps = {
  awsAccountId: 'awsAccountId',
  columnGroups: [{
    geoSpatialColumnGroup: {
      columns: ['columns'],
      name: 'name',

      // the properties below are optional
      countryCode: 'countryCode',
    },
  }],
  columnLevelPermissionRules: [{
    columnNames: ['columnNames'],
    principals: ['principals'],
  }],
  dataSetId: 'dataSetId',
  datasetParameters: [{
    dateTimeDatasetParameter: {
      id: 'id',
      name: 'name',
      valueType: 'valueType',

      // the properties below are optional
      defaultValues: {
        staticValues: ['staticValues'],
      },
      timeGranularity: 'timeGranularity',
    },
    decimalDatasetParameter: {
      id: 'id',
      name: 'name',
      valueType: 'valueType',

      // the properties below are optional
      defaultValues: {
        staticValues: [123],
      },
    },
    integerDatasetParameter: {
      id: 'id',
      name: 'name',
      valueType: 'valueType',

      // the properties below are optional
      defaultValues: {
        staticValues: [123],
      },
    },
    stringDatasetParameter: {
      id: 'id',
      name: 'name',
      valueType: 'valueType',

      // the properties below are optional
      defaultValues: {
        staticValues: ['staticValues'],
      },
    },
  }],
  dataSetRefreshProperties: {
    refreshConfiguration: {
      incrementalRefresh: {
        lookbackWindow: {
          columnName: 'columnName',
          size: 123,
          sizeUnit: 'sizeUnit',
        },
      },
    },
  },
  dataSetUsageConfiguration: {
    disableUseAsDirectQuerySource: false,
    disableUseAsImportedSource: false,
  },
  fieldFolders: {
    fieldFoldersKey: {
      columns: ['columns'],
      description: 'description',
    },
  },
  importMode: 'importMode',
  ingestionWaitPolicy: {
    ingestionWaitTimeInHours: 123,
    waitForSpiceIngestion: false,
  },
  logicalTableMap: {
    logicalTableMapKey: {
      alias: 'alias',
      source: {
        dataSetArn: 'dataSetArn',
        joinInstruction: {
          leftOperand: 'leftOperand',
          onClause: 'onClause',
          rightOperand: 'rightOperand',
          type: 'type',

          // the properties below are optional
          leftJoinKeyProperties: {
            uniqueKey: false,
          },
          rightJoinKeyProperties: {
            uniqueKey: false,
          },
        },
        physicalTableId: 'physicalTableId',
      },

      // the properties below are optional
      dataTransforms: [{
        castColumnTypeOperation: {
          columnName: 'columnName',
          newColumnType: 'newColumnType',

          // the properties below are optional
          format: 'format',
        },
        createColumnsOperation: {
          columns: [{
            columnId: 'columnId',
            columnName: 'columnName',
            expression: 'expression',
          }],
        },
        filterOperation: {
          conditionExpression: 'conditionExpression',
        },
        overrideDatasetParameterOperation: {
          parameterName: 'parameterName',

          // the properties below are optional
          newDefaultValues: {
            dateTimeStaticValues: ['dateTimeStaticValues'],
            decimalStaticValues: [123],
            integerStaticValues: [123],
            stringStaticValues: ['stringStaticValues'],
          },
          newParameterName: 'newParameterName',
        },
        projectOperation: {
          projectedColumns: ['projectedColumns'],
        },
        renameColumnOperation: {
          columnName: 'columnName',
          newColumnName: 'newColumnName',
        },
        tagColumnOperation: {
          columnName: 'columnName',
          tags: [{
            columnDescription: {
              text: 'text',
            },
            columnGeographicRole: 'columnGeographicRole',
          }],
        },
      }],
    },
  },
  name: 'name',
  permissions: [{
    actions: ['actions'],
    principal: 'principal',
  }],
  physicalTableMap: {
    physicalTableMapKey: {
      customSql: {
        columns: [{
          name: 'name',
          type: 'type',
        }],
        dataSourceArn: 'dataSourceArn',
        name: 'name',
        sqlQuery: 'sqlQuery',
      },
      relationalTable: {
        dataSourceArn: 'dataSourceArn',
        inputColumns: [{
          name: 'name',
          type: 'type',
        }],
        name: 'name',

        // the properties below are optional
        catalog: 'catalog',
        schema: 'schema',
      },
      s3Source: {
        dataSourceArn: 'dataSourceArn',
        inputColumns: [{
          name: 'name',
          type: 'type',
        }],

        // the properties below are optional
        uploadSettings: {
          containsHeader: false,
          delimiter: 'delimiter',
          format: 'format',
          startFromRow: 123,
          textQualifier: 'textQualifier',
        },
      },
    },
  },
  rowLevelPermissionDataSet: {
    arn: 'arn',
    permissionPolicy: 'permissionPolicy',

    // the properties below are optional
    formatVersion: 'formatVersion',
    namespace: 'namespace',
    status: 'status',
  },
  rowLevelPermissionTagConfiguration: {
    tagRules: [{
      columnName: 'columnName',
      tagKey: 'tagKey',

      // the properties below are optional
      matchAllValue: 'matchAllValue',
      tagMultiValueDelimiter: 'tagMultiValueDelimiter',
    }],

    // the properties below are optional
    status: 'status',
    tagRuleConfigurations: tagRuleConfigurations,
  },
  tags: [{
    key: 'key',
    value: 'value',
  }],
};

Properties

NameTypeDescription
awsAccountId?stringThe AWS account ID.
columnGroups?IResolvable | IResolvable | ColumnGroupProperty[]Groupings of columns that work together in certain Amazon QuickSight features.
columnLevelPermissionRules?IResolvable | IResolvable | ColumnLevelPermissionRuleProperty[]A set of one or more definitions of a ColumnLevelPermissionRule .
dataSetId?stringAn ID for the dataset that you want to create.
dataSetRefreshProperties?IResolvable | DataSetRefreshPropertiesPropertyAWS::QuickSight::DataSet.DataSetRefreshProperties.
dataSetUsageConfiguration?IResolvable | DataSetUsageConfigurationPropertyThe usage configuration to apply to child datasets that reference this dataset as a source.
datasetParameters?IResolvable | IResolvable | DatasetParameterProperty[]AWS::QuickSight::DataSet.DatasetParameters.
fieldFolders?IResolvable | { [string]: IResolvable | FieldFolderProperty }The folder that contains fields and nested subfolders for your dataset.
importMode?stringIndicates whether you want to import the data into SPICE.
ingestionWaitPolicy?IResolvable | IngestionWaitPolicyPropertyThe wait policy to use when creating or updating a Dataset.
logicalTableMap?IResolvable | { [string]: IResolvable | LogicalTableProperty }Configures the combination and transformation of the data from the physical tables.
name?stringThe display name for the dataset.
permissions?IResolvable | IResolvable | ResourcePermissionProperty[]A list of resource permissions on the dataset.
physicalTableMap?IResolvable | { [string]: IResolvable | PhysicalTableProperty }Declares the physical tables that are available in the underlying data sources.
rowLevelPermissionDataSet?IResolvable | RowLevelPermissionDataSetPropertyThe row-level security configuration for the data that you want to create.
rowLevelPermissionTagConfiguration?IResolvable | RowLevelPermissionTagConfigurationPropertyThe element you can use to define tags for row-level security.
tags?CfnTag[]Contains a map of the key-value pairs for the resource tag or tags assigned to the dataset.

awsAccountId?

Type: string (optional)

The AWS account ID.


columnGroups?

Type: IResolvable | IResolvable | ColumnGroupProperty[] (optional)

Groupings of columns that work together in certain Amazon QuickSight features.

Currently, only geospatial hierarchy is supported.


columnLevelPermissionRules?

Type: IResolvable | IResolvable | ColumnLevelPermissionRuleProperty[] (optional)

A set of one or more definitions of a ColumnLevelPermissionRule .


dataSetId?

Type: string (optional)

An ID for the dataset that you want to create.

This ID is unique per AWS Region for each AWS account.


dataSetRefreshProperties?

Type: IResolvable | DataSetRefreshPropertiesProperty (optional)

AWS::QuickSight::DataSet.DataSetRefreshProperties.


dataSetUsageConfiguration?

Type: IResolvable | DataSetUsageConfigurationProperty (optional)

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


datasetParameters?

Type: IResolvable | IResolvable | DatasetParameterProperty[] (optional)

AWS::QuickSight::DataSet.DatasetParameters.


fieldFolders?

Type: IResolvable | { [string]: IResolvable | FieldFolderProperty } (optional)

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


importMode?

Type: string (optional)

Indicates whether you want to import the data into SPICE.


ingestionWaitPolicy?

Type: IResolvable | IngestionWaitPolicyProperty (optional)

The wait policy to use when creating or updating a Dataset.

The default is to wait for SPICE ingestion to finish with timeout of 36 hours.


logicalTableMap?

Type: IResolvable | { [string]: IResolvable | LogicalTableProperty } (optional)

Configures the combination and transformation of the data from the physical tables.


name?

Type: string (optional)

The display name for the dataset.


permissions?

Type: IResolvable | IResolvable | ResourcePermissionProperty[] (optional)

A list of resource permissions on the dataset.


physicalTableMap?

Type: IResolvable | { [string]: IResolvable | PhysicalTableProperty } (optional)

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


rowLevelPermissionDataSet?

Type: IResolvable | RowLevelPermissionDataSetProperty (optional)

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


rowLevelPermissionTagConfiguration?

Type: IResolvable | RowLevelPermissionTagConfigurationProperty (optional)

The element you can use to define tags for row-level security.


tags?

Type: CfnTag[] (optional)

Contains a map of the key-value pairs for the resource tag or tags assigned to the dataset.