Interface WhereOperators<AttributeType>

Operators that can be used in WhereOptions

interface WhereOperators<AttributeType = any> {
    "[adjacent]"?: AttributeType extends Range<RangeType>
        ? Rangable<RangeType>
        : DynamicValues<AttributeType>;
    "[allKeysExist]"?: string[] | DynamicValues<string[]>;
    "[anyKeyExists]"?: string[] | DynamicValues<string[]>;
    "[between]"?:
        | Literal
        | [
            lowerInclusive: OperatorValues<NonNullable<AttributeType>>,
            higherInclusive: OperatorValues<NonNullable<AttributeType>>,
        ];
    "[contained]"?: AttributeType extends any[]
        ? | AllowAnyAll<
            (
                DynamicValues<AttributeType> | (AttributeType extends Range<infer RangeType> ? Rangable<RangeType> : AttributeType extends any[] ? StaticValues<...> : never)
            ),
        >
        | undefined
        : AllowAnyAll<OperatorValues<Rangable<AttributeType>>>;
    "[contains]"?: AttributeType extends Range<RangeType>
        ? OperatorValues<OperatorValues<NonNullable<RangeType>>>
        : AttributeType extends object
            ? OperatorValues<Partial<AttributeType>>
            :
                | AllowAnyAll<
                    (
                        DynamicValues<AttributeType> | (AttributeType extends Range<infer RangeType> ? Rangable<RangeType> : AttributeType extends any[] ? StaticValues<...> : never)
                    ),
                >
                | undefined;
    "[endsWith]"?: OperatorValues<Extract<AttributeType, string>>;
    "[eq]"?: AllowAnyAll<OperatorValues<AttributeType>>;
    "[gt]"?: AllowAnyAll<OperatorValues<NonNullable<AttributeType>>>;
    "[gte]"?: AllowAnyAll<OperatorValues<NonNullable<AttributeType>>>;
    "[iLike]"?: AllowAnyAll<OperatorValues<Extract<AttributeType, string>>>;
    "[in]"?: Literal | readonly OperatorValues<NonNullable<AttributeType>>[];
    "[iRegexp]"?: AllowAnyAll<OperatorValues<Extract<AttributeType, string>>>;
    "[is]"?: Literal | Extract<AttributeType, boolean | null>;
    "[isNot]"?: Literal | Extract<AttributeType, boolean | null>;
    "[like]"?: AllowAnyAll<OperatorValues<Extract<AttributeType, string>>>;
    "[lt]"?: AllowAnyAll<OperatorValues<NonNullable<AttributeType>>>;
    "[lte]"?: AllowAnyAll<OperatorValues<NonNullable<AttributeType>>>;
    "[match]"?: AllowAnyAll<DynamicValues<AttributeType>>;
    "[ne]"?: AllowAnyAll<OperatorValues<AttributeType>>;
    "[noExtendLeft]"?: AttributeType extends Range<RangeType>
        ? Rangable<RangeType>
        : DynamicValues<AttributeType>;
    "[noExtendRight]"?: AttributeType extends Range<RangeType>
        ? Rangable<RangeType>
        : DynamicValues<AttributeType>;
    "[notBetween]"?:
        | Literal
        | [
            lowerInclusive: OperatorValues<NonNullable<AttributeType>>,
            higherInclusive: OperatorValues<NonNullable<AttributeType>>,
        ];
    "[notEndsWith]"?: OperatorValues<Extract<AttributeType, string>>;
    "[notILike]"?: AllowAnyAll<OperatorValues<Extract<AttributeType, string>>>;
    "[notIn]"?: Literal | readonly OperatorValues<NonNullable<AttributeType>>[];
    "[notIRegexp]"?: AllowAnyAll<
        OperatorValues<Extract<AttributeType, string>>,
    >;
    "[notLike]"?: AllowAnyAll<OperatorValues<Extract<AttributeType, string>>>;
    "[notRegexp]"?: AllowAnyAll<OperatorValues<Extract<AttributeType, string>>>;
    "[notStartsWith]"?: OperatorValues<Extract<AttributeType, string>>;
    "[notSubstring]"?: OperatorValues<Extract<AttributeType, string>>;
    "[overlap]"?: AllowAnyAll<
        (
            DynamicValues<AttributeType> | (AttributeType extends Range<infer RangeType> ? Rangable<RangeType> : AttributeType extends any[] ? StaticValues<...> : never)
        ),
    >;
    "[regexp]"?: AllowAnyAll<OperatorValues<Extract<AttributeType, string>>>;
    "[startsWith]"?: OperatorValues<Extract<AttributeType, string>>;
    "[strictLeft]"?: AttributeType extends Range<RangeType>
        ? Rangable<RangeType>
        : DynamicValues<AttributeType>;
    "[strictRight]"?: AttributeType extends Range<RangeType>
        ? Rangable<RangeType>
        : DynamicValues<AttributeType>;
    "[substring]"?: OperatorValues<Extract<AttributeType, string>>;
}

