QuickSight / Client / describe_data_set

describe_data_set

QuickSight.Client.describe_data_set(**kwargs)

Describes a dataset. This operation doesn’t support datasets that include uploaded files as a source.

See also: AWS API Documentation

Request Syntax

response = client.describe_data_set(
    AwsAccountId='string',
    DataSetId='string'
)

Parameters:

• AwsAccountId (string) –

  [REQUIRED]

  The Amazon Web Services account ID.

• DataSetId (string) –

  [REQUIRED]

  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.

Return type:

dict

Returns:

Response Syntax

{
    'DataSet': {
        'Arn': 'string',
        'DataSetId': 'string',
        'Name': 'string',
        'CreatedTime': datetime(2015, 1, 1),
        'LastUpdatedTime': datetime(2015, 1, 1),
        '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'
                }
            }
        },
        'OutputColumns': [
            {
                'Name': 'string',
                'Description': 'string',
                'Type': 'STRING'|'INTEGER'|'DECIMAL'|'DATETIME'
            },
        ],
        'ImportMode': 'SPICE'|'DIRECT_QUERY',
        'ConsumedSpiceCapacityInBytes': 123,
        '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
        }
    },
    'RequestId': 'string',
    'Status': 123
}

Response Structure

• (dict) –

  • DataSet (dict) –

    Information on the dataset.

    • Arn (string) –

      The Amazon Resource Name (ARN) of the resource.

    • DataSetId (string) –

      The ID of the dataset.

    • Name (string) –

      A display name for the dataset.

    • CreatedTime (datetime) –

      The time that this dataset was created.

    • LastUpdatedTime (datetime) –

      The last time that this dataset was updated.

    • PhysicalTableMap (dict) –

      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) –

              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) –

              The name of the relational table.

            • InputColumns (list) –

              The column schema of the table.

              • (dict) –

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

                • Name (string) –

                  The name of this column in the underlying data source.

                • Type (string) –

                  The data type of the column.

          • CustomSql (dict) –

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

            • DataSourceArn (string) –

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

            • Name (string) –

              A display name for the SQL query result.

            • SqlQuery (string) –

              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) –

                  The name of this column in the underlying data source.

                • Type (string) –

                  The data type of the column.

          • S3Source (dict) –

            A physical table type for as S3 data source.

            • DataSourceArn (string) –

              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) –

              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) –

                  The name of this column in the underlying data source.

                • Type (string) –

                  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) –

            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) –

                  Projected columns.

                  • (string) –

              • FilterOperation (dict) –

                An operation that filters rows based on some condition.

                • ConditionExpression (string) –

                  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) –

                  Calculated columns to create.

                  • (dict) –

                    A calculated column for a dataset.

                    • ColumnName (string) –

                      Column name.

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

                    • Expression (string) –

                      An expression that defines the calculated column.

              • RenameColumnOperation (dict) –

                An operation that renames a column.

                • ColumnName (string) –

                  The name of the column to be renamed.

                • NewColumnName (string) –

                  The new name for the column.

              • CastColumnTypeOperation (dict) –

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

                • ColumnName (string) –

                  Column name.

                • NewColumnType (string) –

                  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) –

                  The column that this operation acts on.

                • Tags (list) –

                  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) –

                  The column that this operation acts on.

                • TagNames (list) –

                  The column tags to remove from this column.

                  • (string) –

          • Source (dict) –

            Source of this logical table.

            • JoinInstruction (dict) –

              Specifies the result of a join of two logical tables.

              • LeftOperand (string) –

                The operand on the left side of a join.

              • RightOperand (string) –

                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) –

                The type of join that it is.

              • OnClause (string) –

                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.

    • OutputColumns (list) –

      The list of columns after all transforms. These columns are available in templates, analyses, and dashboards.

      • (dict) –

        Output column.

        • Name (string) –

          A display name for the dataset.

        • Description (string) –

          A description for a column.

        • Type (string) –

          Type.

    • ImportMode (string) –

      A value that indicates whether you want to import the data into SPICE.

    • ConsumedSpiceCapacityInBytes (integer) –

      The amount of SPICE capacity used by this dataset. This is 0 if the dataset isn’t imported 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) –

            A display name for the hierarchy.

          • CountryCode (string) –

            Country code.

          • Columns (list) –

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

      • Namespace (string) –

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

      • Arn (string) –

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

      • PermissionPolicy (string) –

        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 element you can use to define tags for row-level security.

      • Status (string) –

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

      • TagRules (list) –

        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) –

            The unique key for a tag.

          • ColumnName (string) –

            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.

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

• QuickSight.Client.exceptions.ThrottlingException

• QuickSight.Client.exceptions.ResourceNotFoundException

• QuickSight.Client.exceptions.InternalFailureException