Variable Op`Const`

Op: {
    and: symbol;
    or: symbol;
    not: symbol;
    eq: symbol;
    is: symbol;
    ne: symbol;
    gt: symbol;
    gte: symbol;
    lt: symbol;
    lte: symbol;
    like: symbol;
    notLike: symbol;
    iLike: symbol;
    notILike: symbol;
    startsWith: symbol;
    notStartsWith: symbol;
    endsWith: symbol;
    notEndsWith: symbol;
    substring: symbol;
    notSubstring: symbol;
    col: symbol;
    in: symbol;
    notIn: symbol;
    between: symbol;
    notBetween: symbol;
    isNull: symbol;
    isNotNull: symbol;
    exists: symbol;
    notExists: symbol;
    regexp: symbol;
    notRegexp: symbol;
    iRegexp: symbol;
    notIRegexp: symbol;
    any: symbol;
    all: symbol;
    containsKey: symbol;
    containsKeyPath: symbol;
    containsPath: symbol;
    strictLeft: symbol;
    strictRight: symbol;
    noExtendRight: symbol;
    noExtendLeft: symbol;
    adj: symbol;
    notAdj: symbol;
    arrayContains: symbol;
    arrayContainedBy: symbol;
    arrayOverlaps: symbol;
    arrayAny: symbol;
    arrayAll: symbol;
    contains: symbol;
    containedBy: symbol;
    keyExists: symbol;
    overlap: symbol;
    match: symbol;
    $json: symbol;
    jsonPath: symbol;
    jsonContains: symbol;
    jsonHasKey: symbol;
    jsonbExtract: symbol;
    jsonbExtractText: symbol;
    jsonbExtractPath: symbol;
    jsonbExtractPathText: symbol;
    jsonConcat: symbol;
    jsonDelete: symbol;
    jsonDeletePath: symbol;
    jsonPathExists: symbol;
    jsonPathQuery: symbol;
    jsonTypeOf: symbol;
    json(path: string): symbol;
    key(
        pathOrOptions: string | { path: string; value?: any },
    ): Record<string, any>;
    literal(value: string): LiteralValue;
    cast(value: any, type: string): CastExpression;
    extract(field: any, part: ExtractPart): ExtractExpression;
    conv(
        value: any,
        from: string | null | undefined,
        to: string,
    ): ConvExpression;
    where(
        column: string | { $col: string },
        operator: any,
        value?: any,
    ): Record<string, any> | { $where: { $col: string; [key: string]: any } };
    asc(field: string): OrderExpression;
    desc(field: string): OrderExpression;
    random(): OrderExpression;
    isNotNullPredicate(value: any): boolean;
    matchAgainst(
        columns: string | string[],
        options?: { mode?: "boolean" | "natural" },
    ): { $match: { columns: string[]; mode: "boolean" | "natural" } };
    matchFulltext(
        columns: string | string[],
    ): { $match: { columns: string[]; mode: "natural" } };
    toTsvector(
        column: string,
        config?: string,
    ): { $tsvector: { column: string; config: string } };
    toTsquery(
        query: string,
        config?: string,
    ): { $tsquery: { query: string; config: string } };
    stDistance: symbol;
    stWithin: symbol;
    stContains: symbol;
    stIntersects: symbol;
    stDWithin: symbol;
    stCrosses: symbol;
    stOverlaps: symbol;
    stTouches: symbol;
    stEquals: symbol;
    stIsValid: symbol;
} = ...

Type Declaration