Type Parameters

AttributeType = any
The JS type of the attribute the operator is operating on.

See https://sequelize.org/docs/v7/core-concepts/model-querying-basics/#operators

Properties

`Optional`[adjacent]

"[adjacent]"?: AttributeType extends Range<RangeType>
? Rangable<RangeType>
: DynamicValues<AttributeType>

PG only

Whether the two ranges are adjacent.

Example

{ rangeAttribute: { [Op.adjacent]: [1, 2] } }
// results in
// "rangeAttribute" -|- [1, 2)

https://www.postgresql.org/docs/14/functions-range.html

`Optional`[allKeysExist]

"[allKeysExist]"?: string[] | DynamicValues<string[]>

PG only

Check if all of these array strings exist as top-level keys.

Example

{ jsonbAttribute: { [Op.allKeysExist]: ['a','b'] } }
// results in
// "jsonbAttribute" ?& ARRAY['a','b']

https://www.postgresql.org/docs/current/functions-json.html

`Optional`[anyKeyExists]

"[anyKeyExists]"?: string[] | DynamicValues<string[]>

PG only

Check if any of these array strings exist as top-level keys.

Example

{ jsonbAttribute: { [Op.anyKeyExists]: ['a','b'] } }
// results in
// "jsonbAttribute" ?| ARRAY['a','b']

https://www.postgresql.org/docs/current/functions-json.html

`Optional`[between]

"[between]"?:
    | Literal
    | [
        lowerInclusive: OperatorValues<NonNullable<AttributeType>>,
        higherInclusive: OperatorValues<NonNullable<AttributeType>>,
    ]

Example

`[Op.between]: [6, 10],` becomes `BETWEEN 6 AND 10`

`Optional`[contained]

"[contained]"?: AttributeType extends any[]
    ? | AllowAnyAll<
        (
            DynamicValues<AttributeType> | (AttributeType extends Range<infer RangeType> ? Rangable<RangeType> : AttributeType extends any[] ? StaticValues<...> : never)
        ),
    >
    | undefined
    : AllowAnyAll<OperatorValues<Rangable<AttributeType>>>

PG array & range 'contained by' operator

Example

`[Op.contained]: [1, 2]` becomes `<@ [1, 2]`

`Optional`[contains]

"[contains]"?: AttributeType extends Range<RangeType>
    ? OperatorValues<OperatorValues<NonNullable<RangeType>>>
    : AttributeType extends object
        ? OperatorValues<Partial<AttributeType>>
        :
            | AllowAnyAll<
                (
                    DynamicValues<AttributeType> | (AttributeType extends Range<infer RangeType> ? Rangable<RangeType> : AttributeType extends any[] ? StaticValues<...> : never)
                ),
            >
            | undefined

PG array & range 'contains' operator

Example

`[Op.contains]: [1, 2]` becomes `@> [1, 2]`

`Optional`[endsWith]

"[endsWith]"?: OperatorValues<Extract<AttributeType, string>>

String ends with value.

`Optional`[eq]

"[eq]"?: AllowAnyAll<OperatorValues<AttributeType>>

Example

`[Op.eq]: 6,` becomes `= 6`

Example

`[Op.eq]: [6, 7]` becomes `= ARRAY[6, 7]`

Example

`[Op.eq]: null` becomes `IS NULL`

Example

`[Op.eq]: true` becomes `= true`

Example

`[Op.eq]: literal('raw sql')` becomes `= raw sql`

Example

`[Op.eq]: col('column')` becomes `= "column"`

Example

`[Op.eq]: fn('NOW')` becomes `= NOW()`

`Optional`[gt]

"[gt]"?: AllowAnyAll<OperatorValues<NonNullable<AttributeType>>>

Example

`[Op.gt]: 6` becomes `> 6`

`Optional`[gte]

"[gte]"?: AllowAnyAll<OperatorValues<NonNullable<AttributeType>>>

Example

`[Op.gte]: 6` becomes `>= 6`

`Optional`[iLike]

"[iLike]"?: AllowAnyAll<OperatorValues<Extract<AttributeType, string>>>

case insensitive PG only

Example

`[Op.iLike]: '%hat'` becomes `ILIKE '%hat'`

Example

`[Op.iLike]: { [Op.any]: ['cat', 'hat']}` becomes `ILIKE ANY (ARRAY['cat', 'hat'])`

`Optional`[in]

"[in]"?: Literal | readonly OperatorValues<NonNullable<AttributeType>>[]

Example

`[Op.in]: [1, 2],` becomes `IN (1, 2)`

`Optional`[iRegexp]

