QuickSight / Client / update_data_set

update_data_set

QuickSight.Client.update_data_set(**kwargs)

Updates a dataset. This operation doesn’t support datasets that include uploaded files as a source. Partial updates are not supported by this operation.

See also: AWS API Documentation

Request Syntax

response = client.update_data_set(
    AwsAccountId='string',
    DataSetId='string',
    Name='string',
    PhysicalTableMap={
        'string': {
            'RelationalTable': {
                'DataSourceArn': 'string',
                'Catalog': 'string',
                'Schema': 'string',
                'Name': 'string',
                'InputColumns': [
                    {
                        'Name': 'string',
                        'Type': 'STRING'|'INTEGER'|'DECIMAL'|'DATETIME'|'BIT'|'BOOLEAN'|'JSON'
                    },
                ]
            },
            'CustomSql': {
                'DataSourceArn': 'string',
                'Name': 'string',
                'SqlQuery': 'string',
                'Columns': [
                    {
                        'Name': 'string',
                        'Type': 'STRING'|'INTEGER'|'DECIMAL'|'DATETIME'|'BIT'|'BOOLEAN'|'JSON'
                    },
                ]
            },
            'S3Source': {
                'DataSourceArn': 'string',
                'UploadSettings': {
                    'Format': 'CSV'|'TSV'|'CLF'|'ELF'|'XLSX'|'JSON',
                    'StartFromRow': 123,
                    'ContainsHeader': True|False,
                    'TextQualifier': 'DOUBLE_QUOTE'|'SINGLE_QUOTE',
                    'Delimiter': 'string'
                },
                'InputColumns': [
                    {
                        'Name': 'string',
                        'Type': 'STRING'|'INTEGER'|'DECIMAL'|'DATETIME'|'BIT'|'BOOLEAN'|'JSON'
                    },
                ]
            }
        }
    },
    LogicalTableMap={
        'string': {
            'Alias': 'string',
            'DataTransforms': [
                {
                    'ProjectOperation': {
                        'ProjectedColumns': [
                            'string',
                        ]
                    },
                    'FilterOperation': {
                        'ConditionExpression': 'string'
                    },
                    'CreateColumnsOperation': {
                        'Columns': [
                            {
                                'ColumnName': 'string',
                                'ColumnId': 'string',
                                'Expression': 'string'
                            },
                        ]
                    },
                    'RenameColumnOperation': {
                        'ColumnName': 'string',
                        'NewColumnName': 'string'
                    },
                    'CastColumnTypeOperation': {
                        'ColumnName': 'string',
                        'NewColumnType': 'STRING'|'INTEGER'|'DECIMAL'|'DATETIME',
                        'Format': 'string'
                    },
                    'TagColumnOperation': {
                        'ColumnName': 'string',
                        'Tags': [
                            {
                                'ColumnGeographicRole': 'COUNTRY'|'STATE'|'COUNTY'|'CITY'|'POSTCODE'|'LONGITUDE'|'LATITUDE',
                                'ColumnDescription': {
                                    'Text': 'string'
                                }
                            },
                        ]
                    },
                    'UntagColumnOperation': {
                        'ColumnName': 'string',
                        'TagNames': [
                            'COLUMN_GEOGRAPHIC_ROLE'|'COLUMN_DESCRIPTION',
                        ]
                    }
                },
            ],
            'Source': {
                'JoinInstruction': {
                    'LeftOperand': 'string',
                    'RightOperand': 'string',
                    'LeftJoinKeyProperties': {
                        'UniqueKey': True|False
                    },
                    'RightJoinKeyProperties': {
                        'UniqueKey': True|False
                    },
                    'Type': 'INNER'|'OUTER'|'LEFT'|'RIGHT',
                    'OnClause': 'string'
                },
                'PhysicalTableId': 'string',
                'DataSetArn': 'string'
            }
        }
    },
    ImportMode='SPICE'|'DIRECT_QUERY',
    ColumnGroups=[
        {
            'GeoSpatialColumnGroup': {
                'Name': 'string',
                'CountryCode': 'US',
                'Columns': [
                    'string',
                ]
            }
        },
    ],
    FieldFolders={
        'string': {
            'description': 'string',
            'columns': [
                'string',
            ]
        }
    },
    RowLevelPermissionDataSet={
        'Namespace': 'string',
        'Arn': 'string',
        'PermissionPolicy': 'GRANT_ACCESS'|'DENY_ACCESS',
        'FormatVersion': 'VERSION_1'|'VERSION_2',
        'Status': 'ENABLED'|'DISABLED'
    },
    RowLevelPermissionTagConfiguration={
        'Status': 'ENABLED'|'DISABLED',
        'TagRules': [
            {
                'TagKey': 'string',
                'ColumnName': 'string',
                'TagMultiValueDelimiter': 'string',
                'MatchAllValue': 'string'
            },
        ]
    },
    ColumnLevelPermissionRules=[
        {
            'Principals': [
                'string',
            ],
            'ColumnNames': [
                'string',
            ]
        },
    ],
    DataSetUsageConfiguration={
        'DisableUseAsDirectQuerySource': True|False,
        'DisableUseAsImportedSource': True|False
    }
)