Readonlyand: symbol
Readonlyor: symbol
Readonlynot: symbol
Readonlyeq: symbol
Readonlyis: symbol
Readonlyne: symbol
Readonlygt: symbol
Readonlygte: symbol
Readonlylt: symbol
Readonlylte: symbol
Readonlylike: symbol
ReadonlynotLike: symbol
ReadonlyiLike: symbol
ReadonlynotILike: symbol
ReadonlystartsWith: symbol
ReadonlynotStartsWith: symbol
ReadonlyendsWith: symbol
ReadonlynotEndsWith: symbol
Readonlysubstring: symbol
ReadonlynotSubstring: symbol
Readonlycol: symbol
Readonlyin: symbol
ReadonlynotIn: symbol
Readonlybetween: symbol
ReadonlynotBetween: symbol
ReadonlyisNull: symbol
ReadonlyisNotNull: symbol
Readonlyexists: symbol
ReadonlynotExists: symbol
Readonlyregexp: symbol
ReadonlynotRegexp: symbol
ReadonlyiRegexp: symbol
ReadonlynotIRegexp: symbol
Readonlyany: symbol
Readonlyall: symbol
ReadonlycontainsKey: symbol
ReadonlycontainsKeyPath: symbol
ReadonlycontainsPath: symbol
ReadonlystrictLeft: symbol
ReadonlystrictRight: symbol
ReadonlynoExtendRight: symbol
ReadonlynoExtendLeft: symbol
Readonlyadj: symbol
ReadonlynotAdj: symbol

`Readonly`arrayContains: symbol

Array contains - checks if an array contains all specified elements PostgreSQL: @>

Example

// Find products where tags contains both 'electronics' and 'sale'
Product.findAll({ where: { tags: { [Op.arrayContains]: ['electronics', 'sale'] } } })
// SQL: WHERE tags @> ARRAY['electronics', 'sale']

`Readonly`arrayContainedBy: symbol

Array contained by - checks if an array is contained by the specified elements PostgreSQL: <@

Example

// Find products where tags is contained by ['electronics', 'sale', 'new']
Product.findAll({ where: { tags: { [Op.arrayContainedBy]: ['electronics', 'sale'] } } })
// SQL: WHERE tags <@ ARRAY['electronics', 'sale']

`Readonly`arrayOverlaps: symbol

Array overlaps - checks if arrays have common elements PostgreSQL: &&

Example

// Find products where tags overlaps with ['electronics', 'sale']
Product.findAll({ where: { tags: { [Op.arrayOverlaps]: ['electronics', 'sale'] } } })
// SQL: WHERE tags && ARRAY['electronics', 'sale']

`Readonly`arrayAny: symbol

Array ANY - checks if any element matches the condition PostgreSQL: ANY

Example

// Find products where any tag equals 'electronics'
Product.findAll({ where: { tags: { [Op.arrayAny]: 'electronics' } } })
// SQL: WHERE 'electronics' = ANY(tags)

`Readonly`arrayAll: symbol

Array ALL - checks if all elements match the condition PostgreSQL: ALL

Example

// Find products where all prices are greater than 100
Product.findAll({ where: { prices: { [Op.arrayAll]: { [Op.gt]: 100 } } } })
// SQL: WHERE 100 > ALL(prices)

Readonlycontains: symbol

JSON contains - checks if JSON document contains the specified value PostgreSQL: @> MySQL: JSON_CONTAINS SQLite: JSON_EXTRACT
Example
```
// Find users where preferences contains { theme: 'dark' }
User.findAll({ where: { preferences: { [Op.contains]: { theme: 'dark' } } } })
```

`Readonly`containedBy: symbol

JSON is contained in - checks if the value is contained in the JSON column PostgreSQL: <@

Example

// Find users where settings is contained in the specified JSON
User.findAll({ where: { settings: { [Op.containedBy]: { theme: 'dark', lang: 'en' } } } })

`Readonly`keyExists: symbol

JSON key exists - checks if a key (or array index) exists in a JSON object/array

Example

// Find users where 'role' key exists in data column
User.findAll({ where: { data: { [Op.keyExists]: 'role' } } })

// Find users where array index 0 exists
User.findAll({ where: { tags: { [Op.keyExists]: '0' } } })

`Readonly`overlap: symbol

JSON overlap - checks if JSON arrays overlap (have common elements) PostgreSQL: &&

Example

