LogoLogo
API Documentation
Current Version
Current Version
  • DecisionRules Documentation
  • DecisionRules Academy
  • API
    • API Introduction
    • API Keys
      • Solver API Keys
      • Management API keys
      • BI API keys
    • Rule Solver API
    • Management API
      • Rule Migration Strategies
      • Deprecated Endpoints
    • Console Logs API
    • Business Intelligence API
      • Deprecated Endpoints
    • Datacenters & Locations
      • Global Cloud
      • Regional Cloud
    • Apache Kafka Solver API
    • Endpoint Settings
    • Archive
      • Rule Flow Solver API (DEPRECATED)
  • AI Assistant
    • About Assistant
    • Assistant Setup
      • Gemini Assistant
  • RULES
    • Rules Introduction
    • Rule List
    • Rule Mode
    • Common Rule Features
      • Input & Output Model
        • Simple Editor
        • JSON Editor
      • Test Bench
      • Rule Alias
      • Rule State
      • Versioning
      • Rule Variables
      • Execution Strategy
      • Rule Dependencies
      • Rule Export & Import
        • Rule Export
        • Rule Import
        • Managing Decision Table in Excel/Google Sheets
        • Deprecated Formats: XLSX v.1 and CSV
      • Tags
      • Rule Comparison
        • Decision Table Comparison
        • Decision Tree Comparison
        • Scripting Rule Comparison
      • Rule Lock
      • Teamwork Indicator
      • Event Timeline
    • Data Types & Functions
      • Supported Data Types
      • Operators and Functions
        • Basic operators
        • Date operators
        • Functions
          • Logical Functions
          • Math Functions
          • Date and Time Functions
          • Text Functions
          • Data Functions
          • Array Functions
          • Integration functions
          • Functions and JSON
    • Decision Table
      • Table Designer
        • Table Operations
          • Filter Values
          • Valid Values
          • Sorting
      • Binding to Model
    • Decision Tree
      • Tree Designer
    • Workflow
      • Workflow Designer
      • Workflow Nodes Overview
      • Workflow Limits
    • Scripting Rule
      • Custom functions in Scripting Rules
      • Calling external API within ScriptingRules
      • Use Rule Variables in Scripting Rules
      • Call Embedded Rules in Scripting Rules
      • Tips
    • Rule Flow
      • Rule Flow Designer
      • Rule Flow Mapping
      • Rule States in Rule Flow
      • Warnings & Errors
      • Rule Flow Limits
  • SPACE
    • Space Introduction
    • Space Info
    • Dashboard
    • Access
    • API Keys
    • Audit Logs
  • Organization
    • Organization Introduction
    • Organization List
    • Members
    • Teams
    • Spaces
    • Space Roles
    • Policies
    • Statistics
    • Settings
  • Profile
    • Profile Introduction
    • General
    • Dashboard
    • Plans
    • Add-ons
    • Limits
      • Plan Limits Explained
    • Subscriptions
    • Invoices
  • Access
    • Sign Up & Login
    • Invitations & Permissions
    • Single Sign-On (SSO)
  • Business Intelligence
    • Audit Logs
    • Power BI Connectivity
      • Create a Power BI Report
      • Connect Power BI to Business Intelligence API
      • Connecting from Power BI (deprecated)
      • Connect DecisionRules to Power BI Using Our Custom Connector
  • OTHER DEPLOYMENT OPTIONS
    • Regional Cloud
      • Region Specific API URLs
    • Docker & On-Premise
      • Environment Variables
      • Redis Connection Modes
      • DecisionRules Application
        • Minimal Requirements
        • DecisionRules Server
        • DecisionRules Client
        • DecisionRules Business Intelligence
        • Networking Between Docker Containers
      • Setup Single Sign-On (SSO)
        • Set up Microsoft Entra ID SSO
        • Set up Google SSO
      • Docker Showcase App
        • Showcase
        • Showcase + Business Intelligence
      • AWS Setup
        • AWS ECS/Fargate
        • Cache - Amazon ElastiCache
      • Microsoft Azure Setup
        • Database - Azure CosmosDB
        • Cache - Azure Cache for Redis
        • Azure Container Apps
      • Azure Red Hat OpenShift
      • Google Kubernetes Engine (GKE)
      • Kubernetes Setup
        • Kubernetes Setup with Business Intelligence
      • Logging options
      • CD/CI Pipelines
        • Azure DevOps CICD Pipelines
        • Using Migration script (old way)
      • Offline License
      • White Labeling
  • SDK and Integrations
    • Languages / Frameworks
      • SQL Server
      • Oracle PL/SQL
      • PostgreSQL
      • JavaScript
      • Java Spring Example
      • PHP Library
      • Python Library
      • .NET Library
      • Google Tag Manager
    • Excel Add-in
  • Terms & Conditions
    • Terms and Conditions
    • Privacy Policy
    • Service Level Agreement
      • Community Support
      • Standard Cloud (SaaS)
      • Silver SLA
      • Gold SLA
      • Custom SLA
    • Sub-Processor List
  • Product Updates
    • Release Notes
      • Public Cloud
      • On-Premise / Private Cloud
    • Major Updates
      • Changes in Version 1.19.0 (10/2024)
      • Changes in Version 1.20.0 (4/2025)
    • Roadmap
