Skip to content
v2.277.0

LogicalTableProperty Struct ​

<p>A <i>logical table</i> 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.</p>

Example ​

ts
// 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';
const logicalTableProperty: quicksight.CfnDataSet.LogicalTableProperty = {
  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',
      subType: 'subType',
    },
    createColumnsOperation: {
      columns: [{
        columnId: 'columnId',
        columnName: 'columnName',
        expression: 'expression',
      }],

      // the properties below are optional
      alias: 'alias',
      source: {
        transformOperationId: 'transformOperationId',

        // the properties below are optional
        columnIdMappings: [{
          sourceColumnId: 'sourceColumnId',
          targetColumnId: 'targetColumnId',
        }],
      },
    },
    filterOperation: {
      conditionExpression: 'conditionExpression',
      dateFilterCondition: {
        columnName: 'columnName',
        comparisonFilterCondition: {
          operator: 'operator',

          // the properties below are optional
          value: {
            staticValue: 'staticValue',
          },
        },
        rangeFilterCondition: {
          includeMaximum: false,
          includeMinimum: false,
          rangeMaximum: {
            staticValue: 'staticValue',
          },
          rangeMinimum: {
            staticValue: 'staticValue',
          },
        },
      },
      numericFilterCondition: {
        columnName: 'columnName',
        comparisonFilterCondition: {
          operator: 'operator',

          // the properties below are optional
          value: {
            staticValue: 123,
          },
        },
        rangeFilterCondition: {
          includeMaximum: false,
          includeMinimum: false,
          rangeMaximum: {
            staticValue: 123,
          },
          rangeMinimum: {
            staticValue: 123,
          },
        },
      },
      stringFilterCondition: {
        columnName: 'columnName',
        comparisonFilterCondition: {
          operator: 'operator',

          // the properties below are optional
          value: {
            staticValue: 'staticValue',
          },
        },
        listFilterCondition: {
          operator: 'operator',

          // the properties below are optional
          values: {
            staticValues: ['staticValues'],
          },
        },
      },
    },
    overrideDatasetParameterOperation: {
      parameterName: 'parameterName',

      // the properties below are optional
      newDefaultValues: {
        dateTimeStaticValues: ['dateTimeStaticValues'],
        decimalStaticValues: [123],
        integerStaticValues: [123],
        stringStaticValues: ['stringStaticValues'],
      },
      newParameterName: 'newParameterName',
    },
    projectOperation: {
      alias: 'alias',
      projectedColumns: ['projectedColumns'],
      source: {
        transformOperationId: 'transformOperationId',

        // the properties below are optional
        columnIdMappings: [{
          sourceColumnId: 'sourceColumnId',
          targetColumnId: 'targetColumnId',
        }],
      },
    },
    renameColumnOperation: {
      columnName: 'columnName',
      newColumnName: 'newColumnName',
    },
    tagColumnOperation: {
      columnName: 'columnName',
      tags: [{
        columnDescription: {
          text: 'text',
        },
        columnGeographicRole: 'columnGeographicRole',
      }],
    },
    untagColumnOperation: {
      columnName: 'columnName',
      tagNames: ['tagNames'],
    },
  }],
};
python
# The code below shows an example of how to instantiate this type.
# The values are placeholders you should change.
from aws_cdk import aws_quicksight as quicksight