// Find users where tags overlaps with ['admin', 'vip']
User.findAll({ where: { tags: { [Op.overlap]: ['admin', 'vip'] } } })

`Readonly`match: symbol

Column reference - reference another column in a WHERE clause Used for comparing one column to another

Example

// Find orders where quantity equals available stock
Order.findAll({ where: { quantity: { [Op.col]: 'available_stock' } } })

Readonly$json: symbol

`Readonly`jsonPath: symbol

JSON path explicit operator - explicit JSON path with field and path separated Convenience method combining field and path in one call

Example

// Query with field and path separated
User.findAll({
  where: {
    data: { [Op.jsonPath('settings', 'theme')]: 'dark' }
  }
})
// SQLite/MySQL: WHERE json_extract(data, '$.settings.theme') = 'dark'
// PostgreSQL: WHERE data->>'settings'->>'theme' = 'dark'

// Check if path exists (no value comparison)
User.findAll({
  where: {
    data: { [Op.jsonPath('settings', 'theme')]: { [Op.ne]: null } }
  }
})

`Readonly`jsonContains: symbol

JSON contains - checks if a JSON column contains a specific value or object PostgreSQL: @> (contains), MySQL: JSON_CONTAINS, SQLite: json_each

Example

// Find users where preferences contains { theme: 'dark' }
User.findAll({ where: { preferences: { [Op.jsonContains]: { theme: 'dark' } } } })
// SQL: WHERE preferences @> '{"theme":"dark"}' (PostgreSQL)
// SQL: WHERE JSON_CONTAINS(preferences, '{"theme":"dark"}') (MySQL)

`Readonly`jsonHasKey: symbol

JSON has key - checks if a JSON column has a specific key PostgreSQL: ? (jsonb_exists), MySQL: JSON_CONTAINS_PATH, SQLite: json_each

Example

// Find users where data column has 'role' key
User.findAll({ where: { data: { [Op.jsonHasKey]: 'role' } } })
// SQL: WHERE data ? 'role' (PostgreSQL)
// SQL: WHERE JSON_CONTAINS_PATH(data, 'one', '$.role') (MySQL)

`Readonly`jsonbExtract: symbol

JSONB extract - extracts a JSON object field (returns JSON) PostgreSQL: -> operator

Example

// Extract field as JSON: data -> 'key'
User.findAll({ where: { data: { [Op.jsonbExtract]: { path: 'key' } } } })
// SQL: WHERE data -> 'key'

`Readonly`jsonbExtractText: symbol

JSONB extract text - extracts a JSON object field as text (returns text) PostgreSQL: ->> operator

Example

// Extract field as text: data ->> 'key'
User.findAll({ where: { data: { [Op.jsonbExtractText]: { path: 'key', value: 'someValue' } } } })
// SQL: WHERE data ->> 'key' = 'someValue'

`Readonly`jsonbExtractPath: symbol

JSONB extract path - extracts JSON by path (returns JSON) PostgreSQL: #> operator

Example

// Extract nested path as JSON: data #> '{a, b}'
User.findAll({ where: { data: { [Op.jsonbExtractPath]: { path: ['a', 'b'] } } } })
// SQL: WHERE data #> '{a, b}'

`Readonly`jsonbExtractPathText: symbol

JSONB extract path text - extracts JSON by path as text (returns text) PostgreSQL: #>> operator

Example

// Extract nested path as text: data #>> '{a, b}'
User.findAll({ where: { data: { [Op.jsonbExtractPathText]: { path: ['a', 'b'], value: 'someValue' } } } })
// SQL: WHERE data #>> '{a, b}' = 'someValue'

`Readonly`jsonConcat: symbol

JSONB concatenation - concatenates two JSONB values PostgreSQL: || operator

Example

// Concatenate JSONB values: data || '{"key": "value"}'
User.findAll({ where: { data: { [Op.jsonConcat]: { key: 'value' } } } })
// SQL: WHERE data || '{"key": "value"}'