Powered by GitBook
On this page
  • List of Basic Operators
  • Equals (=)
  • Anything (ANY)
  • Is in (IN)
  • Not in (!IN)
  • Greater than or equal (>=)
  • Greater than (>)
  • Less than or equal (<=)
  • Less than (<)
  • Not equal (!=)
  • Between (BTW)
  • Between left open (BTW LO)
  • Between right open (BTW RO)
  • Not between (!BTW)
  • Is null (NULL)
  • Is not null (!NULL)
  • Contains text (C TXT)
  • Contains in (C IN)
  • Not contains in (!C IN)
  • Equal array (EQ ARR)
  • Else (ELSE)

Was this helpful?

  1. RULES
  2. Data Types & Functions
  3. Operators and Functions

Basic operators

Description of general operators used in decision tables

Last updated 1 month ago

Was this helpful?

List of Basic Operators

Each condition cell in the decision table allows you to select a different operator. Below is an example of some available basic operators:

Input values (left operands) are auto-casted to the necessary data type, and right-side operands are also auto-casted. No quotes are needed in table values.

Equals (=)

Compares scalar values like strings, numbers, and booleans.

// [request value] = [table value]

3 = 3                 // true
"3" = 3               // true
true = true           // true
"true" = true         // true

Anything (ANY)

The Anything operator is the simplest operator available in decision tables. It always returns true, regardless of the input. This operator is typically used in cases where a condition needs to pass for every possible input value, or where the specific value is irrelevant to the rule’s outcome.

The Anything operator does not perform any comparison; it simply returns true for any input.

The operator is useful in scenarios where you want a rule to be triggered without considering the specific content of the condition.

Is in (IN)

Returns true if the left operand is in the right operand's set, which must be an array. Members of the set can be separated by pipe (|), comma (,), semicolon (;)

// [request value] IN [table value]

3     IN 1|2|3             // true
"a"   IN "a"|"b"|"c"       // true
"3"   IN 1|2|3             // true
"la"  IN "la-la"|"blah"    // false

Only exact matches.

Not in (!IN)

Returns true if the left operand is not in the right operand's set. Members of the set can be separated by pipe (|), comma (,), semicolon (;)

// [request value] NOT IN [table value]

3   NOT IN 1|2|3              //false
4   NOT IN 1|2|3              //true
"a" NOT IN "a"|"b"|"c"        //false
"d" NOT IN "a"|"b"|"c"        //true
"3" NOT IN 1|2|3              //false

Greater than or equal (>=)

Compares numbers or strings; returns true if the left operand is greater than or equal to the right operand.

  • Numbers can be decimal or integer.

// [request value] >= [table value]

5 >= 3              // true
3.1 >= 2.1          // true
"b" >= "a"          // true
"a" >= "a"          // true
true >= true        // true
true >= false       // true

Greater than (>)

Returns true if the left operand is greater than the right operand.

  • Numbers can be decimal or integer.

// [request value] > [table value]

5 > 3              // true
5 > 5              // false
3.1 > 2.1          // true
"b" > "a"          // true
true > true        // false
true > false       // true

Less than or equal (<=)

Returns true if the left operand is less than or equal to the right operand.

  • Numbers can be decimal or integer.