Parameters:

• AwsAccountId (string) –

  [REQUIRED]

  The Amazon Web Services account ID.

• DataSetId (string) –

  [REQUIRED]

  The ID for the dataset that you want to update. This ID is unique per Amazon Web Services Region for each Amazon Web Services account.

• Name (string) –

  [REQUIRED]

  The display name for the dataset.

• PhysicalTableMap (dict) –

  [REQUIRED]

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

  • (string) –

    • (dict) –

      A view of a data source that contains information about the shape of the data in the underlying source. This is a variant type structure. For this structure to be valid, only one of the attributes can be non-null.

      • RelationalTable (dict) –

        A physical table type for relational data sources.

        • DataSourceArn (string) – [REQUIRED]

          The Amazon Resource Name (ARN) for the data source.

        • Catalog (string) –

          The catalog associated with a table.

        • Schema (string) –

          The schema name. This name applies to certain relational database engines.

        • Name (string) – [REQUIRED]

          The name of the relational table.

        • InputColumns (list) – [REQUIRED]

          The column schema of the table.

          • (dict) –

            Metadata for a column that is used as the input of a transform operation.

            • Name (string) – [REQUIRED]

              The name of this column in the underlying data source.

            • Type (string) – [REQUIRED]

              The data type of the column.

      • CustomSql (dict) –

        A physical table type built from the results of the custom SQL query.

        • DataSourceArn (string) – [REQUIRED]

          The Amazon Resource Name (ARN) of the data source.

        • Name (string) – [REQUIRED]

          A display name for the SQL query result.

        • SqlQuery (string) – [REQUIRED]

          The SQL query.

        • Columns (list) –

          The column schema from the SQL query result set.

          • (dict) –

            Metadata for a column that is used as the input of a transform operation.

            • Name (string) – [REQUIRED]

              The name of this column in the underlying data source.

            • Type (string) – [REQUIRED]

              The data type of the column.

      • S3Source (dict) –

        A physical table type for as S3 data source.

        • DataSourceArn (string) – [REQUIRED]

          The Amazon Resource Name (ARN) for the data source.

        • UploadSettings (dict) –

          Information about the format for the S3 source file or files.

          • Format (string) –

            File format.

          • StartFromRow (integer) –

            A row number to start reading data from.

          • ContainsHeader (boolean) –

            Whether the file has a header row, or the files each have a header row.

          • TextQualifier (string) –

            Text qualifier.

          • Delimiter (string) –

            The delimiter between values in the file.

        • InputColumns (list) – [REQUIRED]

          A physical table type for an S3 data source.

          Note

          For files that aren’t JSON, only STRING data types are supported in input columns.

          • (dict) –

            Metadata for a column that is used as the input of a transform operation.

            • Name (string) – [REQUIRED]

              The name of this column in the underlying data source.

            • Type (string) – [REQUIRED]

              The data type of the column.