`Readonly`jsonDelete: symbol

JSONB delete key - deletes a key from JSONB object PostgreSQL: - operator

Example

// Delete key from JSONB: data - 'key'
User.findAll({ where: { data: { [Op.jsonDelete]: 'key' } } })
// SQL: WHERE data - 'key'

`Readonly`jsonDeletePath: symbol

JSONB delete by path - deletes a key from JSONB by path PostgreSQL: #- operator

Example

// Delete by path: data #- '{a, b}'
User.findAll({ where: { data: { [Op.jsonDeletePath]: ['a', 'b'] } } })
// SQL: WHERE data #- '{a, b}'

`Readonly`jsonPathExists: symbol

JSON path exists - checks if a JSON path exists and returns boolean PostgreSQL: @? operator

Example

// Check if path exists: data @? '$.key'
User.findAll({ where: { data: { [Op.jsonPathExists]: '$.key' } } })
// SQL: WHERE data @? '$.key'

`Readonly`jsonPathQuery: symbol

JSON path query - evaluates JSON path and returns result PostgreSQL: @@ operator

Example

// Query JSON path: data @@ '$.key'
User.findAll({ where: { data: { [Op.jsonPathQuery]: '$.key' } } })
// SQL: WHERE data @@ '$.key'

`Readonly`jsonTypeOf: symbol

JSON type of - returns the type of a JSON value PostgreSQL: json_typeof function

Example

// Get JSON type: json_typeof(data)
User.findAll({ where: { data: { [Op.jsonTypeOf]: 'object' } } })
// SQL: WHERE json_typeof(data) = 'object'

json: function

json(path: string): symbol

Create a JSON column path reference for querying Returns a Symbol that can be used as a computed property key

Parameters

path: string

Returns symbol

Example

// Using as computed property key (recommended)
User.findAll({
  where: {
    settings: { [Op.json('$.theme')]: 'dark' }
  }
})
// SQL: WHERE json_extract(settings, '$.theme') = 'dark'

// Using with path prefix
User.findAll({
  where: {
    data: { [Op.json('address.city')]: 'NYC' }
  }
})
// SQL: WHERE json_extract(data, '$.address.city') = 'NYC'

key: function

key(pathOrOptions: string | { path: string; value?: any }): Record<string, any>

Create a JSON key path query Useful for accessing specific keys in a JSON/JSONB column

Parameters

pathOrOptions: string | { path: string; value?: any }

Returns Record<string, any>

Example

// Access JSON key 'name' from data column
User.findAll({
  where: {
    data: { [Op.key]: 'name' }
  }
})

// Compare JSON key to a value
User.findAll({
  where: {
    data: { [Op.key]: { path: 'name', value: 'John' } }
  }
})

// Nested key access
User.findAll({
  where: {
    data: { [Op.key]: { path: 'profile.settings.theme', value: 'dark' } }
  }
})

literal: function

literal(value: string): LiteralValue

Create a raw SQL literal Useful for embedding raw SQL expressions like NOW(), CURRENT_TIMESTAMP, etc.

Parameters

value: string

Returns LiteralValue

Example

// Use with update to set current timestamp
User.update({ lastLogin: Op.literal('NOW()') }, { where: { ... } })

// Use in where clause to compare with current time
User.findAll({
  where: {
    createdAt: { [Op.lt]: Op.literal('NOW()') }
  }
})

// Compare column to a literal value
User.findAll({
  where: {
    updatedAt: { [Op.gt]: Op.literal('createdAt') }
  }
})

// Use with Op.where
User.findAll({ where: Op.where(Op.col('created_at'), '>', Op.literal('NOW()')) })

cast: function

cast(value: any, type: string): CastExpression

Create a CAST expression for type casting SQL: CAST(value AS type)

Parameters

value: any
type: string

Returns CastExpression

Example

// CAST('2023-01-01' AS DATE)
User.findAll({
  attributes: [[Op.cast('2023-01-01', 'DATE'), 'dateOnly']]
})