// [request value] <= [table value]

3 <= 5              // true
3 <= 3              // true
2.1 <= 3.1          // true
"a" <= "a"          // true
"a" <= "b"          // true
true <= true        // true
false <= true       // true

Less than (<)

Returns true if the left operand is less than the right operand.

  • Numbers can be decimal or integer.

// [request value] < [table value]

3 < 5              // true
3 < 3              // false
2.1 < 3.1          // true
"a" < "b"          // true
true < true        // false
false < true       // true

Not equal (!=)

Compares scalar values and returns true if they are not equal.

// [request value] != [table value]

3    != 3           //false
"3"  != 3           //false
3    != 4           //true
true != false       //true

Between (BTW)

Returns true if the left operand is between or equal to the two values specified in the right operand, which must be an array of two values. This operator can be used to compare Numbers, Strings, or Booleans.

  • The operator evaluates whether the left operand falls within the inclusive range defined by the two values in the right operand array.

// [request value] BTW [table value 1 AND table value 2]

4     BTW [3 AND 5]            // true
3     BTW [3 AND 5]            // true
4.0   BTW [3.0 AND 5.5]        // true
3.5   BTW [3.0 AND 5.5]        // true
"b"   BTW ["a" AND "c"]        // true
"a"   BTW ["a" AND "c"]        // true
true  BTW [true AND false]     // false
true  BTW [true AND true]      // true

The left operand can be a number, string, or boolean, and the right operand must be an array of two values.

Between left open (BTW LO)

Returns true if the left operand falls within the range defined by two values in the right operand, excluding the lower limit (left value) and including the upper limit (right value). If the left operand is equal to the lower limit, the result will be false.

// [request value] BTW LO [table value 1 AND table value 2]

4     BTW LO [3 AND 5]           // true
3     BTW LO [3 AND 5]           // false
5.5   BTW LO [3.0 AND 5.5]       // true
3.0   BTW LO [3.0 AND 5.5]       // false
"b"   BTW LO ["a" AND "c"]       // true
"a"   BTW LO ["a" AND "c"]       // false
true  BTW LO [false AND true]    // true
false BTW LO [false AND true]    // false

The left operand can be a number, string, or boolean, and the right operand must be an array of two values.

Between right open (BTW RO)

Returns true if the left operand falls within the range defined by two values in the right operand, including the lower limit (left value) and excluding the upper limit (right value). If the left operand is equal to the upper limit, the result will be false.

// [request value] BTW RO [table value 1 AND table value 2]

4      BTW RO [3 AND 5]          // true
5      BTW RO [3 AND 5]          // false
3.0    BTW RO [3.0 AND 5.5]      // true
5.5    BTW RO [3.0 AND 5.5]      // false
"b"    BTW RO ["a" AND "c"]      // true
"c"    BTW RO ["a" AND "c"]      // false
true   BTW RO [false AND true]   // false
false  BTW RO [false AND true]   // true

The left operand can be a number, string, or boolean, and the right operand must be an array of two values.

Not between (!BTW)

Returns true if the left operand does not fall within the range defined by two values in the right operand. This operator effectively checks if the left operand is outside the specified interval.

// [request value] !BTW [table value 1 AND table value 2]

4     !BTW [3 AND 5]         // false
2     !BTW [3 AND 5]         // true
"b"   !BTW ["a" AND "c"]     // false
"d"   !BTW ["a" AND "c"]     // true
true  !BTW [false AND true]  // false
false !BTW [false AND true]  // false

The left operand can be a number, string, or boolean, while the right operand must be an array containing two values.

Is null (NULL)

Returns true if the value being evaluated is empty. It does not accept any specific table values for comparison.

The request value is checked against various types of empty values.

// [request value] NULL [table value is empty]

null    NULL           // true
{}      NULL           // true
[]      NULL           // true
"a"     NULL           // false
3       NULL           // false
""      NULL           // false
0       NULL           // false

This operator is useful for validating whether a value has been provided or is absent.

Is not null (!NULL)

Returns true if the value being evaluated is not empty. It does not accept any specific table values for comparison.

The request value is assessed to determine if it holds any non-empty data.

// [request value] !NULL [table value is empty]