logical_table_property = quicksight.CfnDataSet.LogicalTableProperty(
    alias="alias",
    source=quicksight.CfnDataSet.LogicalTableSourceProperty(
        data_set_arn="dataSetArn",
        join_instruction=quicksight.CfnDataSet.JoinInstructionProperty(
            left_operand="leftOperand",
            on_clause="onClause",
            right_operand="rightOperand",
            type="type",

            # the properties below are optional
            left_join_key_properties=quicksight.CfnDataSet.JoinKeyPropertiesProperty(
                unique_key=False
            ),
            right_join_key_properties=quicksight.CfnDataSet.JoinKeyPropertiesProperty(
                unique_key=False
            )
        ),
        physical_table_id="physicalTableId"
    ),

    # the properties below are optional
    data_transforms=[quicksight.CfnDataSet.TransformOperationProperty(
        cast_column_type_operation=quicksight.CfnDataSet.CastColumnTypeOperationProperty(
            column_name="columnName",
            new_column_type="newColumnType",

            # the properties below are optional
            format="format",
            sub_type="subType"
        ),
        create_columns_operation=quicksight.CfnDataSet.CreateColumnsOperationProperty(
            columns=[quicksight.CfnDataSet.CalculatedColumnProperty(
                column_id="columnId",
                column_name="columnName",
                expression="expression"
            )],

            # the properties below are optional
            alias="alias",
            source=quicksight.CfnDataSet.TransformOperationSourceProperty(
                transform_operation_id="transformOperationId",

                # the properties below are optional
                column_id_mappings=[quicksight.CfnDataSet.DataSetColumnIdMappingProperty(
                    source_column_id="sourceColumnId",
                    target_column_id="targetColumnId"
                )]
            )
        ),
        filter_operation=quicksight.CfnDataSet.FilterOperationProperty(
            condition_expression="conditionExpression",
            date_filter_condition=quicksight.CfnDataSet.DataSetDateFilterConditionProperty(
                column_name="columnName",
                comparison_filter_condition=quicksight.CfnDataSet.DataSetDateComparisonFilterConditionProperty(
                    operator="operator",

                    # the properties below are optional
                    value=quicksight.CfnDataSet.DataSetDateFilterValueProperty(
                        static_value="staticValue"
                    )
                ),
                range_filter_condition=quicksight.CfnDataSet.DataSetDateRangeFilterConditionProperty(
                    include_maximum=False,
                    include_minimum=False,
                    range_maximum=quicksight.CfnDataSet.DataSetDateFilterValueProperty(
                        static_value="staticValue"
                    ),
                    range_minimum=quicksight.CfnDataSet.DataSetDateFilterValueProperty(
                        static_value="staticValue"
                    )
                )
            ),
            numeric_filter_condition=quicksight.CfnDataSet.DataSetNumericFilterConditionProperty(
                column_name="columnName",
                comparison_filter_condition=quicksight.CfnDataSet.DataSetNumericComparisonFilterConditionProperty(
                    operator="operator",

                    # the properties below are optional
                    value=quicksight.CfnDataSet.DataSetNumericFilterValueProperty(
                        static_value=123
                    )
                ),
                range_filter_condition=quicksight.CfnDataSet.DataSetNumericRangeFilterConditionProperty(
                    include_maximum=False,
                    include_minimum=False,
                    range_maximum=quicksight.CfnDataSet.DataSetNumericFilterValueProperty(
                        static_value=123
                    ),
                    range_minimum=quicksight.CfnDataSet.DataSetNumericFilterValueProperty(
                        static_value=123
                    )
                )
            ),
            string_filter_condition=quicksight.CfnDataSet.DataSetStringFilterConditionProperty(
                column_name="columnName",
                comparison_filter_condition=quicksight.CfnDataSet.DataSetStringComparisonFilterConditionProperty(
                    operator="operator",

                    # the properties below are optional
                    value=quicksight.CfnDataSet.DataSetStringFilterValueProperty(
                        static_value="staticValue"
                    )
                ),
                list_filter_condition=quicksight.CfnDataSet.DataSetStringListFilterConditionProperty(
                    operator="operator",

                    # the properties below are optional
                    values=quicksight.CfnDataSet.DataSetStringListFilterValueProperty(
                        static_values=["staticValues"]
                    )
                )
            )
        ),
        override_dataset_parameter_operation=quicksight.CfnDataSet.OverrideDatasetParameterOperationProperty(
            parameter_name="parameterName",

            # the properties below are optional
            new_default_values=quicksight.CfnDataSet.NewDefaultValuesProperty(
                date_time_static_values=["dateTimeStaticValues"],
                decimal_static_values=[123],
                integer_static_values=[123],
                string_static_values=["stringStaticValues"]
            ),
            new_parameter_name="newParameterName"
        ),
        project_operation=quicksight.CfnDataSet.ProjectOperationProperty(
            alias="alias",
            projected_columns=["projectedColumns"],
            source=quicksight.CfnDataSet.TransformOperationSourceProperty(
                transform_operation_id="transformOperationId",

                # the properties below are optional
                column_id_mappings=[quicksight.CfnDataSet.DataSetColumnIdMappingProperty(
                    source_column_id="sourceColumnId",
                    target_column_id="targetColumnId"
                )]
            )
        ),
        rename_column_operation=quicksight.CfnDataSet.RenameColumnOperationProperty(
            column_name="columnName",
            new_column_name="newColumnName"
        ),
        tag_column_operation=quicksight.CfnDataSet.TagColumnOperationProperty(
            column_name="columnName",
            tags=[quicksight.CfnDataSet.ColumnTagProperty(
                column_description=quicksight.CfnDataSet.ColumnDescriptionProperty(
                    text="text"
                ),
                column_geographic_role="columnGeographicRole"
            )]
        ),
        untag_column_operation=quicksight.CfnDataSet.UntagColumnOperationProperty(
            column_name="columnName",
            tag_names=["tagNames"]
        )
    )]
)
java
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import software.amazon.awscdk.services.quicksight.*;