// CAST(column AS INTEGER)
User.findAll({
  attributes: [[Op.cast(col('createdAt'), 'INTEGER'), 'dateInt']]
})

// CAST to DECIMAL
User.findAll({
  attributes: [[Op.cast(col('price'), 'DECIMAL(10,2)'), 'priceDecimal']]
})

extract: function

extract(field: any, part: ExtractPart): ExtractExpression

Create an EXTRACT expression for extracting date parts SQL: EXTRACT(part FROM field)

Parameters

field: any
part: ExtractPart

Returns ExtractExpression

Example

// EXTRACT(YEAR FROM createdAt)
User.findAll({
  attributes: [[Op.extract('createdAt', 'year'), 'year']]
})

// EXTRACT(MONTH FROM order_date)
User.findAll({
  attributes: [[Op.extract('orderDate', 'month'), 'month']]
})

// EXTRACT(HOUR FROM timestamp)
User.findAll({
  attributes: [[Op.extract('createdAt', 'hour'), 'hour']]
})

conv: function
- conv(value: any, from: string | null | undefined, to: string): ConvExpression
  Create a CONVERT expression for type conversion SQL: CONVERT(value, type) for MySQL, CAST for other dialects
  Parameters
  - value: any
  - from: string | null | undefined
  - to: string
  Returns ConvExpression
  Example
  // CONVERT(value, type) User.findAll({ attributes: [[Op.conv(col('value'), null, 'CHAR'), 'strValue']] }) // MySQL charset conversion User.findAll({ attributes: [[Op.conv(col('name'), null, 'utf8mb4'), 'utf8Name']] })
  - Defined in operators.ts:639

where: function

where(
    column: string | { $col: string },
    operator: any,
    value?: any,
): Record<string, any> | { $where: { $col: string; [key: string]: any } }

Create a where clause with a column reference Supports both simple equality (2 args) and explicit operator (3 args)

Parameters

column: string | { $col: string }
operator: any
Optionalvalue: any

Returns Record<string, any> | { $where: { $col: string; [key: string]: any } }

Example

// Simple equality (2 args) - defaults to =
Op.where(Op.col('username'), 'john')
// => { $where: { $col: 'username', $eq: 'john' } }

// Compare column to a value with explicit operator
Op.where(Op.col('user.id'), '=', 1)
// => { $where: { $col: 'user.id', $eq: 1 } }

// Compare column to another column
Op.where(Op.col('balance'), '>', Op.col('credit_limit'))
// => { $where: { $col: 'balance', $gt: { $col: 'credit_limit' } } }

// Using with Op.eq symbol
Op.where(Op.col('user.id'), Op.eq, 1)
// => { $where: { $col: 'user.id', $eq: 1 } }

// Using with findAll
User.findAll({ where: Op.where(Op.col('username'), 'john') })
User.findAll({ where: Op.where('status', 'active') })

asc: function

asc(field: string): OrderExpression

Create an ascending order expression SQL: ORDER BY field ASC

Parameters

field: string

Returns OrderExpression

Example

// Order by name ascending
User.findAll({ order: [Op.asc('name')] })
// SQL: ORDER BY name ASC

// Multiple order conditions
User.findAll({ order: [Op.asc('name'), Op.desc('createdAt')] })

desc: function

desc(field: string): OrderExpression

Create a descending order expression SQL: ORDER BY field DESC

Parameters

field: string

Returns OrderExpression

Example

// Order by createdAt descending (newest first)
User.findAll({ order: [Op.desc('createdAt')] })
// SQL: ORDER BY createdAt DESC

// Combined with asc
User.findAll({ order: [Op.asc('name'), Op.desc('createdAt')] })

random: function

random(): OrderExpression

Create a random order expression SQL: ORDER BY RANDOM() (SQLite/PostgreSQL) or ORDER BY RAND() (MySQL)

Returns OrderExpression

Example