"a"      !NULL          //true
3        !NULL          //true
""       !NULL          //true
null     !NULL          //false
{}       !NULL          //false
[]       !NULL          //false

This operator is useful for confirming that a value has been provided or exists in the dataset.

Contains text (C TXT)

The operator checks if the left operand includes a value specified in the right operand, returning true if a match is found and false otherwise.

The operator matches not only exact values but also substrings.

  • Members of the set can be separated by pipe (|), comma (,), or semicolon (;).

  • The left operand can be of type Number, String, Boolean, or an Array containing these types.

// [request value] C TXT [table value]

[1,2,3]                             C TXT "1"             //true
[11,2,3]                            C TXT "1"             //true
[2,3,4]                             C TXT "1"             //false
"This is example 1,2,3 with true."  C TXT "1,2,3"         //true
"This is example false or true."    C TXT "true or false" //false
"This is example true with false."  C TXT true            //true

This operator is particularly useful for scenarios where partial matches or the presence of specific elements within a collection need to be identified.

Contains in (C IN)

Returns true if any of the values in the right operand are present in the left operand. This operator checks for both exact matches and substrings, returning false if no match is found.

The operator matches not only exact values but also substrings.

  • Members of the set in the right operand can be separated by pipe (|), comma (,), or semicolon (;).

  • The left operand can be a Number, String, Boolean, or an Array of these types.

// [request value] C IN [table value]

"This is example 1 with true." C IN 1|2|3          //true
"This is example 1 with true." C IN 1|true|"ok"    //true
"This is example 1 with true." C IN "is"|2|true    //true
"This is example 1 with true." C IN true|3         //true
[1,2,3]                        C IN true|3         //true
["true or falseee", "haha"]    C IN true|false     //true
"This is example 1 with true." C IN "test"|2       //false

This operator is effective for verifying the existence of one or more elements from a list within a string or array.

Not contains in (!C IN)

Returns true if none of the elements in the right operand are present in the left operand. This operator checks both exact values and substrings, returning false if any match is found.

  • Members of the set in the right operand can be separated by pipe (|), comma (,), or semicolon (;).

  • The left operand can be a Number, String, Boolean, or an Array containing these types.

  • It returns true only when there are no matches found.

// [request value] !C IN [table value]

"This is example 1 with true." !C IN 2|3|4          //true
"This is example 1 with true." !C IN 2|false|"ok"   //true
"This is example 1 with true." !C IN "are"|2|false  //true
"This is example 1 with true." !C IN false|3        //true
[1,2,3]                        !C IN true|3         //false
["true or falseee", "haha"]    !C IN "hello"|"bye"  //true
"This is example 1 with true." !C IN "test"|1       //false

This operator is useful when you want to confirm that none of a given set of elements is present in a string or array.

Equal array (EQ ARR)

Returns true if all the values in the right operand are substrings of at least one of the values in the left operand. This operator checks for matches within the elements of the left operand array, ensuring that all specified values in the right operand appear as substrings.

  • The right operand set can be separated by pipe (|), comma (,), or semicolon (;).

  • The left operand must be an array [].

  • It returns true only when all the values in the right operand match a substring in the left operand.

// [request value] EQ ARR [table value]

[1, 2, 3]     EQ ARR  1|2|3      //true
["a", "b"]    EQ ARR  "a"|"b"    //true
[1,2,3]       EQ ARR  1|2        //true
[1111,111]    EQ ARR  1|11|111   //true
[1,2,3,4,5]   EQ ARR  1|2|3|4|6  //false

This operator is helpful when you want to ensure that a set of substrings is found across an array of values.

Else (ELSE)

The ELSE operator is a unique operator in decision tables, which returns true when no preceding row has passed the evaluation. It acts independently of the input variable in its column and only evaluates the overall flow of the table rather than specific conditions.

Key Points:

  • The ELSE operator triggers if no other rows have passed before it.

  • There can only be one row with the ELSE operator that passes.

  • When evaluated, it takes into account only the conditions above it in the table.

The ELSE operator is primarily used to create a default or fallback row in decision tables. This row is triggered if no other conditions match, making it ideal for handling scenarios like generating error messages or returning default responses.

String comparison is .

String comparison is .

String comparison is .

String comparison is .

similar to JS
similar to JS
similar to JS
similar to JS
Basic operators modal