Interface OpTypes

This interface is the type of the Op object.

This type cannot be used directly, use Op instead.

interface OpTypes {
    adjacent: typeof adjacent;
    all: typeof all;
    allKeysExist: typeof allKeysExist;
    and: typeof and;
    any: typeof any;
    anyKeyExists: typeof anyKeyExists;
    between: typeof between;
    col: typeof col;
    contained: typeof contained;
    contains: typeof contains;
    endsWith: typeof endsWith;
    eq: typeof eq;
    gt: typeof gt;
    gte: typeof gte;
    iLike: typeof iLike;
    in: typeof in;
    iRegexp: typeof iRegexp;
    is: typeof is;
    isNot: typeof isNot;
    like: typeof like;
    lt: typeof lt;
    lte: typeof lte;
    match: typeof match;
    ne: typeof ne;
    noExtendLeft: typeof noExtendLeft;
    noExtendRight: typeof noExtendRight;
    not: typeof not;
    notBetween: typeof notBetween;
    notEndsWith: typeof notEndsWith;
    notILike: typeof notILike;
    notIn: typeof notIn;
    notIRegexp: typeof notIRegexp;
    notLike: typeof notLike;
    notRegexp: typeof notRegexp;
    notStartsWith: typeof notStartsWith;
    notSubstring: typeof notSubstring;
    or: typeof or;
    overlap: typeof overlap;
    regexp: typeof regexp;
    startsWith: typeof startsWith;
    strictLeft: typeof strictLeft;
    strictRight: typeof strictRight;
    substring: typeof substring;
    values: typeof values;
}

Properties

`Readonly`adjacent

adjacent: typeof adjacent

Operator -|- (PG range is adjacent to operator)

[Op.adjacent]: [1, 2]

In SQL

-|- [1, 2)

`Readonly`all

all: typeof all

Operator ALL

[Op.gt]: {
 [Op.all]: literal('SELECT 1')
}

In SQL

> ALL (SELECT 1)

`Readonly`allKeysExist

allKeysExist: typeof allKeysExist

Operator ?&

[Op.allKeysExist]: ['a', 'b']

In SQL

?& ARRAY['a', 'b']

`Readonly`and

and: typeof and

Operator AND

[Op.and]: {a: 5}

In SQL

AND (a = 5)

`Readonly`any

any: typeof any

Operator ANY ARRAY (PG only)

[Op.any]: [2,3]

In SQL

ANY (ARRAY[2, 3]::INTEGER[])

Operator LIKE ANY ARRAY (also works for iLike and notLike)

[Op.like]: { [Op.any]: ['cat', 'hat']}

In SQL

LIKE ANY (ARRAY['cat', 'hat'])

`Readonly`anyKeyExists

anyKeyExists: typeof anyKeyExists

Operator ?|

[Op.anyKeyExists]: ['a', 'b']

In SQL

?| ARRAY['a', 'b']

`Readonly`between

between: typeof between

Operator BETWEEN

[Op.between]: [6, 10]

In SQL

BETWEEN 6 AND 10

`Readonly`col

col: typeof col

With dialect specific column identifiers (PG in this example)

[Op.col]: 'user.organization_id'

In SQL

= "user"."organization_id"

`Readonly`contained

contained: typeof contained

Operator <@ (PG array contained by operator)

[Op.contained]: [1, 2]

In SQL

<@ [1, 2)

`Readonly`contains

contains: typeof contains

Operator @> (PG array contains operator)

[Op.contains]: [1, 2]

In SQL

@> [1, 2)

`Readonly`endsWith

endsWith: typeof endsWith

Operator LIKE

[Op.endsWith]: 'hat'

In SQL

LIKE '%hat'

`Readonly`eq

eq: typeof eq

Operator =

[Op.eq]: 3

In SQL

= 3

`Readonly`gt

gt: typeof gt

Operator >

[Op.gt]: 6

In SQL

> 6

`Readonly`gte

gte: typeof gte

Operator >=

[Op.gte]: 6

In SQL

>= 6

`Readonly`iLike

iLike: typeof iLike

Operator ILIKE (case insensitive) (PG only)

[Op.iLike]: '%hat'

In SQL

ILIKE '%hat'

`Readonly`in

in: typeof in

Operator IN

[Op.in]: [1, 2]

In SQL

IN [1, 2]

`Readonly`iRegexp

iRegexp: typeof iRegexp

Operator ~* (PG only)

[Op.iRegexp]: '^[h|a|t]'

In SQL

~* '^[h|a|t]'

`Readonly`is

is: typeof is

Operator IS

[Op.is]: null

In SQL

IS null

`Readonly`isNot

isNot: typeof isNot

Operator IS NOT

[Op.isNot]: null

In SQL

IS NOT null

`Readonly`like

like: typeof like

Operator LIKE

[Op.like]: '%hat'

In SQL

LIKE '%hat'

`Readonly`lt

lt: typeof lt

Operator <

[Op.lt]: 10

In SQL

< 10

`Readonly`lte

lte: typeof lte

Operator <=

[Op.lte]: 10

In SQL

<= 10

`Readonly`match

match: typeof match

Operator @@

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

In SQL

@@ to_tsquery('fat & rat')

`Readonly`ne

ne: typeof ne

Operator !=

[Op.ne]: 20

In SQL

!= 20

`Readonly`noExtendLeft

noExtendLeft: typeof noExtendLeft

Operator &> (PG range does not extend to the left of operator)

[Op.noExtendLeft]: [1, 2]

In SQL

&> [1, 2)

`Readonly`noExtendRight

noExtendRight: typeof noExtendRight