• LogicalTableMap (dict) –

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

  • (string) –

    • (dict) –

      A logical table is a unit that joins and that data transformations operate on. A logical table has a source, which can be either a physical table or result of a join. When a logical table points to a physical table, the logical table acts as a mutable copy of that physical table through transform operations.

      • Alias (string) – [REQUIRED]

        A display name for the logical table.

      • DataTransforms (list) –

        Transform operations that act on this logical table. For this structure to be valid, only one of the attributes can be non-null.

        • (dict) –

          A data transformation on a logical table. This is a variant type structure. For this structure to be valid, only one of the attributes can be non-null.

          • ProjectOperation (dict) –

            An operation that projects columns. Operations that come after a projection can only refer to projected columns.

            • ProjectedColumns (list) – [REQUIRED]

              Projected columns.

              • (string) –

          • FilterOperation (dict) –

            An operation that filters rows based on some condition.

            • ConditionExpression (string) – [REQUIRED]

              An expression that must evaluate to a Boolean value. Rows for which the expression evaluates to true are kept in the dataset.

          • CreateColumnsOperation (dict) –

            An operation that creates calculated columns. Columns created in one such operation form a lexical closure.

            • Columns (list) – [REQUIRED]

              Calculated columns to create.

              • (dict) –

                A calculated column for a dataset.

                • ColumnName (string) – [REQUIRED]

                  Column name.

                • ColumnId (string) – [REQUIRED]

                  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.

                • Expression (string) – [REQUIRED]

                  An expression that defines the calculated column.

          • RenameColumnOperation (dict) –

            An operation that renames a column.

            • ColumnName (string) – [REQUIRED]

              The name of the column to be renamed.

            • NewColumnName (string) – [REQUIRED]

              The new name for the column.

          • CastColumnTypeOperation (dict) –

            A transform operation that casts a column to a different type.

            • ColumnName (string) – [REQUIRED]

              Column name.

            • NewColumnType (string) – [REQUIRED]

              New column data type.

            • 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.

          • TagColumnOperation (dict) –

            An operation that tags a column with additional information.

            • ColumnName (string) – [REQUIRED]

              The column that this operation acts on.

            • Tags (list) – [REQUIRED]

              The dataset column tag, currently only used for geospatial type tagging.

              Note

              This is not tags for the Amazon Web Services tagging feature.

              • (dict) –

                A tag for a column in a TagColumnOperation structure. This is a variant type structure. For this structure to be valid, only one of the attributes can be non-null.

                • ColumnGeographicRole (string) –

                  A geospatial role for a column.

                • ColumnDescription (dict) –

                  A description for a column.

                  • Text (string) –

                    The text of a description for a column.

          • UntagColumnOperation (dict) –

            A transform operation that removes tags associated with a column.

            • ColumnName (string) – [REQUIRED]

              The column that this operation acts on.

            • TagNames (list) – [REQUIRED]

              The column tags to remove from this column.

              • (string) –

      • Source (dict) – [REQUIRED]

        Source of this logical table.

        • JoinInstruction (dict) –

          Specifies the result of a join of two logical tables.

          • LeftOperand (string) – [REQUIRED]

            The operand on the left side of a join.

          • RightOperand (string) – [REQUIRED]

            The operand on the right side of a join.

          • LeftJoinKeyProperties (dict) –

            Join key properties of the left operand.

            • 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.

          • RightJoinKeyProperties (dict) –

            Join key properties of the right operand.

            • 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.

          • Type (string) – [REQUIRED]

            The type of join that it is.

          • OnClause (string) – [REQUIRED]

            The join instructions provided in the ON clause of a join.

        • PhysicalTableId (string) –

          Physical table ID.

        • DataSetArn (string) –

          The Amazon Resource Number (ARN) of the parent dataset.

• ImportMode (string) –

  [REQUIRED]

  Indicates whether you want to import the data into SPICE.

• ColumnGroups (list) –

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

  • (dict) –

    Groupings of columns that work together in certain Amazon QuickSight features. This is a variant type structure. For this structure to be valid, only one of the attributes can be non-null.

    • GeoSpatialColumnGroup (dict) –

      Geospatial column group that denotes a hierarchy.

      • Name (string) – [REQUIRED]

        A display name for the hierarchy.

      • CountryCode (string) –

        Country code.

      • Columns (list) – [REQUIRED]

        Columns in this hierarchy.

        • (string) –

