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;
    iRegexp: typeof iRegexp;
    in: typeof in;
    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;
    notIRegexp: typeof notIRegexp;
    notIn: typeof notIn;
    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

adjacent all allKeysExist and any anyKeyExists between col contained contains endsWith eq gt gte iLike iRegexp in is isNot like lt lte match ne noExtendLeft noExtendRight not notBetween notEndsWith notILike notIRegexp notIn notLike notRegexp notStartsWith notSubstring or overlap regexp startsWith strictLeft strictRight substring 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 iRegexp

iRegexp: typeof iRegexp

Operator ~* (PG only)

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

In SQL

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

Readonly in

in: typeof in

Operator IN

[Op.in]: [1, 2]

In SQL

IN [1, 2]

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 notIRegexp

notIRegexp: typeof notIRegexp

Operator !~* (PG only)

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

In SQL

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

Readonly notIn

notIn: typeof notIn

Operator NOT IN

[Op.notIn]: [1, 2]

In SQL

NOT IN [1, 2]

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)

Settings

Member Visibility

Theme

On This Page

adjacentallallKeysExistandanyanyKeyExistsbetweencolcontainedcontainsendsWitheqgtgteiLikeiRegexpinisisNotlikeltltematchnenoExtendLeftnoExtendRightnotnotBetweennotEndsWithnotILikenotIRegexpnotInnotLikenotRegexpnotStartsWithnotSubstringoroverlapregexpstartsWithstrictLeftstrictRightsubstringvalues