LogicalTableProperty logicalTableProperty = LogicalTableProperty.builder()
        .alias("alias")
        .source(LogicalTableSourceProperty.builder()
                .dataSetArn("dataSetArn")
                .joinInstruction(JoinInstructionProperty.builder()
                        .leftOperand("leftOperand")
                        .onClause("onClause")
                        .rightOperand("rightOperand")
                        .type("type")

                        // the properties below are optional
                        .leftJoinKeyProperties(JoinKeyPropertiesProperty.builder()
                                .uniqueKey(false)
                                .build())
                        .rightJoinKeyProperties(JoinKeyPropertiesProperty.builder()
                                .uniqueKey(false)
                                .build())
                        .build())
                .physicalTableId("physicalTableId")
                .build())

        // the properties below are optional
        .dataTransforms(List.of(TransformOperationProperty.builder()
                .castColumnTypeOperation(CastColumnTypeOperationProperty.builder()
                        .columnName("columnName")
                        .newColumnType("newColumnType")

                        // the properties below are optional
                        .format("format")
                        .subType("subType")
                        .build())
                .createColumnsOperation(CreateColumnsOperationProperty.builder()
                        .columns(List.of(CalculatedColumnProperty.builder()
                                .columnId("columnId")
                                .columnName("columnName")
                                .expression("expression")
                                .build()))

                        // the properties below are optional
                        .alias("alias")
                        .source(TransformOperationSourceProperty.builder()
                                .transformOperationId("transformOperationId")

                                // the properties below are optional
                                .columnIdMappings(List.of(DataSetColumnIdMappingProperty.builder()
                                        .sourceColumnId("sourceColumnId")
                                        .targetColumnId("targetColumnId")
                                        .build()))
                                .build())
                        .build())
                .filterOperation(FilterOperationProperty.builder()
                        .conditionExpression("conditionExpression")
                        .dateFilterCondition(DataSetDateFilterConditionProperty.builder()
                                .columnName("columnName")
                                .comparisonFilterCondition(DataSetDateComparisonFilterConditionProperty.builder()
                                        .operator("operator")

                                        // the properties below are optional
                                        .value(DataSetDateFilterValueProperty.builder()
                                                .staticValue("staticValue")
                                                .build())
                                        .build())
                                .rangeFilterCondition(DataSetDateRangeFilterConditionProperty.builder()
                                        .includeMaximum(false)
                                        .includeMinimum(false)
                                        .rangeMaximum(DataSetDateFilterValueProperty.builder()
                                                .staticValue("staticValue")
                                                .build())
                                        .rangeMinimum(DataSetDateFilterValueProperty.builder()
                                                .staticValue("staticValue")
                                                .build())
                                        .build())
                                .build())
                        .numericFilterCondition(DataSetNumericFilterConditionProperty.builder()
                                .columnName("columnName")
                                .comparisonFilterCondition(DataSetNumericComparisonFilterConditionProperty.builder()
                                        .operator("operator")

                                        // the properties below are optional
                                        .value(DataSetNumericFilterValueProperty.builder()
                                                .staticValue(123)
                                                .build())
                                        .build())
                                .rangeFilterCondition(DataSetNumericRangeFilterConditionProperty.builder()
                                        .includeMaximum(false)
                                        .includeMinimum(false)
                                        .rangeMaximum(DataSetNumericFilterValueProperty.builder()
                                                .staticValue(123)
                                                .build())
                                        .rangeMinimum(DataSetNumericFilterValueProperty.builder()
                                                .staticValue(123)
                                                .build())
                                        .build())
                                .build())
                        .stringFilterCondition(DataSetStringFilterConditionProperty.builder()
                                .columnName("columnName")
                                .comparisonFilterCondition(DataSetStringComparisonFilterConditionProperty.builder()
                                        .operator("operator")

                                        // the properties below are optional
                                        .value(DataSetStringFilterValueProperty.builder()
                                                .staticValue("staticValue")
                                                .build())
                                        .build())
                                .listFilterCondition(DataSetStringListFilterConditionProperty.builder()
                                        .operator("operator")

                                        // the properties below are optional
                                        .values(DataSetStringListFilterValueProperty.builder()
                                                .staticValues(List.of("staticValues"))
                                                .build())
                                        .build())
                                .build())
                        .build())
                .overrideDatasetParameterOperation(OverrideDatasetParameterOperationProperty.builder()
                        .parameterName("parameterName")

                        // the properties below are optional
                        .newDefaultValues(NewDefaultValuesProperty.builder()
                                .dateTimeStaticValues(List.of("dateTimeStaticValues"))
                                .decimalStaticValues(List.of(123))
                                .integerStaticValues(List.of(123))
                                .stringStaticValues(List.of("stringStaticValues"))
                                .build())
                        .newParameterName("newParameterName")
                        .build())
                .projectOperation(ProjectOperationProperty.builder()
                        .alias("alias")
                        .projectedColumns(List.of("projectedColumns"))
                        .source(TransformOperationSourceProperty.builder()
                                .transformOperationId("transformOperationId")

                                // the properties below are optional
                                .columnIdMappings(List.of(DataSetColumnIdMappingProperty.builder()
                                        .sourceColumnId("sourceColumnId")
                                        .targetColumnId("targetColumnId")
                                        .build()))
                                .build())
                        .build())
                .renameColumnOperation(RenameColumnOperationProperty.builder()
                        .columnName("columnName")
                        .newColumnName("newColumnName")
                        .build())
                .tagColumnOperation(TagColumnOperationProperty.builder()
                        .columnName("columnName")
                        .tags(List.of(ColumnTagProperty.builder()
                                .columnDescription(ColumnDescriptionProperty.builder()
                                        .text("text")
                                        .build())
                                .columnGeographicRole("columnGeographicRole")
                                .build()))
                        .build())
                .untagColumnOperation(UntagColumnOperationProperty.builder()
                        .columnName("columnName")
                        .tagNames(List.of("tagNames"))
                        .build())
                .build()))
        .build();