Operator &< (PG range does not extend to the right of operator)

[Op.noExtendRight]: [1, 2]

In SQL

&< [1, 2)

`Readonly`not

not: typeof not

Operator NOT

[Op.not]: true

In SQL

IS NOT TRUE

`Readonly`notBetween

notBetween: typeof notBetween

Operator NOT BETWEEN

[Op.notBetween]: [11, 15]

In SQL

NOT BETWEEN 11 AND 15

`Readonly`notEndsWith

notEndsWith: typeof notEndsWith

Operator NOT LIKE

[Op.notEndsWith]: 'hat'

In SQL

NOT LIKE '%hat'

`Readonly`notILike

notILike: typeof notILike

Operator NOT ILIKE (case insensitive) (PG only)

[Op.notILike]: '%hat'

In SQL

NOT ILIKE '%hat'

`Readonly`notIn

notIn: typeof notIn

Operator NOT IN

[Op.notIn]: [1, 2]

In SQL

NOT IN [1, 2]

`Readonly`notIRegexp

notIRegexp: typeof notIRegexp

Operator !~* (PG only)

[Op.notIRegexp]: '^[h|a|t]'

In SQL

!~* '^[h|a|t]'

`Readonly`notLike

notLike: typeof notLike

Operator NOT LIKE

[Op.notLike]: '%hat'

In SQL

NOT LIKE '%hat'

`Readonly`notRegexp

notRegexp: typeof notRegexp

Operator NOT REGEXP (MySQL/PG only)

[Op.notRegexp]: '^[h|a|t]'

In SQL

NOT REGEXP/!~ '^[h|a|t]'

`Readonly`notStartsWith

notStartsWith: typeof notStartsWith

Operator NOT LIKE

[Op.notStartsWith]: 'hat'

In SQL

NOT LIKE 'hat%'

`Readonly`notSubstring

notSubstring: typeof notSubstring

Operator LIKE

[Op.notSubstring]: 'hat'

In SQL

NOT LIKE '%hat%'

`Readonly`or

or: typeof or

Operator OR

[Op.or]: [{a: 5}, {a: 6}]

In SQL

(a = 5 OR a = 6)

`Readonly`overlap

overlap: typeof overlap

Operator && (PG array overlap operator)

[Op.overlap]: [1, 2]

In SQL

&& [1, 2)

`Readonly`regexp

regexp: typeof regexp

Operator REGEXP (MySQL/PG only)

[Op.regexp]: '^[h|a|t]'

In SQL

REGEXP/~ '^[h|a|t]'

`Readonly`startsWith

startsWith: typeof startsWith

Operator LIKE

[Op.startsWith]: 'hat'

In SQL

LIKE 'hat%'

`Readonly`strictLeft

strictLeft: typeof strictLeft

Operator << (PG range strictly left of operator)

[Op.strictLeft]: [1, 2]

In SQL

<< [1, 2)

`Readonly`strictRight

strictRight: typeof strictRight

Operator >> (PG range strictly right of operator)

[Op.strictRight]: [1, 2]

In SQL

>> [1, 2)

`Readonly`substring

substring: typeof substring

Operator LIKE

[Op.substring]: 'hat'

In SQL

LIKE '%hat%'

`Readonly`values

values: typeof values

Operator VALUES

[Op.values]: [4, 5, 6]

In SQL

VALUES (4), (5), (6)

Interface OpTypes

Index

Properties

Properties

Readonlyadjacent

Readonlyall

ReadonlyallKeysExist

Readonlyand

Readonlyany

ReadonlyanyKeyExists

Readonlybetween

Readonlycol

Readonlycontained

Readonlycontains

ReadonlyendsWith

Readonlyeq

Readonlygt

Readonlygte

ReadonlyiLike

Readonlyin

ReadonlyiRegexp

Readonlyis

ReadonlyisNot

Readonlylike

Readonlylt

Readonlylte

Readonlymatch

Readonlyne

ReadonlynoExtendLeft

ReadonlynoExtendRight

Readonlynot

ReadonlynotBetween

ReadonlynotEndsWith

ReadonlynotILike

ReadonlynotIn

ReadonlynotIRegexp

ReadonlynotLike

ReadonlynotRegexp

ReadonlynotStartsWith

ReadonlynotSubstring

Readonlyor

Readonlyoverlap

Readonlyregexp

ReadonlystartsWith

ReadonlystrictLeft

ReadonlystrictRight

Readonlysubstring

Readonlyvalues

Settings

On This Page

`Readonly`adjacent

`Readonly`all

`Readonly`allKeysExist

`Readonly`and

`Readonly`any

`Readonly`anyKeyExists

`Readonly`between

`Readonly`col

`Readonly`contained

`Readonly`contains

`Readonly`endsWith

`Readonly`eq

`Readonly`gt

`Readonly`gte

`Readonly`iLike

`Readonly`in

`Readonly`iRegexp

`Readonly`is

`Readonly`isNot

`Readonly`like

`Readonly`lt

`Readonly`lte

`Readonly`match

`Readonly`ne

`Readonly`noExtendLeft

`Readonly`noExtendRight

`Readonly`not

`Readonly`notBetween

`Readonly`notEndsWith

`Readonly`notILike

`Readonly`notIn

`Readonly`notIRegexp

`Readonly`notLike

`Readonly`notRegexp

`Readonly`notStartsWith

`Readonly`notSubstring

`Readonly`or

`Readonly`overlap

`Readonly`regexp

`Readonly`startsWith

`Readonly`strictLeft

`Readonly`strictRight

`Readonly`substring

`Readonly`values