// Random ordering (useful for sampling)
User.findAll({ order: [Op.random()] })
// SQLite: ORDER BY RANDOM()
// MySQL: ORDER BY RAND()
// PostgreSQL: ORDER BY RANDOM()

// With limit for random sample
User.findAll({ order: [Op.random()], limit: 5 })

isNotNullPredicate: function

isNotNullPredicate(value: any): boolean

Check if a value is not null Returns true if the value is not null or undefined Useful as a predicate for filtering arrays

Parameters

value: any

Returns boolean

Example

// Filter out null values from an array
const values = [1, null, 2, undefined, 3];
const notNullValues = values.filter(Op.isNotNull);
// => [1, 2, 3]

// Using in array filter with objects
const users = [{ name: 'John', age: null }, { name: 'Jane', age: 25 }];
const withAge = users.filter(u => Op.isNotNull(u.age));
// => [{ name: 'Jane', age: 25 }]

matchAgainst: function
- matchAgainst(
  columns: string | string[],
  options?: { mode?: "boolean" | "natural" },
  ): { $match: { columns: string[]; mode: "boolean" | "natural" } }
  Create a full-text search MATCH AGAINST condition (MySQL) SQL: MATCH(columns) AGAINST(searchTerm [IN NATURAL LANGUAGE MODE | IN BOOLEAN MODE])
  Parameters
  - columns: string | string[]
  - Optionaloptions: { mode?: "boolean" | "natural" }
  Returns { $match: { columns: string[]; mode: "boolean" | "natural" } }
  Example
  // Natural language mode search Article.findAll({ where: { [Op.matchAgainst(['title', 'body'])]: 'database' } }) // SQL: WHERE MATCH(title, body) AGAINST('database' IN NATURAL LANGUAGE MODE) // Boolean mode search Article.findAll({ where: { [Op.matchAgainst(['title', 'body'], { mode: 'boolean' })]: '+mysql -oracle' } }) // SQL: WHERE MATCH(title, body) AGAINST('+mysql -oracle' IN BOOLEAN MODE)
  - Defined in operators.ts:872
matchFulltext: function
- matchFulltext(
  columns: string | string[],
  ): { $match: { columns: string[]; mode: "natural" } }
  Create a full-text search condition (alias for matchAgainst with explicit mode) SQL: MATCH(columns) AGAINST(searchTerm IN NATURAL LANGUAGE MODE)
  Parameters
  - columns: string | string[]
  Returns { $match: { columns: string[]; mode: "natural" } }
  Example
  Article.findAll({ where: { [Op.matchFulltext(['title', 'body'])]: 'database' } }) // SQL: WHERE MATCH(title, body) AGAINST('database' IN NATURAL LANGUAGE MODE)
  - Defined in operators.ts:899
toTsvector: function
- toTsvector(
  column: string,
  config?: string,
  ): { $tsvector: { column: string; config: string } }
  Create a PostgreSQL tsvector expression SQL: to_tsvector(config, column)
  Parameters
  - column: string
  - config: string = 'english'
  Returns { $tsvector: { column: string; config: string } }
  Example
  Article.findAll({ where: { [Op.toTsvector('title')]: { $tsquery: 'database' } } }) // SQL: WHERE to_tsvector('english', title) @@ to_tsquery('english', 'database')
  - Defined in operators.ts:923
toTsquery: function
- toTsquery(
  query: string,
  config?: string,
  ): { $tsquery: { query: string; config: string } }
  Create a PostgreSQL tsquery expression SQL: to_tsquery(config, query)
  Parameters
  - query: string
  - config: string = 'english'
  Returns { $tsquery: { query: string; config: string } }
  Example
  Article.findAll({ where: { body: { [Op.toTsquery('database')]: true } } }) // SQL: WHERE body @@ to_tsquery('english', 'database')
  - Defined in operators.ts:949
ReadonlystDistance: symbol

