> ## Documentation Index
> Fetch the complete documentation index at: https://docs.maia.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Filter

export const ComponentMetadata = ({warehouses, unsupportedWarehouses = [], componentType, connectionInputs, connectionOutputs}) => {
  const allWarehouses = [...warehouses.map(w => ({
    name: w,
    supported: true
  })), ...unsupportedWarehouses.map(w => ({
    name: w,
    supported: false
  }))];
  return <div style={{
    background: 'var(--colors-background-light, #f9fafb)',
    border: '1px solid var(--colors-border-default, #e5e7eb)',
    borderRadius: '12px',
    padding: '20px 28px',
    marginBottom: '28px',
    boxShadow: '0 1px 4px rgba(0,0,0,0.10)'
  }}>
      <table style={{
    width: '100%',
    borderCollapse: 'collapse'
  }}>
        <tbody>
          <tr>
            <td style={{
    fontWeight: '600',
    paddingRight: '32px',
    paddingBottom: '14px',
    whiteSpace: 'nowrap',
    verticalAlign: 'middle',
    width: '180px'
  }}>Project Availability</td>
            <td style={{
    paddingBottom: '14px',
    verticalAlign: 'middle'
  }}>
              <div style={{
    display: 'flex',
    flexWrap: 'wrap',
    gap: '8px'
  }}>
                {allWarehouses.map((w, i) => <span key={i} style={{
    background: w.supported ? '#dcfce7' : '#fee2e2',
    color: w.supported ? '#15803d' : '#b91c1c',
    border: `1px solid ${w.supported ? '#bbf7d0' : '#fca5a5'}`,
    borderRadius: '9999px',
    padding: '3px 12px',
    fontSize: '0.85rem',
    fontWeight: '500',
    whiteSpace: 'nowrap'
  }}>
                    {w.name} {w.supported ? '✅' : '❌'}
                  </span>)}
              </div>
            </td>
          </tr>
          <tr>
            <td style={{
    fontWeight: '600',
    paddingRight: '32px',
    paddingBottom: '14px',
    whiteSpace: 'nowrap',
    verticalAlign: 'middle'
  }}>Component Type</td>
            <td style={{
    paddingBottom: '14px',
    verticalAlign: 'middle'
  }}>{componentType}</td>
          </tr>
          <tr>
            <td style={{
    fontWeight: '600',
    paddingRight: '32px',
    paddingBottom: '14px',
    whiteSpace: 'nowrap',
    verticalAlign: 'middle'
  }}>Connection Inputs</td>
            <td style={{
    paddingBottom: '14px',
    verticalAlign: 'middle'
  }}>{connectionInputs}</td>
          </tr>
          <tr>
            <td style={{
    fontWeight: '600',
    paddingRight: '32px',
    whiteSpace: 'nowrap',
    verticalAlign: 'middle'
  }}>Connection Outputs</td>
            <td style={{
    verticalAlign: 'middle'
  }}>{connectionOutputs}</td>
          </tr>
        </tbody>
      </table>
    </div>;
};

<ComponentMetadata warehouses={["Snowflake", "Databricks", "Amazon Redshift", "Google BigQuery"]} componentType="Transformation" connectionInputs="One" connectionOutputs="Unlimited" />

The **Filter** transformation component lets you filter a dataset and return rows according to criteria of your choice. You can combine multiple filter criteria using AND or OR logic.

This component is equivalent to writing a SELECT WHERE query.

### Use case

This component can be used to narrow down the data you are processing, so you can focus on what is most relevant. For example, you can use it to:

* Filter a financial dataset by transaction value to see your highest-value orders.
* Filter recent customer interactions by date to analyze customer behavior within the past 30 days.
* Filter customer data by different criteria so you can target different customer groups with tailored ads.

***

## Properties