"[iRegexp]"?: AllowAnyAll<OperatorValues<Extract<AttributeType, string>>>

PG only

Matches regular expression, case insensitive

Example

`[Op.iRegexp]: '^[h|a|t]'` becomes `~* '^[h|a|t]'`

`Optional`[is]

"[is]"?: Literal | Extract<AttributeType, boolean | null>

Example

`[Op.is]: null` becomes `IS NULL`

Example

`[Op.is]: true` becomes `IS TRUE`

Example

`[Op.is]: literal('value')` becomes `IS value`

`Optional`[isNot]

"[isNot]"?: Literal | Extract<AttributeType, boolean | null>

Example: [Op.isNot]: null, becomes IS NOT NULL

`Optional`[like]

"[like]"?: AllowAnyAll<OperatorValues<Extract<AttributeType, string>>>

Example

`[Op.like]: '%hat',` becomes `LIKE '%hat'`

Example

`[Op.like]: { [Op.any]: ['cat', 'hat'] }` becomes `LIKE ANY (ARRAY['cat', 'hat'])`

`Optional`[lt]

"[lt]"?: AllowAnyAll<OperatorValues<NonNullable<AttributeType>>>

Example

`[Op.lt]: 10` becomes `< 10`

`Optional`[lte]

"[lte]"?: AllowAnyAll<OperatorValues<NonNullable<AttributeType>>>

Example

`[Op.lte]: 10` becomes `<= 10`

`Optional`[match]

"[match]"?: AllowAnyAll<DynamicValues<AttributeType>>

Example

`[Op.match]: Sequelize.fn('to_tsquery', 'fat & rat')` becomes `@@ to_tsquery('fat & rat')`

`Optional`[ne]

"[ne]"?: AllowAnyAll<OperatorValues<AttributeType>>

Example

`[Op.ne]: 20,` becomes `!= 20`

Example

`[Op.ne]: [20, 21]` becomes `!= ARRAY[20, 21]`

Example

`[Op.ne]: null` becomes `IS NOT NULL`

Example

`[Op.ne]: true` becomes `!= true`

Example

`[Op.ne]: literal('raw sql')` becomes `!= raw sql`

Example

`[Op.ne]: col('column')` becomes `!= "column"`

Example

`[Op.ne]: fn('NOW')` becomes `!= NOW()`

`Optional`[noExtendLeft]

"[noExtendLeft]"?: AttributeType extends Range<RangeType>
? Rangable<RangeType>
: DynamicValues<AttributeType>

PG only

Whether the range extends to the left of the other range.

Example

{ rangeAttribute: { [Op.noExtendLeft]: [1, 2] } }
// results in
// "rangeAttribute" &> [1, 2)

https://www.postgresql.org/docs/14/functions-range.html

`Optional`[noExtendRight]

"[noExtendRight]"?: AttributeType extends Range<RangeType>
? Rangable<RangeType>
: DynamicValues<AttributeType>

PG only

Whether the range extends to the right of the other range.

Example

{ rangeAttribute: { [Op.noExtendRight]: [1, 2] } }
// results in
// "rangeAttribute" &< [1, 2)

https://www.postgresql.org/docs/14/functions-range.html

`Optional`[notBetween]

"[notBetween]"?:
    | Literal
    | [
        lowerInclusive: OperatorValues<NonNullable<AttributeType>>,
        higherInclusive: OperatorValues<NonNullable<AttributeType>>,
    ]

Example

`[Op.notBetween]: [11, 15],` becomes `NOT BETWEEN 11 AND 15`

`Optional`[notEndsWith]

"[notEndsWith]"?: OperatorValues<Extract<AttributeType, string>>

String not ends with value.

`Optional`[notILike]

"[notILike]"?: AllowAnyAll<OperatorValues<Extract<AttributeType, string>>>

PG only

Example

`[Op.notILike]: '%hat'` becomes `NOT ILIKE '%hat'`

Example

`[Op.notILike]: { [Op.any]: ['cat', 'hat']}` becomes `NOT ILIKE ANY (ARRAY['cat', 'hat'])`

`Optional`[notIn]

"[notIn]"?: Literal | readonly OperatorValues<NonNullable<AttributeType>>[]

Example

`[Op.notIn]: [1, 2],` becomes `NOT IN (1, 2)`

`Optional`[notIRegexp]

"[notIRegexp]"?: AllowAnyAll<OperatorValues<Extract<AttributeType, string>>>

PG only

Does not match regular expression, case insensitive

Example

`[Op.notIRegexp]: '^[h|a|t]'` becomes `!~* '^[h|a|t]'`

`Optional`[notLike]

"[notLike]"?: AllowAnyAll<OperatorValues<Extract<AttributeType, string>>>

Example

`[Op.notLike]: '%hat'` becomes `NOT LIKE '%hat'`