ST_Distance - calculate distance between two geometries MySQL: ST_Distance(geom1, geom2) PostgreSQL: ST_Distance(geom1, geom2) - for geometry, ST_Distance(geog1, geog2) for geography
Example
```
// Find locations within 100 meters of a point
Location.findAll({
  where: {
    location: { [Op.stDWithin]: { from: 'POINT(0 0)', distance: 100, srid: 4326 } }
  }
})
```

`Readonly`stWithin: symbol

ST_Within - check if geometry A is within geometry B MySQL: ST_Within(geom1, geom2) PostgreSQL: ST_Within(geom1, geom2)

Example

// Find locations within a polygon
Location.findAll({
  where: {
    location: { [Op.stWithin]: { geometry: 'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))', srid: 4326 } }
  }
})

`Readonly`stContains: symbol

ST_Contains - check if geometry A contains geometry B MySQL: ST_Contains(geom1, geom2) PostgreSQL: ST_Contains(geom1, geom2)

Example

// Find areas that contain a point
Area.findAll({
  where: {
    boundary: { [Op.stContains]: { geometry: 'POINT(5 5)', srid: 4326 } }
  }
})

`Readonly`stIntersects: symbol

ST_Intersects - check if two geometries intersect MySQL: ST_Intersects(geom1, geom2) PostgreSQL: ST_Intersects(geom1, geom2)

Example

// Find locations that intersect with a polygon
Location.findAll({
  where: {
    location: { [Op.stIntersects]: { geometry: 'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))', srid: 4326 } }
  }
})

ReadonlystDWithin: symbol

ST_DWithin - check if geometries are within a given distance PostgreSQL: ST_DWithin (for both geometry and geography) MySQL 8.0+: ST_Distance_Sphere or ST_DWithin (with care)
Example
```
// Find locations within 1km of a point
Location.findAll({
  where: {
    location: { [Op.stDWithin]: { from: 'POINT(-122.4194 37.7749)', distance: 1000, srid: 4326 } }
  }
})
```
ReadonlystCrosses: symbol

ST_Crosses - check if two geometries cross MySQL: ST_Crosses(geom1, geom2) PostgreSQL: ST_Crosses(geom1, geom2)
ReadonlystOverlaps: symbol

ST_Overlaps - check if two geometries overlap MySQL: ST_Overlaps(geom1, geom2) PostgreSQL: ST_Overlaps(geom1, geom2)
ReadonlystTouches: symbol

ST_Touches - check if two geometries touch MySQL: ST_Touches(geom1, geom2) PostgreSQL: ST_Touches(geom1, geom2)
ReadonlystEquals: symbol

ST_Equals - check if two geometries are equal MySQL: ST_Equals(geom1, geom2) PostgreSQL: ST_Equals(geom1, geom2)
ReadonlystIsValid: symbol

ST_IsValid - check if a geometry is valid MySQL: ST_IsValid(geom) PostgreSQL: ST_IsValid(geom)

Variable OpConst

Type Declaration

Readonlyand: symbol

Readonlyor: symbol

Readonlynot: symbol

Readonlyeq: symbol

Readonlyis: symbol

Readonlyne: symbol

Readonlygt: symbol

Readonlygte: symbol

Readonlylt: symbol

Readonlylte: symbol

Readonlylike: symbol

ReadonlynotLike: symbol

ReadonlyiLike: symbol

ReadonlynotILike: symbol

ReadonlystartsWith: symbol

ReadonlynotStartsWith: symbol

ReadonlyendsWith: symbol

ReadonlynotEndsWith: symbol

Readonlysubstring: symbol

ReadonlynotSubstring: symbol

Readonlycol: symbol

Readonlyin: symbol

ReadonlynotIn: symbol

Readonlybetween: symbol

ReadonlynotBetween: symbol

ReadonlyisNull: symbol

ReadonlyisNotNull: symbol

Readonlyexists: symbol

ReadonlynotExists: symbol

Readonlyregexp: symbol

ReadonlynotRegexp: symbol

ReadonlyiRegexp: symbol

