---
title: SQL comparison operators
description: Comparison operators evaluate the relationship between the left and right operands and return true or false.
url: https://docs.influxdata.com/influxdb3/cloud-dedicated/reference/sql/operators/comparison/
estimated_tokens: 1819
publisher: InfluxData
canonical: https://docs.influxdata.com/influxdb3/cloud-dedicated/reference/sql/operators/comparison/
date: '2025-04-03T12:43:17-06:00'
lastmod: '2025-04-03T12:43:17-06:00'
---

Comparison operators evaluate the relationship between the left and right
operands and returns `true` or `false`.

|       Operator       |                        Meaning                         |                                    |
|----------------------|--------------------------------------------------------|------------------------------------|
|         `=`          |                        Equal to                        |           [](#equal-to)            |
|         `<>`         |                      Not equal to                      |         [](#not-equal-to)          |
|         `!=`         |                      Not equal to                      |         [](#not-equal-to)          |
|         `>`          |                      Greater than                      |         [](#greater-than)          |
|         `>=`         |                Greater than or equal to                |     [](#greater-than-or-equal)     |
|         `<`          |                       Less than                        |           [](#less-than)           |
|         `<=`         |                 Less than or equal to                  |      [](#less-than-or-equal)       |
|  `IS DISTINCT FROM`  |                    Is distinct from                    |       [](#is-distinct-from)        |
|`IS NOT DISTINCT FROM`|                  Is not distinct from                  |     [](#is-not-distinct-from)      |
|         `~`          |              Matches a regular expression              |         [](#regexp-match)          |
|         `~*`         |   Matches a regular expression *(case-insensitive)*    | [](#regexp-match-case-insensitive) |
|         `!~`         |          Does not match a regular expression           |        [](#regexp-nomatch)         |
|        `!~*`         |Does not match a regular expression *(case-insensitive)*|[](#regexp-nomatch-case-insensitive)|

## \=

The `=` operator compares the left and right operands and, if equal, returns `true`.
Otherwise returns `false`.

```sql
SELECT 123 = 123
```

|Int64(123) = Int64(123)|
|-----------------------|
|         true          |

## !=, \<\>

The `!=` and `<>` operators compare the left and right operands and, if not equal,
returns `true`. Otherwise returns `false`.

```sql
SELECT 123 != 456
```

|Int64(123) != Int64(456)|
|------------------------|
|          true          |

```sql
SELECT 123 <> 456
```

|Int64(123) != Int64(456)|
|------------------------|
|          true          |

## \>

The `>` operator compares the left and right operands and, if the left operand
is greater than the right operand, returns `true`.
Otherwise returns `false`.

```sql
SELECT 3 > 2
```

|Int64(3) \> Int64(2)|
|--------------------|
|        true        |

## \>=

The `>=` operator compares the left and right operands and, if the left operand
is greater than or equal to the right operand, returns `true`.
Otherwise returns `false`.

```sql
SELECT 3 >= 2
```

|Int64(3) \>= Int64(2)|
|---------------------|
|        true         |

## \<

The `<` operator compares the left and right operands and, if the left operand
is less than the right operand, returns `true`.
Otherwise returns `false`.

```sql
SELECT 1 < 2
```

|Int641(1) \< Int64(2)|
|---------------------|
|        true         |

## \<=

The `<=` operator compares the left and right operands and, if the left operand
is less than or equal to the right operand, returns `true`.
Otherwise returns `false`.

```sql
SELECT 1 <= 2
```

|Int641(1) \<= Int64(2)|
|----------------------|
|         true         |

## IS DISTINCT FROM

The `IS DISTINCT FROM` operator is a *NULL*-safe operator that returns`true` if both operands are not equal; otherwise, it returns `false`.
This operator guarantees the result of a comparison is `true` or `false` and not
an empty set.

```sql
SELECT 0 IS DISTINCT FROM NULL
```

|Int64(0) IS DISTINCT FROM NULL|
|------------------------------|
|             true             |

## IS NOT DISTINCT FROM

The `IS NOT DISTINCT FROM` operator is a *NULL*-safe operator that returns`true` if both operands are equal or *NULL*; otherwise, it returns `false`.
This operator negates [`IS DISTINCT FROM`](#is-distinct-from).

```sql
SELECT NULL IS NOT DISTINCT FROM NULL
```

|NULL IS NOT DISTINCT FROM NULL|
|------------------------------|
|             true             |

## \~

The `~` operator compares the left string operand to the right regular expression
operand and, if it matches (case-sensitive), returns `true`.
Otherwise returns `false`.

```sql
SELECT 'abc' ~ 'a.*'
```

|Utf8(“abc”) \~ Utf8(“a.\*”)|
|---------------------------|
|           true            |

## \~\*

The `~*` operator compares the left string operand to the right regular expression
operand and, if it matches (case-insensitive), returns `true`.
Otherwise returns `false`.

```sql
SELECT 'Abc' ~* 'A.*'
```

|Utf8(“Abc”) \~\* Utf8(“A.\*”)|
|-----------------------------|
|            true             |

## !\~

The `!~` operator compares the left string operand to the right regular expression
operand and, if it does not match (case-sensitive), returns `true`.
Otherwise returns `false`.

```sql
SELECT 'abc' !~ 'd.*'
```

|Utf8(“abc”) !\~ Utf8(“d.\*”)|
|----------------------------|
|            true            |

## !\~\*

The `!~*` operator compares the left string operand to the right regular expression
operand and, if it does not match (case-insensitive), returns `true`.
Otherwise returns `false`.

```sql
SELECT 'Abc' !~* 'a.*'
```

|Utf8(“Abc”) !\~\* Utf8(“a.\*”)|
|------------------------------|
|            false             |
| Operator | Meaning |  |
| --- | --- | --- |
| Operator | Meaning |  |
| = | Equal to |  |
| <> | Not equal to |  |
| != | Not equal to |  |
| > | Greater than |  |
| >= | Greater than or equal to |  |
| < | Less than |  |
| <= | Less than or equal to |  |
| IS DISTINCT FROM | Is distinct from |  |
| IS NOT DISTINCT FROM | Is not distinct from |  |
| ~ | Matches a regular expression |  |
| ~* | Matches a regular expression  (case-insensitive) |  |
| !~ | Does not match a regular expression |  |
| !~* | Does not match a regular expression  (case-insensitive) |  |

| Int64(123) = Int64(123) |
| --- |
| Int64(123) = Int64(123) |
| true |

| Int64(123) != Int64(456) |
| --- |
| Int64(123) != Int64(456) |
| true |

| Int64(123) != Int64(456) |
| --- |
| Int64(123) != Int64(456) |
| true |

| Int64(3) > Int64(2) |
| --- |
| Int64(3) > Int64(2) |
| true |

| Int64(3) >= Int64(2) |
| --- |
| Int64(3) >= Int64(2) |
| true |

| Int641(1) < Int64(2) |
| --- |
| Int641(1) < Int64(2) |
| true |

| Int641(1) <= Int64(2) |
| --- |
| Int641(1) <= Int64(2) |
| true |

| Int64(0) IS DISTINCT FROM NULL |
| --- |
| Int64(0) IS DISTINCT FROM NULL |
| true |

| NULL IS NOT DISTINCT FROM NULL |
| --- |
| NULL IS NOT DISTINCT FROM NULL |
| true |

| Utf8(“abc”) ~ Utf8(“a.*”) |
| --- |
| Utf8(“abc”) ~ Utf8(“a.*”) |
| true |

| Utf8(“Abc”) ~* Utf8(“A.*”) |
| --- |
| Utf8(“Abc”) ~* Utf8(“A.*”) |
| true |

| Utf8(“abc”) !~ Utf8(“d.*”) |
| --- |
| Utf8(“abc”) !~ Utf8(“d.*”) |
| true |

| Utf8(“Abc”) !~* Utf8(“a.*”) |
| --- |
| Utf8(“Abc”) !~* Utf8(“a.*”) |
| false |