Example

`[Op.notLike]: { [Op.any]: ['cat', 'hat']}` becomes `NOT LIKE ANY (ARRAY['cat', 'hat'])`

`Optional`[notRegexp]

"[notRegexp]"?: AllowAnyAll<OperatorValues<Extract<AttributeType, string>>>

MySQL/PG only

Does not match regular expression, case sensitive

Example

`[Op.notRegexp]: '^[h|a|t]'` becomes `NOT REGEXP/!~ '^[h|a|t]'`

`Optional`[notStartsWith]

"[notStartsWith]"?: OperatorValues<Extract<AttributeType, string>>

Strings not starts with value.

`Optional`[notSubstring]

"[notSubstring]"?: OperatorValues<Extract<AttributeType, string>>

String not contains value.

`Optional`[overlap]

"[overlap]"?: AllowAnyAll<
    (
        DynamicValues<AttributeType> | (AttributeType extends Range<infer RangeType> ? Rangable<RangeType> : AttributeType extends any[] ? StaticValues<...> : never)
    ),
>

PG array & range 'overlaps' operator

Example

`[Op.overlap]: [1, 2]` becomes `&& [1, 2]`

`Optional`[regexp]

"[regexp]"?: AllowAnyAll<OperatorValues<Extract<AttributeType, string>>>

MySQL/PG only

Matches regular expression, case sensitive

Example

`[Op.regexp]: '^[h|a|t]'` becomes `REGEXP/~ '^[h|a|t]'`

`Optional`[startsWith]

"[startsWith]"?: OperatorValues<Extract<AttributeType, string>>

Strings starts with value.

`Optional`[strictLeft]

"[strictLeft]"?: AttributeType extends Range<RangeType>
? Rangable<RangeType>
: DynamicValues<AttributeType>

PG only

Whether the range is strictly left of the other range.

Example

{ rangeAttribute: { [Op.strictLeft]: [1, 2] } }
// results in
// "rangeAttribute" << [1, 2)

https://www.postgresql.org/docs/14/functions-range.html

`Optional`[strictRight]

"[strictRight]"?: AttributeType extends Range<RangeType>
? Rangable<RangeType>
: DynamicValues<AttributeType>

PG only

Whether the range is strictly right of the other range.

Example

{ rangeAttribute: { [Op.strictRight]: [1, 2] } }
// results in
// "rangeAttribute" >> [1, 2)

https://www.postgresql.org/docs/14/functions-range.html

`Optional`[substring]

"[substring]"?: OperatorValues<Extract<AttributeType, string>>

String contains value.

Interface WhereOperators<AttributeType>

Type Parameters

Index

Properties

Properties

Optional[adjacent]

Example

Optional[allKeysExist]

Example

Optional[anyKeyExists]

Example

Optional[between]

Example

Optional[contained]

Example

Optional[contains]

Example

Optional[endsWith]

Optional[eq]

Example

Example

Example

Example

Example

Example

Example

Optional[gt]

Example

Optional[gte]

Example

Optional[iLike]

Example

Example

Optional[in]

Example

Optional[iRegexp]

Example

Optional[is]

Example

Example

Example

Optional[isNot]

Optional[like]

Example

Example

Optional[lt]

Example

Optional[lte]

Example

Optional[match]

Example

Optional[ne]

Example

Example

Example

Example

Example

Example

Example

Optional[noExtendLeft]

Example

Optional[noExtendRight]

Example

Optional[notBetween]

Example

Optional[notEndsWith]

Optional[notILike]

Example

Example

Optional[notIn]

Example

Optional[notIRegexp]

Example

Optional[notLike]

Example

Example

Optional[notRegexp]

Example

Optional[notStartsWith]

Optional[notSubstring]

`Optional`[adjacent]

`Optional`[allKeysExist]

`Optional`[anyKeyExists]

`Optional`[between]

`Optional`[contained]

`Optional`[contains]

`Optional`[endsWith]

`Optional`[eq]

`Optional`[gt]

`Optional`[gte]

`Optional`[iLike]

`Optional`[in]

`Optional`[iRegexp]

`Optional`[is]

`Optional`[isNot]

`Optional`[like]

`Optional`[lt]

`Optional`[lte]

`Optional`[match]

`Optional`[ne]

`Optional`[noExtendLeft]

`Optional`[noExtendRight]

`Optional`[notBetween]

`Optional`[notEndsWith]

`Optional`[notILike]

`Optional`[notIn]

`Optional`[notIRegexp]

`Optional`[notLike]

`Optional`[notRegexp]

`Optional`[notStartsWith]

`Optional`[notSubstring]

`Optional`[overlap]

`Optional`[regexp]

`Optional`[startsWith]

`Optional`[strictLeft]

`Optional`[strictRight]

`Optional`[substring]