<Tabs>
  <Tab title="Snowflake">
    <ResponseField name="Name" type="string" required>
      A human-readable name for the component.
    </ResponseField>

    {/* <!-- param-start:[mode] | warehouses: [snowflake] --> */}

    <ResponseField name="Mode" type="drop-down">
      Select how you will configure the filter:

      * **Basic:** In this mode, you specify filter conditions using the dialog box in the `Filter conditions` property.
      * **Advanced:** In this mode, you write a custom SQL expression in the `Filter clause` property.
    </ResponseField>

    {/* <!-- param-start:[filterConditions] | warehouses: [snowflake] --> */}

    <ResponseField name="Filter conditions" type="expression editor" required>
      Only used in **Basic** mode.

      **Input column:** Choose a column from your input table that you will apply this filter to.

      **Qualifier:** Select whether matching rows in the data should be included (**Is**, the default) or excluded (**Not**).

      **Comparator:** Select from:

      * **Less than:** The value in the Input Column must be less than that specified in the Value Column. For more information, read the [Snowflake comparison operators documentation](https://docs.snowflake.com/en/sql-reference/operators-comparison).
      * **Less than or equal to:** The value in the Input Column must be less than or equal to that specified in the Value Column. For more information, read the [Snowflake comparison operators documentation](https://docs.snowflake.com/en/sql-reference/operators-comparison).
      * **Equal to:** The value in the Input Column must be equal to that specified in the Value Column. For more information, read the [Snowflake comparison operators documentation](https://docs.snowflake.com/en/sql-reference/operators-comparison).
      * **Greater than:** The value in the Input Column must be greater than that specified in the Value Column. For more information, read the [Snowflake comparison operators documentation](https://docs.snowflake.com/en/sql-reference/operators-comparison).
      * **Greater than or equal to:** The value in the Input Column must be greater than or equal to that specified in the Value Column. For more information, read the [Snowflake comparison operators documentation](https://docs.snowflake.com/en/sql-reference/operators-comparison).
      * **Like:** Case-sensitive match of the value in the Input Column and the pattern in the Value Column. For more information, read the [Snowflake LIKE documentation](https://docs.snowflake.com/en/sql-reference/functions/like).
      * **ILike:** Case-insensitive match of the value in the Input Column and the pattern in the Value Column. For more information, read the [Snowflake ILIKE documentation](https://docs.snowflake.com/en/sql-reference/functions/ilike).
      * **Similar to:** Matches the value in the Input Column with a SQL standard regular expression pattern in the Value column. For more information, read the [Snowflake REGEXP\_LIKE documentation](https://docs.snowflake.com/en/sql-reference/functions/regexp_like).
      * **Null:** Checks whether the value of the Input Column is the SQL "null" value. For more information, read the [Snowflake IS NULL documentation](https://docs.snowflake.com/en/sql-reference/functions/is-null).
      * **Blank:** Checks whether the value of the Input Column is an empty string. For more information, read the [Snowflake IS NULL documentation](https://docs.snowflake.com/en/sql-reference/functions/is-null).
      * **Null or blank:** Checks whether the value of the Input Column is an empty string or the SQL "null" value. For more information, read the [Snowflake IS NULL documentation](https://docs.snowflake.com/en/sql-reference/functions/is-null).

      **Value:** The value entered by the user to use for comparison. If this value is enclosed in double quotes, it will be treated as a column in the generated SQL, which will allow for comparing columns.

      Click the **Text mode** toggle at the bottom of the dialog to open a multi-line editor that lets you add items in a single block. For more information, read [Text mode](/docs/guides/components-overview#text-mode).

      To use grid variables, toggle **Use Grid Variable** on at the bottom of the dialog. For more information, read [Grid variables](/docs/guides/grid-variables).
    </ResponseField>

    {/* <!-- param-start:[combineCondition] | warehouses: [snowflake] --> */}

    <ResponseField name="Combine condition" type="drop-down" required>
      Only used in **Basic** mode.

      When multiple filter conditions are present, they can be separated by **AND** or **OR**.

      * **AND:** All the filter conditions must be true.
      * **OR:** Any of the filter conditions must be true.

      For more complex conditions involving grouping several **AND** and **OR** conditions together, you can use one of the following options:

      * Use **Advanced** mode to write a custom SQL expression that combines conditions in any way you like.
      * Create a new field using a [Calculator](/docs/components/calculator) component that specifies your complex condition, and then use that new field in a filter condition.
    </ResponseField>

    {/* <!-- param-start:[filterClause] | warehouses: [snowflake] --> */}

    <ResponseField name="Filter clause" type="expression editor" required>
      Only used in **Advanced** mode.

      Write an SQL **WHERE** clause to specify the filter condition. For example, you could write `"score" BETWEEN 70 AND 80` to filter for rows where a numeric score value is between 70 and 80. Do not include the WHERE keyword in this expression, just the clause that would come after it.

      You can use the Maia prompt to help you write the SQL expression for this property by describing the required output in natural language. For example, you could write "Filter for rows where score is between 70 and 80" to get the above example expression.
    </ResponseField>
  </Tab>

  <Tab title="Databricks">
    <ResponseField name="Name" type="string" required>
      A human-readable name for the component.
    </ResponseField>

    {/* <!-- param-start:[mode] | warehouses: [databricks] --> */}

    <ResponseField name="Mode" type="drop-down">
      Select how you will configure the filter:

      * **Basic:** In this mode, you specify filter conditions using the dialog box in the `Filter conditions` property.
      * **Advanced:** In this mode, you write a custom SQL expression in the `Filter clause` property.
    </ResponseField>

    {/* <!-- param-start:[filterConditions] | warehouses: [databricks] --> */}

    <ResponseField name="Filter conditions" type="expression editor" required>
      Only used in **Basic** mode.

      **Input column:** Choose a column from your input table that you will apply this filter to.

      **Qualifier:** Select whether matching rows in the data should be included (**Is**, the default) or excluded (**Not**).

      **Comparator:** Select from:

      * **Less than:** The value in the Input Column must be less than that specified in the Value Column. For more information, read the [Databricks comparison operators documentation](https://docs.databricks.com/en/sql/language-manual/functions/eqsign.html).
      * **Less than or equal to:** The value in the Input Column must be less than or equal to that specified in the Value Column. For more information, read the [Databricks comparison operators documentation](https://docs.databricks.com/en/sql/language-manual/functions/eqsign.html).
      * **Equal to:** The value in the Input Column must be equal to that specified in the Value Column. For more information, read the [Databricks comparison operators documentation](https://docs.databricks.com/en/sql/language-manual/functions/eqsign.html).
      * **Greater than:** The value in the Input Column must be greater than that specified in the Value Column. For more information, read the [Databricks comparison operators documentation](https://docs.databricks.com/en/sql/language-manual/functions/eqsign.html).
      * **Greater than or equal to:** The value in the Input Column must be greater than or equal to that specified in the Value Column. For more information, read the [Databricks comparison operators documentation](https://docs.databricks.com/en/sql/language-manual/functions/eqsign.html).
      * **Like:** Case-sensitive match of the value in the Input Column and the pattern in the Value Column. For more information, read the [Databricks LIKE documentation](https://docs.databricks.com/en/sql/language-manual/functions/like.html).
      * **ILike:** Case-insensitive match of the value in the Input Column and the pattern in the Value Column. For more information, read the [Databricks ILIKE documentation](https://docs.databricks.com/en/sql/language-manual/functions/ilike.html).
      * **Similar to:** Matches the value in the Input Column with a SQL standard regular expression pattern in the Value column. For more information, read the [Databricks RLIKE documentation](https://docs.databricks.com/en/sql/language-manual/functions/rlike.html).
      * **Null:** Checks whether the value of the Input Column is the SQL "null" value. For more information, read the [Databricks IS NULL documentation](https://docs.databricks.com/aws/en/sql/language-manual/functions/isnullop).
      * **Blank:** Checks whether the value of the Input Column is an empty string. For more information, read the [Databricks IS NULL documentation](https://docs.databricks.com/aws/en/sql/language-manual/functions/isnullop).
      * **Null or blank:** Checks whether the value of the Input Column is an empty string or the SQL "null" value. For more information, read the [Databricks IS NULL documentation](https://docs.databricks.com/aws/en/sql/language-manual/functions/isnullop).

      **Value:** The value entered by the user to use for comparison. If this value is enclosed in double quotes, it will be treated as a column in the generated SQL, which will allow for comparing columns.

      Click the **Text mode** toggle at the bottom of the dialog to open a multi-line editor that lets you add items in a single block. For more information, read [Text mode](/docs/guides/components-overview#text-mode).

      To use grid variables, toggle **Use Grid Variable** on at the bottom of the dialog. For more information, read [Grid variables](/docs/guides/grid-variables).
    </ResponseField>

    {/* <!-- param-start:[combineCondition] | warehouses: [databricks] --> */}

    <ResponseField name="Combine condition" type="drop-down" required>
      Only used in **Basic** mode.

      When multiple filter conditions are present, they can be separated by **AND** or **OR**.

      * **AND:** All the filter conditions must be true.
      * **OR:** Any of the filter conditions must be true.

      For more complex conditions involving grouping several **AND** and **OR** conditions together, you can use one of the following options:

      * Use **Advanced** mode to write a custom SQL expression that combines conditions in any way you like.
      * Create a new field using a [Calculator](/docs/components/calculator) component that specifies your complex condition, and then use that new field in a filter condition.
    </ResponseField>

    {/* <!-- param-start:[filterClause] | warehouses: [databricks] --> */}

    <ResponseField name="Filter clause" type="expression editor" required>
      Only used in **Advanced** mode.

      Write an SQL **WHERE** clause to specify the filter condition. For example, you could write `"score" BETWEEN 70 AND 80` to filter for rows where a numeric score value is between 70 and 80. Do not include the WHERE keyword in this expression, just the clause that would come after it.

      You can use the Maia prompt to help you write the SQL expression for this property by describing the required output in natural language. For example, you could write "Filter for rows where score is between 70 and 80" to get the above example expression.
    </ResponseField>
  </Tab>

  <Tab title="Amazon Redshift">
    <ResponseField name="Name" type="string" required>
      A human-readable name for the component.
    </ResponseField>

    {/* <!-- param-start:[mode] | warehouses: [redshift] --> */}

    <ResponseField name="Mode" type="drop-down">
      Select how you will configure the filter:

      * **Basic:** In this mode, you specify filter conditions using the dialog box in the `Filter conditions` property.
      * **Advanced:** In this mode, you write a custom SQL expression in the `Filter clause` property.
    </ResponseField>

    {/* <!-- param-start:[filterConditions] | warehouses: [redshift] --> */}

    <ResponseField name="Filter conditions" type="expression editor" required>
      Only used in **Basic** mode.

      **Input column:** Choose a column from your input table that you will apply this filter to.

      **Qualifier:** Select whether matching rows in the data should be included (**Is**, the default) or excluded (**Not**).

      **Comparator:** Select from:

      * **Less than:** The value in the Input Column must be less than that specified in the Value Column. For more information, read the [Amazon Redshift comparison condition documentation](https://docs.aws.amazon.com/redshift/latest/dg/r_comparison_condition.html).
      * **Less than or equal to:** Value in the Input Column must be less than or equal to that specified in the Value Column. For more information, read the [Amazon Redshift comparison condition documentation](https://docs.aws.amazon.com/redshift/latest/dg/r_comparison_condition.html).
      * **Equal to:** The value in the Input Column must be equal to that specified in the Value Column. For more information, read the [Amazon Redshift comparison condition documentation](https://docs.aws.amazon.com/redshift/latest/dg/r_comparison_condition.html).
      * **Greater than:** The value in the Input Column must be greater than that specified in the Value Column. For more information, read the [Amazon Redshift comparison condition documentation](https://docs.aws.amazon.com/redshift/latest/dg/r_comparison_condition.html).
      * **Greater than or equal to:** The value in the Input Column must be greater than or equal to that specified in the Value Column. For more information, read the [Amazon Redshift comparison condition documentation](https://docs.aws.amazon.com/redshift/latest/dg/r_comparison_condition.html).
      * **Like:** Case-sensitive match of the value in the Input Column and the pattern in the Value Column. For more information, read the [Amazon Redshift LIKE documentation](https://docs.aws.amazon.com/redshift/latest/dg/r_patternmatching_condition_like.html).
      * **ILike:** Case-insensitive match of the value in the Input Column and the pattern in the Value Column. For more information, read the [Amazon Redshift LIKE documentation](https://docs.aws.amazon.com/redshift/latest/dg/r_patternmatching_condition_like.html).
      * **Similar to:** Matches the value in the Input Column with a SQL standard regular expression pattern in the Value column. For more information, read the [Amazon Redshift SIMILAR TO documentation](https://docs.aws.amazon.com/redshift/latest/dg/pattern-matching-conditions-similar-to.html).
      * **Null:** Checks whether the value of the Input Column is the SQL "null" value. For more information, read the [Amazon Redshift NULL condition documentation](https://docs.aws.amazon.com/redshift/latest/dg/r_Null_condition.html).
      * **Blank:** Checks whether the value of the Input Column is an empty string. For more information, read the [Amazon Redshift NULL condition documentation](https://docs.aws.amazon.com/redshift/latest/dg/r_Null_condition.html).
      * **Null or blank:** Checks whether the value of the Input Column is an empty string or the SQL "null" value. For more information, read the [Amazon Redshift NULL condition documentation](https://docs.aws.amazon.com/redshift/latest/dg/r_Null_condition.html).

      **Value:** The value entered by the user to use for comparison. If this value is enclosed in double quotes, it will be treated as a column in the generated SQL, which will allow for comparing columns.

      Click the **Text mode** toggle at the bottom of the dialog to open a multi-line editor that lets you add items in a single block. For more information, read [Text mode](/docs/guides/components-overview#text-mode).

      To use grid variables, toggle **Use Grid Variable** on at the bottom of the dialog. For more information, read [Grid variables](/docs/guides/grid-variables).
    </ResponseField>

    {/* <!-- param-start:[combineCondition] | warehouses: [redshift] --> */}

    <ResponseField name="Combine condition" type="drop-down" required>
      Only used in **Basic** mode.

      When multiple filter conditions are present, they can be separated by **AND** or **OR**.

      * **AND:** All the filter conditions must be true.
      * **OR:** Any of the filter conditions must be true.

      For more complex conditions involving grouping several **AND** and **OR** conditions together, you can use one of the following options:

      * Use **Advanced** mode to write a custom SQL expression that combines conditions in any way you like.
      * Create a new field using a [Calculator](/docs/components/calculator) component that specifies your complex condition, and then use that new field in a filter condition.
    </ResponseField>

    {/* <!-- param-start:[filterClause] | warehouses: [redshift] --> */}

    <ResponseField name="Filter clause" type="expression editor" required>
      Only used in **Advanced** mode.

      Write an SQL **WHERE** clause to specify the filter condition. For example, you could write `"score" BETWEEN 70 AND 80` to filter for rows where a numeric score value is between 70 and 80. Do not include the WHERE keyword in this expression, just the clause that would come after it.

      You can use the Maia prompt to help you write the SQL expression for this property by describing the required output in natural language. For example, you could write "Filter for rows where score is between 70 and 80" to get the above example expression.
    </ResponseField>
  </Tab>

  <Tab title="Google BigQuery">
    <ResponseField name="Name" type="string" required>
      A human-readable name for the component.
    </ResponseField>

    {/* <!-- param-start:[mode] | warehouses: [bigquery] --> */}

    <ResponseField name="Mode" type="drop-down">
      Select how you will configure the filter:

      * **Basic:** In this mode, you specify filter conditions using the dialog box in the `Filter conditions` property.
      * **Advanced:** In this mode, you write a custom SQL expression in the `Filter clause` property.
    </ResponseField>

    {/* <!-- param-start:[filterConditions] | warehouses: [bigquery] --> */}

    <ResponseField name="Filter conditions" type="expression editor" required>
      Only used in **Basic** mode.

      **Input column:** Choose a column from your input table that you will apply this filter to.

      **Qualifier:** Select whether matching rows in the data should be included (**Is**, the default) or excluded (**Not**).

      **Comparator:** Select from:

      * **Less than:** The value in the Input Column must be less than that specified in the Value Column. For more information, read the [Google BigQuery comparison operators documentation](https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/operators#comparison_operators).
      * **Less than or equal to:** The value in the Input Column must be less than or equal to that specified in the Value Column. For more information, read the [Google BigQuery comparison operators documentation](https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/operators#comparison_operators).
      * **Equal to:** The value in the Input Column must be equal to that specified in the Value Column. For more information, read the [Google BigQuery comparison operators documentation](https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/operators#comparison_operators).
      * **Greater than:** The value in the Input Column must be greater than that specified in the Value Column. For more information, read the [Google BigQuery comparison operators documentation](https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/operators#comparison_operators).
      * **Greater than or equal to:** The value in the Input Column must be greater than or equal to that specified in the Value Column. For more information, read the [Google BigQuery comparison operators documentation](https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/operators#comparison_operators).
      * **Like:** Case-sensitive match of the value in the Input Column and the pattern in the Value Column. For more information, read the [Google BigQuery LIKE operator documentation](https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/operators#like_operator).
      * **Null:** Checks whether the value of the Input Column is the SQL "null" value. For more information, read the [Google BigQuery IS NULL operator documentation](https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/operators).
      * **Blank:** Checks whether the value of the Input Column is an empty string. For more information, read the [Google BigQuery IS NULL operator documentation](https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/operators#is_operators).
      * **Null or blank:** Checks whether the value of the Input Column is an empty string or the SQL "null" value. For more information, read the [Google BigQuery IS NULL operator documentation](https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/operators).
      * **Regexp contains:** Matches the value in the Input Column against a regular expression pattern in the Value column. For more information, read the [Google BigQuery REGEXP\_CONTAINS documentation](https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/string_functions#regexp_contains).

      **Value:** The value entered by the user to use for comparison. If this value is enclosed in double quotes, it will be treated as a column in the generated SQL, which will allow for comparing columns.

      Click the **Text mode** toggle at the bottom of the dialog to open a multi-line editor that lets you add items in a single block. For more information, read [Text mode](/docs/guides/components-overview#text-mode).

      To use grid variables, toggle **Use Grid Variable** on at the bottom of the dialog. For more information, read [Grid variables](/docs/guides/grid-variables).
    </ResponseField>

    {/* <!-- param-start:[combineCondition] | warehouses: [bigquery] --> */}

    <ResponseField name="Combine condition" type="drop-down" required>
      Only used in **Basic** mode.

      When multiple filter conditions are present, they can be separated by **AND** or **OR**.

      * **AND:** All the filter conditions must be true.
      * **OR:** Any of the filter conditions must be true.

      For more complex conditions involving grouping several **AND** and **OR** conditions together, you can use one of the following options:

      * Use **Advanced** mode to write a custom SQL expression that combines conditions in any way you like.
      * Create a new field using a [Calculator](/docs/components/calculator) component that specifies your complex condition, and then use that new field in a filter condition.
    </ResponseField>

    {/* <!-- param-start:[filterClause] | warehouses: [bigquery] --> */}

    <ResponseField name="Filter clause" type="expression editor" required>
      Only used in **Advanced** mode.

      Write an SQL **WHERE** clause to specify the filter condition. For example, you could write `"score" BETWEEN 70 AND 80` to filter for rows where a numeric score value is between 70 and 80. Do not include the WHERE keyword in this expression, just the clause that would come after it.

      You can use the Maia prompt to help you write the SQL expression for this property by describing the required output in natural language. For example, you could write "Filter for rows where score is between 70 and 80" to get the above example expression.
    </ResponseField>
  </Tab>
</Tabs>

## Working with dates

Values representing a constant date/time need to be single-quoted so that they are recognized by Snowflake. The following formats are recognized by the Filter component, and will be quoted automatically:

* yyyy-MM-dd
* yyyy-MM-dd HH:mm:ss
* yyyy-MM-dd HH:mm:ss +HH:mm
* yyyy-MM-dd HH:mm:ss.SSSSSS
* yyyy-MM-dd hh:mm:ss.SSSSSS +HH:mm
* yyyy-MM-ddThh:mm:ss.SSSSSSZ

Other date/time formats recognized by Snowflake will work if they are single-quoted in the **Filter** property, such as RFC format 'Thu, 21 Dec 2000 04:01:07 PM'.

Read the following documentation for a complete list of what the following cloud platforms will recognize automatically:

* [Snowflake documentation](https://docs.snowflake.com/en/user-guide/date-time-input-output.html#supported-formats-for-auto-detection)
* [Databricks documentation](https://docs.databricks.com/en/sql/language-manual/sql-ref-datetime-pattern.html)
* [Amazon Redshift documentation](https://docs.aws.amazon.com/redshift/latest/dg/automatic-recognition.html)
* [Google BigQuery documentation](https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/format-elements#format_elements_date_time)

Functions and column references can also be used in this component. Values such as the following will work as expected:

* CURRENT\_TIMESTAMP()
* "anotherDateColumn" + 365

***

## Examples

```
Input Data

+-------------------+------+-------+------------+
|       EMAIL       | EXAM | SCORE |    DATE    |
+-------------------+------+-------+------------+
| tgf@gmail.com     | math |    66 | 2022-02-24 |
| toml@gmail.com    | math |    78 | 2022-01-25 |
| jenny1@gmail.com  | chem |    44 | 2021-11-05 |
| lucygh@aol.com    | chem |    70 | 2022-02-13 |
| suecool@gmail.com | math |    89 | 2022-01-29 |
+-------------------+------+-------+------------+
```

<Tabs>
  <Tab title="Example 1">
    **Finding all passing grades**

    We can use "Greater than" comparators on integer type columns to find values greater than a given value.

    **Filter component properties:**

    * **Filter Conditions:**
      * **Input column:** SCORE
      * **Qualifier:** Is
      * **Comparator:** Greater than or equal to
      * **Value:** 70
    * **Combine Conditions:** (We have a single filter so this doesn't matter)

    ```
    Output Data

    +-------------------+------+-------+------------+
    |       EMAIL       | EXAM | SCORE |    DATE    |
    +-------------------+------+-------+------------+
    | toml@gmail.com    | math |    78 | 2022-01-25 |
    | lucygh@aol.com    | chem |    70 | 2022-02-13 |
    | suecool@gmail.com | math |    89 | 2022-01-29 |
    +-------------------+------+-------+------------+
    ```
  </Tab>

  <Tab title="Example 2">
    **Passing grades with gmail addresses**

    Like, ILike and Similar to allow you to filter column values using a regular expression.

    **Filter component properties:**

    * **Filter Conditions:**
      * Input Column: SCORE
        * Qualifier: Is
        * Comparator: Greater than or equal to
        * Value: 70
      * Input Column: EMAIL
        * Qualifier: Is
        * Comparator: Similar to
        * Value: ^\[^@][+@gmail.com](mailto:+@gmail.com)\$
    * **Combine Conditions:** AND

    ```
    Output Data

    +-------------------+------+-------+------------+
    |       EMAIL       | EXAM | SCORE |    DATE    |
    +-------------------+------+-------+------------+
    | toml@gmail.com    | math |    78 | 2022-01-25 |
    | suecool@gmail.com | math |    89 | 2022-01-29 |
    +-------------------+------+-------+------------+
    ```

    You could instead use the **Like** comparator with equivalent value **%gmail\\.com** to do the same email filtering.
  </Tab>

  <Tab title="Example 3">
    **Finding exams after January 2022**

    We can use "Greater than" comparators on date type columns to find dates after a given value. This requires that date values are in a recognized format.

    **Filter component properties:**

    * **Filter Conditions:**
      * Input Column: DATE
      * Qualifier: Is
      * Comparator: Greater than
      * Value: 2022-01-31
    * **Combine Conditions:** (We have a single filter so this doesn't matter)

    ```
    Output Data

    +-------------------+------+-------+------------+
    |       EMAIL       | EXAM | SCORE |    DATE    |
    +-------------------+------+-------+------------+
    | tgf@gmail.com     | math |    66 | 2022-02-24 |
    | lucygh@aol.com    | chem |    70 | 2022-02-13 |
    +-------------------+------+-------+------------+
    ```
  </Tab>
</Tabs>