ReadonlynotIRegexp: symbol

Readonlyany: symbol

Readonlyall: symbol

ReadonlycontainsKey: symbol

ReadonlycontainsKeyPath: symbol

ReadonlycontainsPath: symbol

ReadonlystrictLeft: symbol

ReadonlystrictRight: symbol

ReadonlynoExtendRight: symbol

ReadonlynoExtendLeft: symbol

Readonlyadj: symbol

ReadonlynotAdj: symbol

ReadonlyarrayContains: symbol

Example

ReadonlyarrayContainedBy: symbol

Example

ReadonlyarrayOverlaps: symbol

Example

ReadonlyarrayAny: symbol

Example

ReadonlyarrayAll: symbol

Example

Readonlycontains: symbol

Example

ReadonlycontainedBy: symbol

Example

ReadonlykeyExists: symbol

Example

Readonlyoverlap: symbol

Example

Readonlymatch: symbol

Example

Readonly$json: symbol

ReadonlyjsonPath: symbol

Example

ReadonlyjsonContains: symbol

Example

ReadonlyjsonHasKey: symbol

Example

ReadonlyjsonbExtract: symbol

Example

ReadonlyjsonbExtractText: symbol

Example

ReadonlyjsonbExtractPath: symbol

Example

ReadonlyjsonbExtractPathText: symbol

Variable Op`Const`

`Readonly`and: symbol

`Readonly`or: symbol

`Readonly`not: symbol

`Readonly`eq: symbol

`Readonly`is: symbol

`Readonly`ne: symbol

`Readonly`gt: symbol

`Readonly`gte: symbol

`Readonly`lt: symbol

`Readonly`lte: symbol

`Readonly`like: symbol

`Readonly`notLike: symbol

`Readonly`iLike: symbol

`Readonly`notILike: symbol

`Readonly`startsWith: symbol

`Readonly`notStartsWith: symbol

`Readonly`endsWith: symbol

`Readonly`notEndsWith: symbol

`Readonly`substring: symbol

`Readonly`notSubstring: symbol

`Readonly`col: symbol

`Readonly`in: symbol

`Readonly`notIn: symbol

`Readonly`between: symbol

`Readonly`notBetween: symbol

`Readonly`isNull: symbol

`Readonly`isNotNull: symbol

`Readonly`exists: symbol

`Readonly`notExists: symbol

`Readonly`regexp: symbol

`Readonly`notRegexp: symbol

`Readonly`iRegexp: symbol

`Readonly`notIRegexp: symbol

`Readonly`any: symbol

`Readonly`all: symbol

`Readonly`containsKey: symbol

`Readonly`containsKeyPath: symbol

`Readonly`containsPath: symbol

`Readonly`strictLeft: symbol

`Readonly`strictRight: symbol

`Readonly`noExtendRight: symbol

`Readonly`noExtendLeft: symbol

`Readonly`adj: symbol

`Readonly`notAdj: symbol

`Readonly`arrayContains: symbol

`Readonly`arrayContainedBy: symbol

`Readonly`arrayOverlaps: symbol

`Readonly`arrayAny: symbol

`Readonly`arrayAll: symbol

`Readonly`contains: symbol

`Readonly`containedBy: symbol

`Readonly`keyExists: symbol

`Readonly`overlap: symbol

`Readonly`match: symbol

`Readonly`$json: symbol

`Readonly`jsonPath: symbol

`Readonly`jsonContains: symbol

`Readonly`jsonHasKey: symbol

`Readonly`jsonbExtract: symbol

`Readonly`jsonbExtractText: symbol

`Readonly`jsonbExtractPath: symbol

`Readonly`jsonbExtractPathText: symbol

`Readonly`jsonConcat: symbol

`Readonly`jsonDelete: symbol

`Readonly`jsonDeletePath: symbol

`Readonly`jsonPathExists: symbol

`Readonly`jsonPathQuery: symbol

`Readonly`jsonTypeOf: symbol