Skip to content
v2.277.0

TransformOperationProperty Struct ​

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.

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 transformOperationProperty: quicksight.CfnDataSet.TransformOperationProperty = {
  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

transform_operation_property = 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.*;

TransformOperationProperty transformOperationProperty = 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();
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 transformOperationProperty = 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"

transformOperationProperty := &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 ​

castColumnTypeOperationoptionalIResolvable | CfnDataSet.CastColumnTypeOperationPropertycast_column_type_operationoptionaltyping.Union[IResolvable, CastColumnTypeOperationProperty]castColumnTypeOperationoptionalIResolvableCastColumnTypeOperationoptionalIResolvableCastColumnTypeOperationoptionalinterface{}#
A transform operation that casts a column to a different type.
createColumnsOperationoptionalIResolvable | CfnDataSet.CreateColumnsOperationPropertycreate_columns_operationoptionaltyping.Union[IResolvable, CreateColumnsOperationProperty]createColumnsOperationoptionalIResolvableCreateColumnsOperationoptionalIResolvableCreateColumnsOperationoptionalinterface{}#
An operation that creates calculated columns.

Columns created in one such operation form a lexical closure.

filterOperationoptionalIResolvable | CfnDataSet.FilterOperationPropertyfilter_operationoptionaltyping.Union[IResolvable, FilterOperationProperty]filterOperationoptionalIResolvableFilterOperationoptionalIResolvableFilterOperationoptionalinterface{}#
An operation that filters rows based on some condition.
overrideDatasetParameterOperationoptionalIResolvable | CfnDataSet.OverrideDatasetParameterOperationPropertyoverride_dataset_parameter_operationoptionaltyping.Union[IResolvable, OverrideDatasetParameterOperationProperty]overrideDatasetParameterOperationoptionalIResolvableOverrideDatasetParameterOperationoptionalIResolvableOverrideDatasetParameterOperationoptionalinterface{}#
A transform operation that overrides the dataset parameter values that are defined in another dataset.
projectOperationoptionalIResolvable | CfnDataSet.ProjectOperationPropertyproject_operationoptionaltyping.Union[IResolvable, ProjectOperationProperty]projectOperationoptionalIResolvableProjectOperationoptionalIResolvableProjectOperationoptionalinterface{}#
An operation that projects columns.

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

renameColumnOperationoptionalIResolvable | CfnDataSet.RenameColumnOperationPropertyrename_column_operationoptionaltyping.Union[IResolvable, RenameColumnOperationProperty]renameColumnOperationoptionalIResolvableRenameColumnOperationoptionalIResolvableRenameColumnOperationoptionalinterface{}#
An operation that renames a column.
tagColumnOperationoptionalIResolvable | CfnDataSet.TagColumnOperationPropertytag_column_operationoptionaltyping.Union[IResolvable, TagColumnOperationProperty]tagColumnOperationoptionalIResolvableTagColumnOperationoptionalIResolvableTagColumnOperationoptionalinterface{}#
An operation that tags a column with additional information.
untagColumnOperationoptionalIResolvable | CfnDataSet.UntagColumnOperationPropertyuntag_column_operationoptionaltyping.Union[IResolvable, UntagColumnOperationProperty]untagColumnOperationoptionalIResolvableUntagColumnOperationoptionalIResolvableUntagColumnOperationoptionalinterface{}#
<p>A transform operation that removes tags associated with a column.</p>.