• FieldFolders (dict) –

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

  • (string) –

    • (dict) –

      A FieldFolder element is a folder that contains fields and nested subfolders.

      • description (string) –

        The description for a field folder.

      • columns (list) –

        A folder has a list of columns. A column can only be in one folder.

        • (string) –

• RowLevelPermissionDataSet (dict) –

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

  • Namespace (string) –

    The namespace associated with the dataset that contains permissions for RLS.

  • Arn (string) – [REQUIRED]

    The Amazon Resource Name (ARN) of the dataset that contains permissions for RLS.

  • PermissionPolicy (string) – [REQUIRED]

    The type of permissions to use when interpreting the permissions for RLS. DENY_ACCESS is included for backward compatibility only.

  • FormatVersion (string) –

    The user or group rules associated with the dataset that contains permissions for RLS.

    By default, FormatVersion is VERSION_1 . When FormatVersion is VERSION_1 , UserName and GroupName are required. When FormatVersion is VERSION_2 , UserARN and GroupARN are required, and Namespace must not exist.

  • Status (string) –

    The status of the row-level security permission dataset. If enabled, the status is ENABLED . If disabled, the status is DISABLED .

• RowLevelPermissionTagConfiguration (dict) –

  The configuration of tags on a dataset to set row-level security. Row-level security tags are currently supported for anonymous embedding only.

  • Status (string) –

    The status of row-level security tags. If enabled, the status is ENABLED . If disabled, the status is DISABLED .

  • TagRules (list) – [REQUIRED]

    A set of rules associated with row-level security, such as the tag names and columns that they are assigned to.

    • (dict) –

      A set of rules associated with a tag.

      • TagKey (string) – [REQUIRED]

        The unique key for a tag.

      • ColumnName (string) – [REQUIRED]

        The column name that a tag key is assigned to.

      • TagMultiValueDelimiter (string) –

        A string that you want to use to delimit the values when you pass the values at run time. For example, you can delimit the values with a comma.

      • 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. For example, you can use an asterisk as your match all value.

• ColumnLevelPermissionRules (list) –

  A set of one or more definitions of a ColumnLevelPermissionRule .

  • (dict) –

    A rule defined to grant access on one or more restricted columns. Each dataset can have multiple rules. To create a restricted column, you add it to one or more rules. Each rule must contain at least one column and at least one user or group. To be able to see a restricted column, a user or group needs to be added to a rule for that column.

    • Principals (list) –

      An array of Amazon Resource Names (ARNs) for Amazon QuickSight users or groups.

      • (string) –

    • ColumnNames (list) –

      An array of column names.

      • (string) –

• DataSetUsageConfiguration (dict) –

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

  • DisableUseAsDirectQuerySource (boolean) –

    An option that controls whether a child dataset of a direct query can use this dataset as a source.

  • DisableUseAsImportedSource (boolean) –

    An option that controls whether a child dataset that’s stored in QuickSight can use this dataset as a source.

Return type:

dict

Returns:

Response Syntax

{
    'Arn': 'string',
    'DataSetId': 'string',
    'IngestionArn': 'string',
    'IngestionId': 'string',
    'RequestId': 'string',
    'Status': 123
}

Response Structure

• (dict) –

  • Arn (string) –

    The Amazon Resource Name (ARN) of the dataset.

  • DataSetId (string) –

    The ID for the dataset that you want to create. This ID is unique per Amazon Web Services Region for each Amazon Web Services account.

  • IngestionArn (string) –

    The ARN for the ingestion, which is triggered as a result of dataset creation if the import mode is SPICE.

  • IngestionId (string) –

    The ID of the ingestion, which is triggered as a result of dataset creation if the import mode is SPICE.

  • RequestId (string) –

    The Amazon Web Services request ID for this operation.

  • Status (integer) –

    The HTTP status of the request.

Exceptions

• QuickSight.Client.exceptions.AccessDeniedException

• QuickSight.Client.exceptions.ConflictException

• QuickSight.Client.exceptions.InvalidParameterValueException

• QuickSight.Client.exceptions.LimitExceededException

• QuickSight.Client.exceptions.ThrottlingException

• QuickSight.Client.exceptions.ResourceNotFoundException

• QuickSight.Client.exceptions.UnsupportedUserEditionException

• QuickSight.Client.exceptions.InternalFailureException