3.3 Filter Tool & True/False Anchors

3.3 Filter Tool & True/False Anchors

Core Concept: The Filter tool bifurcates a data stream into two distinct output streams based on conditional criteria. Unlike database WHERE clauses or spreadsheet filters that discard non-matching rows, Alteryx routes matching records to the T (True) anchor and non-matching records to the F (False) anchor. This dual-output architecture enables parallel processing, exception logging, and multi-tier data routing without losing a single record.

---

1. Filter Tool Architecture & Record Conservation

The Filter tool features one input anchor (Input) and two output anchors: T (True) and F (False).

                      ┌─────────────────┐
                      │   Filter Tool   │
  [Input Stream] ────►│   Condition:    ├───► [T Anchor] (Records Meeting Condition)
   (100 Records)      │  [Sales] > 500  ├───► [F Anchor] (Records Failing / Nulls)
                      └─────────────────┘

The Law of Record Conservation

Every single record entering the Filter tool must exit through either T or F:

$\text{Total Input Records} = \text{Records}_{\text{True}} + \text{Records}_{\text{False}}$

No records are ever destroyed, duplicated, or lost inside a Filter tool. If an input stream containing 1,000 records outputs 650 records through the T anchor, exactly 350 records will exit through the F anchor.

---

2. Basic Filter Mode vs. Custom Filter Mode

The Filter tool configuration window offers two operating modes: Basic Filter and Custom Filter.

┌────────────────────────────────────────────────────────────────────────────────────────┐
│ Basic Filter Configuration Interface                                                   │
├────────────────────────────────────────────────────────────────────────────────────────┤
│ (•) Basic Filter      ( ) Custom Filter                                                │
│                                                                                        │
│ 1. Select Field:     [ Region                ▼ ]                                       │
│ 2. Select Operator:  [ Equals                ▼ ]                                       │
│ 3. Enter Value:      [ West                    ]                                       │
└────────────────────────────────────────────────────────────────────────────────────────┘

Basic Filter Mode

Basic Filter mode provides a guided, no-code interface restricted to evaluating a single condition on a single field.

• String Operators: Equals, Does not equal, Contains, Does not contain, Starts with, Ends with, Is Empty, Is Not Empty, Is Null, Is Not Null.
• Numeric Operators: =, !=, <, <=, >, >=, Is Null, Is Not Null.
• Date Operators: =, !=, <, <=, >, >=, Is Between, Today(), Current Month, or relative date offsets.

Custom Filter Mode

Custom Filter mode allows analysts to write complex, multi-field boolean expressions using the full Alteryx Formula syntax.

• When you switch from Basic Filter to Custom Filter, Alteryx automatically converts the basic rule into its formula equivalent (e.g., [Region] = "West"), providing an excellent bridge for learning expression syntax.

---

3. Custom Filter Expression Syntax & Logical Operators

Custom filters evaluate expressions to a boolean result (True or False). Records evaluating to True exit via T; records evaluating to False or Null exit via F.

Syntax Conventions

• Field Names: Must be enclosed in square brackets [FieldName].
• String Literals: Must be enclosed in double quotes "Text" or single quotes 'Text'.
• Numeric Literals: Entered as raw digits without quotes, commas, or currency symbols (e.g., 1500 or 24.95).
• Boolean Constants: 1 or True, 0 or False.

Logical Operators and Precedence

Grouping with Parentheses

AND has higher precedence than OR. Use parentheses to explicitly enforce evaluation order:

([Region] == "West" OR [Region] == "South") AND [Total_Revenue] >= 5000 AND [Customer_Type] != "Internal"

Built-in Functions in Custom Filters

You can leverage string, date, and math functions directly inside the Filter tool:

• String Matching: Contains([Product_Name], "Deluxe")
• Case-Insensitive Match: Uppercase([Department]) == "FINANCE"
• Regular Expressions: REGEX_Match([PostalCode], "^\\d{5}(-\\d{4})?$")
• Date Calculations: DateTimeDiff(DateTimeToday(), [Last_Purchase_Date], "days") <= 90

---

4. Null Value Handling in Filter Expressions (Critical Exam Concept!)

Handling Null values correctly is the single most tested nuance of the Filter tool.

                          How Nulls Route in Comparisons

        Expression: [Discount] > 0.10             Expression: [Discount] <= 0.10
        ┌───────────────────────────┐             ┌───────────────────────────┐
        │ Row 1: [Discount] = 0.25  │             │ Row 1: [Discount] = 0.25  │
        │   ──► Evaluates: TRUE     │             │   ──► Evaluates: FALSE    │
        │   ──► Exits: T Anchor     │             │   ──► Exits: F Anchor     │
        ├───────────────────────────┤             ├───────────────────────────┤
        │ Row 2: [Discount] = 0.05  │             │ Row 2: [Discount] = 0.05  │
        │   ──► Evaluates: FALSE    │             │   ──► Evaluates: TRUE     │
        │   ──► Exits: F Anchor     │             │   ──► Exits: T Anchor     │
        ├───────────────────────────┤             ├───────────────────────────┤
        │ Row 3: [Discount] = Null  │             │ Row 3: [Discount] = Null  │
        │   ──► Evaluates: NULL     │             │   ──► Evaluates: NULL     │
        │   ──► Exits: F Anchor     │             │   ──► Exits: F Anchor     │
        └───────────────────────────┘             └───────────────────────────┘

The Null Evaluation Rule

In Alteryx, comparing any value to Null yields Null, which the Filter tool treats as not True. Consequently, all records with Null in evaluated fields exit via the False (F) anchor.

The Inverse Filter Trap

Notice what occurs in the diagram above:

• When testing [Discount] > 0.10, Row 3 (Null) exits the False anchor.
• When testing [Discount] <= 0.10, Row 3 (Null) still exits the False anchor!

Exam Trap: The F (False) output anchor does not contain only records meeting the mathematical opposite of your condition. It contains records that evaluate to False plus all records containing Null values. If you need Nulls to pass through the T anchor, you must explicitly declare: [Discount] > 0.10 OR IsNull([Discount]).

Empty Strings ("") vs. Null

• Null: Represents the complete absence of a value (unallocated cell).
• Empty String (""): A valid string with a length of zero (Len([Field]) == 0).
• IsEmpty([StringField]): Returns True for both empty strings "" and Null values.
• IsNull([StringField]): Returns True only for Null values.

---

5. Practical Workflow Architectures Using Filter

                    ┌─────────────────────────────────────────┐
                    │ Multi-Branch Routing & Exception Handling│
                    └─────────────────────────────────────────┘
                                         │
                                         ▼
                                ┌─────────────────┐
                                │   Filter 1      │
                       ┌───────►│ [Score] >= 70   ├───────┐
                       │        └─────────────────┘       │
                       │                 │ (F)            │ (T)
                       │                 ▼                ▼
              ┌─────────────────┐ ┌─────────────┐ ┌─────────────────┐
              │   Raw Stream    │ │ Needs Review│ │ Passed Standard │
              │  (All Records)  │ │  Exception  │ │ (Downstream BI) │
              └─────────────────┘ └─────────────┘ └─────────────────┘

1. Data Validation & Exception Isolation: Route clean records through T to the main production pipeline, while sending dirty/invalid records through F to an Output Data tool for compliance auditing.
2. Cascading Filters (Sequential Logic): Connect the T output of Filter 1 to the input of Filter 2 to create hierarchical filtering chains (equivalent to Condition1 AND Condition2).
3. Parallel Segmentation: Route high-value customers through T and standard customers through F, apply customized transformation logic to each branch independently, and recombine them downstream with a Union tool.