csharp
// Install: dotnet add package Amazon.CDK.Lib
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
using Amazon.CDK.AWS.QuickSight;

var logicalTableProperty = new LogicalTableProperty {
    Alias = "alias",
    Source = new LogicalTableSourceProperty {
        DataSetArn = "dataSetArn",
        JoinInstruction = new JoinInstructionProperty {
            LeftOperand = "leftOperand",
            OnClause = "onClause",
            RightOperand = "rightOperand",
            Type = "type",

            // the properties below are optional
            LeftJoinKeyProperties = new JoinKeyPropertiesProperty {
                UniqueKey = false
            },
            RightJoinKeyProperties = new JoinKeyPropertiesProperty {
                UniqueKey = false
            }
        },
        PhysicalTableId = "physicalTableId"
    },

    // the properties below are optional
    DataTransforms = new [] { new TransformOperationProperty {
        CastColumnTypeOperation = new CastColumnTypeOperationProperty {
            ColumnName = "columnName",
            NewColumnType = "newColumnType",

            // the properties below are optional
            Format = "format",
            SubType = "subType"
        },
        CreateColumnsOperation = new CreateColumnsOperationProperty {
            Columns = new [] { new CalculatedColumnProperty {
                ColumnId = "columnId",
                ColumnName = "columnName",
                Expression = "expression"
            } },

            // the properties below are optional
            Alias = "alias",
            Source = new TransformOperationSourceProperty {
                TransformOperationId = "transformOperationId",

                // the properties below are optional
                ColumnIdMappings = new [] { new DataSetColumnIdMappingProperty {
                    SourceColumnId = "sourceColumnId",
                    TargetColumnId = "targetColumnId"
                } }
            }
        },
        FilterOperation = new FilterOperationProperty {
            ConditionExpression = "conditionExpression",
            DateFilterCondition = new DataSetDateFilterConditionProperty {
                ColumnName = "columnName",
                ComparisonFilterCondition = new DataSetDateComparisonFilterConditionProperty {
                    Operator = "operator",

                    // the properties below are optional
                    Value = new DataSetDateFilterValueProperty {
                        StaticValue = "staticValue"
                    }
                },
                RangeFilterCondition = new DataSetDateRangeFilterConditionProperty {
                    IncludeMaximum = false,
                    IncludeMinimum = false,
                    RangeMaximum = new DataSetDateFilterValueProperty {
                        StaticValue = "staticValue"
                    },
                    RangeMinimum = new DataSetDateFilterValueProperty {
                        StaticValue = "staticValue"
                    }
                }
            },
            NumericFilterCondition = new DataSetNumericFilterConditionProperty {
                ColumnName = "columnName",
                ComparisonFilterCondition = new DataSetNumericComparisonFilterConditionProperty {
                    Operator = "operator",

                    // the properties below are optional
                    Value = new DataSetNumericFilterValueProperty {
                        StaticValue = 123
                    }
                },
                RangeFilterCondition = new DataSetNumericRangeFilterConditionProperty {
                    IncludeMaximum = false,
                    IncludeMinimum = false,
                    RangeMaximum = new DataSetNumericFilterValueProperty {
                        StaticValue = 123
                    },
                    RangeMinimum = new DataSetNumericFilterValueProperty {
                        StaticValue = 123
                    }
                }
            },
            StringFilterCondition = new DataSetStringFilterConditionProperty {
                ColumnName = "columnName",
                ComparisonFilterCondition = new DataSetStringComparisonFilterConditionProperty {
                    Operator = "operator",

                    // the properties below are optional
                    Value = new DataSetStringFilterValueProperty {
                        StaticValue = "staticValue"
                    }
                },
                ListFilterCondition = new DataSetStringListFilterConditionProperty {
                    Operator = "operator",

                    // the properties below are optional
                    Values = new DataSetStringListFilterValueProperty {
                        StaticValues = new [] { "staticValues" }
                    }
                }
            }
        },
        OverrideDatasetParameterOperation = new OverrideDatasetParameterOperationProperty {
            ParameterName = "parameterName",

            // the properties below are optional
            NewDefaultValues = new NewDefaultValuesProperty {
                DateTimeStaticValues = new [] { "dateTimeStaticValues" },
                DecimalStaticValues = new [] { 123 },
                IntegerStaticValues = new [] { 123 },
                StringStaticValues = new [] { "stringStaticValues" }
            },
            NewParameterName = "newParameterName"
        },
        ProjectOperation = new ProjectOperationProperty {
            Alias = "alias",
            ProjectedColumns = new [] { "projectedColumns" },
            Source = new TransformOperationSourceProperty {
                TransformOperationId = "transformOperationId",

                // the properties below are optional
                ColumnIdMappings = new [] { new DataSetColumnIdMappingProperty {
                    SourceColumnId = "sourceColumnId",
                    TargetColumnId = "targetColumnId"
                } }
            }
        },
        RenameColumnOperation = new RenameColumnOperationProperty {
            ColumnName = "columnName",
            NewColumnName = "newColumnName"
        },
        TagColumnOperation = new TagColumnOperationProperty {
            ColumnName = "columnName",
            Tags = new [] { new ColumnTagProperty {
                ColumnDescription = new ColumnDescriptionProperty {
                    Text = "text"
                },
                ColumnGeographicRole = "columnGeographicRole"
            } }
        },
        UntagColumnOperation = new UntagColumnOperationProperty {
            ColumnName = "columnName",
            TagNames = new [] { "tagNames" }
        }
    } }
};
go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

