aws-cdk-lib.aws_quicksight.CfnDataSet.FilterOperationProperty

FilterOperationProperty Struct

A transform operation that filters rows based on a condition.

Source

Generated code

Type last changed

v2.224.0 · 13 Nov 2025

Example

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import { aws_quicksight as quicksight } from 'aws-cdk-lib';
const filterOperationProperty: quicksight.CfnDataSet.FilterOperationProperty = {
  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'],
      },
    },
  },
};

# 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

filter_operation_property = 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"]
            )
        )
    )
)

// 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.*;

FilterOperationProperty filterOperationProperty = 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();

// 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 filterOperationProperty = 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" }
            }
        }
    }
};

// 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"

filterOperationProperty := &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"),
				},
			},
		},
	},
}

Properties

conditionExpression?optionalstringcondition_expression?optionalstrconditionExpression?optionalStringConditionExpression?optionalstringConditionExpression?optional*string#

An expression that must evaluate to a Boolean value.

Rows for which the expression evaluates to true are kept in the dataset.

dateFilterCondition?optionalIResolvable | CfnDataSet.DataSetDateFilterConditionPropertydate_filter_condition?optionaltyping.Union[IResolvable, DataSetDateFilterConditionProperty]dateFilterCondition?optionalIResolvableDateFilterCondition?optionalIResolvableDateFilterCondition?optionalinterface{}#

A date-based filter condition within a filter operation.

numericFilterCondition?optionalIResolvable | CfnDataSet.DataSetNumericFilterConditionPropertynumeric_filter_condition?optionaltyping.Union[IResolvable, DataSetNumericFilterConditionProperty]numericFilterCondition?optionalIResolvableNumericFilterCondition?optionalIResolvableNumericFilterCondition?optionalinterface{}#

A numeric-based filter condition within a filter operation.

stringFilterCondition?optionalIResolvable | CfnDataSet.DataSetStringFilterConditionPropertystring_filter_condition?optionaltyping.Union[IResolvable, DataSetStringFilterConditionProperty]stringFilterCondition?optionalIResolvableStringFilterCondition?optionalIResolvableStringFilterCondition?optionalinterface{}#

A string-based filter condition within a filter operation.