logicalTableProperty := &LogicalTableProperty{
	Alias: jsii.String("alias"),
	Source: &LogicalTableSourceProperty{
		DataSetArn: jsii.String("dataSetArn"),
		JoinInstruction: &JoinInstructionProperty{
			LeftOperand: jsii.String("leftOperand"),
			OnClause: jsii.String("onClause"),
			RightOperand: jsii.String("rightOperand"),
			Type: jsii.String("type"),

			// the properties below are optional
			LeftJoinKeyProperties: &JoinKeyPropertiesProperty{
				UniqueKey: jsii.Boolean(false),
			},
			RightJoinKeyProperties: &JoinKeyPropertiesProperty{
				UniqueKey: jsii.Boolean(false),
			},
		},
		PhysicalTableId: jsii.String("physicalTableId"),
	},

	// the properties below are optional
	DataTransforms: []interface{}{
		&TransformOperationProperty{
			CastColumnTypeOperation: &CastColumnTypeOperationProperty{
				ColumnName: jsii.String("columnName"),
				NewColumnType: jsii.String("newColumnType"),

				// the properties below are optional
				Format: jsii.String("format"),
				SubType: jsii.String("subType"),
			},
			CreateColumnsOperation: &CreateColumnsOperationProperty{
				Columns: []interface{}{
					&CalculatedColumnProperty{
						ColumnId: jsii.String("columnId"),
						ColumnName: jsii.String("columnName"),
						Expression: jsii.String("expression"),
					},
				},

				// the properties below are optional
				Alias: jsii.String("alias"),
				Source: &TransformOperationSourceProperty{
					TransformOperationId: jsii.String("transformOperationId"),

					// the properties below are optional
					ColumnIdMappings: []interface{}{
						&DataSetColumnIdMappingProperty{
							SourceColumnId: jsii.String("sourceColumnId"),
							TargetColumnId: jsii.String("targetColumnId"),
						},
					},
				},
			},
			FilterOperation: &FilterOperationProperty{
				ConditionExpression: jsii.String("conditionExpression"),
				DateFilterCondition: &DataSetDateFilterConditionProperty{
					ColumnName: jsii.String("columnName"),
					ComparisonFilterCondition: &DataSetDateComparisonFilterConditionProperty{
						Operator: jsii.String("operator"),

						// the properties below are optional
						Value: &DataSetDateFilterValueProperty{
							StaticValue: jsii.String("staticValue"),
						},
					},
					RangeFilterCondition: &DataSetDateRangeFilterConditionProperty{
						IncludeMaximum: jsii.Boolean(false),
						IncludeMinimum: jsii.Boolean(false),
						RangeMaximum: &DataSetDateFilterValueProperty{
							StaticValue: jsii.String("staticValue"),
						},
						RangeMinimum: &DataSetDateFilterValueProperty{
							StaticValue: jsii.String("staticValue"),
						},
					},
				},
				NumericFilterCondition: &DataSetNumericFilterConditionProperty{
					ColumnName: jsii.String("columnName"),
					ComparisonFilterCondition: &DataSetNumericComparisonFilterConditionProperty{
						Operator: jsii.String("operator"),

						// the properties below are optional
						Value: &DataSetNumericFilterValueProperty{
							StaticValue: jsii.Number(123),
						},
					},
					RangeFilterCondition: &DataSetNumericRangeFilterConditionProperty{
						IncludeMaximum: jsii.Boolean(false),
						IncludeMinimum: jsii.Boolean(false),
						RangeMaximum: &DataSetNumericFilterValueProperty{
							StaticValue: jsii.Number(123),
						},
						RangeMinimum: &DataSetNumericFilterValueProperty{
							StaticValue: jsii.Number(123),
						},
					},
				},
				StringFilterCondition: &DataSetStringFilterConditionProperty{
					ColumnName: jsii.String("columnName"),
					ComparisonFilterCondition: &DataSetStringComparisonFilterConditionProperty{
						Operator: jsii.String("operator"),

						// the properties below are optional
						Value: &DataSetStringFilterValueProperty{
							StaticValue: jsii.String("staticValue"),
						},
					},
					ListFilterCondition: &DataSetStringListFilterConditionProperty{
						Operator: jsii.String("operator"),

						// the properties below are optional
						Values: &DataSetStringListFilterValueProperty{
							StaticValues: []*string{
								jsii.String("staticValues"),
							},
						},
					},
				},
			},
			OverrideDatasetParameterOperation: &OverrideDatasetParameterOperationProperty{
				ParameterName: jsii.String("parameterName"),

				// the properties below are optional
				NewDefaultValues: &NewDefaultValuesProperty{
					DateTimeStaticValues: []*string{
						jsii.String("dateTimeStaticValues"),
					},
					DecimalStaticValues: []interface{}{
						jsii.Number(123),
					},
					IntegerStaticValues: []interface{}{
						jsii.Number(123),
					},
					StringStaticValues: []*string{
						jsii.String("stringStaticValues"),
					},
				},
				NewParameterName: jsii.String("newParameterName"),
			},
			ProjectOperation: &ProjectOperationProperty{
				Alias: jsii.String("alias"),
				ProjectedColumns: []*string{
					jsii.String("projectedColumns"),
				},
				Source: &TransformOperationSourceProperty{
					TransformOperationId: jsii.String("transformOperationId"),

					// the properties below are optional
					ColumnIdMappings: []interface{}{
						&DataSetColumnIdMappingProperty{
							SourceColumnId: jsii.String("sourceColumnId"),
							TargetColumnId: jsii.String("targetColumnId"),
						},
					},
				},
			},
			RenameColumnOperation: &RenameColumnOperationProperty{
				ColumnName: jsii.String("columnName"),
				NewColumnName: jsii.String("newColumnName"),
			},
			TagColumnOperation: &TagColumnOperationProperty{
				ColumnName: jsii.String("columnName"),
				Tags: []ColumnTagProperty{
					&ColumnTagProperty{
						ColumnDescription: &ColumnDescriptionProperty{
							Text: jsii.String("text"),
						},
						ColumnGeographicRole: jsii.String("columnGeographicRole"),
					},
				},
			},
			UntagColumnOperation: &UntagColumnOperationProperty{
				ColumnName: jsii.String("columnName"),
				TagNames: []*string{
					jsii.String("tagNames"),
				},
			},
		},
	},
}

Properties ​

aliasstringaliasstraliasStringAliasstringAlias*stringrequired#
<p>A display name for the logical table.</p>.
dataTransformsoptionalIResolvable | IResolvable | CfnDataSet.TransformOperationProperty[]data_transformsoptionaltyping.Union[IResolvable, typing.List[typing.Union[IResolvable, TransformOperationProperty]]]dataTransformsoptionalIResolvableDataTransformsoptionalIResolvableDataTransformsoptionalinterface{}#
<p>Transform operations that act on this logical table.

For this structure to be valid, only one of the attributes can be non-null. </p>

<p>Information about the source of a logical table.

This is a variant type structure. For this structure to be valid, only one of the attributes can be non-null.</p>