select *, ALL(x>0 AND x<4 FOR x IN j.ar) from tbl

select *, ALL(x>0 AND x<4 FOR x IN j.ar) cond from tbl where cond=1

+------+--------------+--------------------------------+
| id   | j            | all(x>0 and x<4 for x in j.ar) |
+------+--------------+--------------------------------+
|    1 | {"ar":[1,3]} |                              1 |
|    2 | {"ar":[3,7]} |                              0 |
+------+--------------+--------------------------------+
2 rows in set (0.00 sec)

+------+--------------+------+
| id   | j            | cond |
+------+--------------+------+
|    1 | {"ar":[1,3]} |    1 |
+------+--------------+------+
1 row in set (0.00 sec)

select * from tbl where all(m) >= 1

select * from tbl where all(m) in (1, 3, 7, 10)

+------+------+
| id   | m    |
+------+------+
|    1 | 1,3  |
|    2 | 3,7  |
+------+------+
2 rows in set (0.00 sec)

+------+------+
| id   | m    |
+------+------+
|    1 | 1,3  |
|    2 | 3,7  |
+------+------+
2 rows in set (0.00 sec)

select * from tbl where all(m) not in (2, 4)

+------+------+
| id   | m    |
+------+------+
|    1 | 1,3  |
|    2 | 3,7  |
+------+------+
2 rows in set (0.00 sec)

select * from tbl where tags all('bug', 'release')

mysql> select * from tbl
+------+---------------------------+
| id   | tags                      |
+------+---------------------------+
|    1 | bug priority_high release |
|    2 | bug priority_low release  |
+------+---------------------------+
2 rows in set (0.00 sec)
mysql> select * from tbl where tags not all('bug')
Empty set (0.00 sec)

+------+---------------------------+
| id   | tags                      |
+------+---------------------------+
|    1 | bug priority_high release |
|    2 | bug priority_low release  |
+------+---------------------------+
2 rows in set (0.00 sec)

select *, ANY(x>5 AND x<10 FOR x IN j.ar) from tbl

select *, ANY(x>5 AND x<10 FOR x IN j.ar) cond from tbl where cond=1

+------+--------------+---------------------------------+
| id   | j            | any(x>5 and x<10 for x in j.ar) |
+------+--------------+---------------------------------+
|    1 | {"ar":[1,3]} |                               0 |
|    2 | {"ar":[3,7]} |                               1 |
+------+--------------+---------------------------------+
2 rows in set (0.00 sec)

+------+--------------+------+
| id   | j            | cond |
+------+--------------+------+
|    2 | {"ar":[3,7]} |    1 |
+------+--------------+------+
1 row in set (0.00 sec)

mysql> select * from tbl
+------+------+
| id   | m    |
+------+------+
|    1 | 1,3  |
|    2 | 3,7  |
+------+------+
2 rows in set (0.01 sec)
mysql> select * from tbl where any(m) > 5
+------+------+
| id   | m    |
+------+------+
|    2 | 3,7  |
+------+------+
1 row in set (0.00 sec)

select * from tbl where any(m) in (1, 7, 10)

+------+------+
| id   | m    |
+------+------+
|    1 | 1,3  |
|    2 | 3,7  |
+------+------+
2 rows in set (0.00 sec)

mysql> select * from tbl
+------+------+
| id   | m    |
+------+------+
|    1 | 1,3  |
|    2 | 3,7  |
+------+------+
2 rows in set (0.00 sec)
mysql> select * from tbl where any(m) not in (1, 3, 5)
+------+------+
| id   | m    |
+------+------+
|    2 | 3,7  |
+------+------+
1 row in set (0.00 sec)

select * from tbl where tags any('bug', 'feature')

select * from tbl
--------------
+------+---------------------------+
| id   | tags                      |
+------+---------------------------+
|    1 | bug priority_high release |
|    2 | bug priority_low release  |
+------+---------------------------+
2 rows in set (0.00 sec)
--------------
select * from tbl where tags not any('feature', 'priority_low')
--------------
+------+---------------------------+
| id   | tags                      |
+------+---------------------------+
|    1 | bug priority_high release |
+------+---------------------------+
1 row in set (0.01 sec)

+------+---------------------------+
| id   | tags                      |
+------+---------------------------+
|    1 | bug priority_high release |
|    2 | bug priority_low release  |
+------+---------------------------+
2 rows in set (0.00 sec)

CONTAINS(polygon, x, y) checks whether the (x,y) point is within the given polygon, and returns 1 if true, or 0 if false. The polygon has to be specified using either the POLY2D() function. The former function is intended for "small" polygons, meaning less than 500 km (300 miles) a side, and it doesn't take into account the Earth's curvature for speed. For larger distances, you should use GEOPOLY2D, which tessellates the given polygon in smaller parts, accounting for the Earth's curvature.

IF ( sqrt(3)*sqrt(3)-3<>0, a, b )
IF ( sqrt(3)*sqrt(3)-3, a, b )

In the first case, the comparison operator <> will return 0.0 (false) due to a threshold, and IF() will always return ** as a result. In the second case, the same sqrt(3)*sqrt(3)-3 expression will be compared with zero without a threshold by the IF() function itself. However, its value will be slightly different from zero due to limited floating-point calculation precision. Because of this, the comparison with 0.0 done by IF() will not pass, and the second variant will return 'a' as a result.

key_of_the_bucket = interval + offset * floor ( ( value - offset ) / interval )

SELECT COUNT(*),
HISTOGRAM(price, {hist_interval=100}) as price_range
FROM facets
GROUP BY price_range ORDER BY price_range ASC;

IN(expr,val1,val2,...) takes 2 or more arguments and returns 1 if the 1st argument (expr) is equal to any of the other arguments (val1..valN), or 0 otherwise. Currently, all the checked values (but not the expression itself) are required to be constant. The constants are pre-sorted, and binary search is used, so IN() even against a large arbitrary list of constants will be very quick. The first argument can also be an MVA attribute. In that case, IN() will return 1 if any of the MVA values are equal to any of the other arguments. IN() also supports IN(expr,@uservar) syntax to check whether the value belongs to the list in the given global user variable. The first argument can be a JSON attribute.

INDEXOF(cond FOR var IN json.array) function iterates through all elements in the array and returns the index of the first element for which 'cond' is true, and -1 if 'cond' is false for every element in the array.

INTERVAL(expr,point1,point2,point3,...) takes 2 or more arguments and returns the index of the argument that is less than the first argument: it returns 0 if expr<point1, 1 if point1<=expr<point2, and so on. It is required that point1<point2<...<pointN for this function to work correctly.

LENGTH(attr_mva) function returns the number of elements in an MVA set. It works with both 32-bit and 64-bit MVA attributes. LENGTH(attr_json) returns the length of a field in JSON. The return value depends on the type of field. For example, LENGTH(json_attr.some_int) always returns 1, and LENGTH(json_attr.some_array) returns the number of elements in the array. LENGTH(string_expr) function returns the length of the string resulting from an expression. TO_STRING() must enclose the expression, regardless of whether the expression returns a non-string or it's simply a string attribute.

SELECT COUNT(*),
RANGE(price, {range_to=150},{range_from=150,range_to=300},{range_from=300}) price_range
FROM facets
GROUP BY price_range ORDER BY price_range ASC;

SELECT id, size, REMAP(size, 15, (5,6,7,8), (1,1,2,2)) s
FROM products
ORDER BY s ASC;

SELECT REMAP(userid, karmapoints, (1, 67), (999, 0)) FROM users;
SELECT REMAP(id%10, salary, (0), (0.0)) FROM employes;

This will put documents with sizes 5 and 6 first, followed by sizes 7 and 8. In case there's an original value not listed in the array (e.g. size 10), it will default to 15, and in this case, will be placed at the end.

Note, that CURTIME(), UTC_TIME(), UTC_TIMESTAMP(), and TIMEDIFF() can be promoted to numeric types using arbitrary conversion functions such as BIGINT(), DOUBLE(), etc.

select NOW();

POST /sql?mode=raw -d "select NOW()"

+------------+
| NOW()      |
+------------+
| 1615788407 |
+------------+

[
  {
    "columns": [
      {
        "now()": {
          "type": "long"
        }
      }
    ],
    "data": [
      {
        "now()": 1615788407
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select CURTIME();

POST /sql?mode=raw -d "select CURTIME()"

+-----------+
| CURTIME() |
+-----------+
| 07:06:30  |
+-----------+

[
  {
    "columns": [
      {
        "CURTIME()": {
          "type": "string"
        }
      }
    ],
    "data": [
      {
        "CURTIME()": "07:06:30"
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select curdate();

POST /sql?mode=raw -d "select CURDATE()"

+------------+
| curdate()  |
+------------+
| 2023-08-02 |
+------------+

[
  {
    "columns": [
      {
        "CURDATE()": {
          "type": "string"
        }
      }
    ],
    "data": [
      {
        "CURDATE()": "2023-08-02"
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select UTC_TIME();

POST /sql?mode=raw -d "select UTC_TIME()"

+------------+
| UTC_TIME() |
+------------+
| 06:06:18   |
+------------+

[
  {
    "columns": [
      {
        "UTC_TIME()": {
          "type": "string"
        }
      }
    ],
    "data": [
      {
        "UTC_TIME()": "06:06:18"
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select UTC_TIMESTAMP();

POST /sql?mode=raw -d "select UTC_TIMESTAMP()"

+---------------------+
| UTC_TIMESTAMP()     |
+---------------------+
| 2021-03-15 06:06:03 |
+---------------------+

[
  {
    "columns": [
      {
        "UTC_TIMESTAMP()": {
          "type": "string"
        }
      }
    ],
    "data": [
      {
        "UTC_TIMESTAMP()": "2021-03-15 06:06:0"
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select second(now());

POST /sql?mode=raw -d "select second(now())"

+---------------+
| second(now()) |
+---------------+
| 52            |
+---------------+

[
  {
    "columns": [
      {
        "second(now())": {
          "type": "long"
        }
      }
    ],
    "data": [
      {
        "second(now())": 52
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select minute(now());

POST /sql?mode=raw -d "select minute(now())"

+---------------+
| minute(now()) |
+---------------+
| 5             |
+---------------+

[
  {
    "columns": [
      {
        "minute(now())": {
          "type": "long"
        }
      }
    ],
    "data": [
      {
        "minute(now())": 5
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select hour(now());

POST /sql?mode=raw -d "select hour(now())"

+-------------+
| hour(now()) |
+-------------+
| 7           |
+-------------+

[
  {
    "columns": [
      {
        "hour(now())": {
          "type": "long"
        }
      }
    ],
    "data": [
      {
        "hour(now())": 7
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select day(now());

POST /sql?mode=raw -d "select day(now())"

+------------+
| day(now()) |
+------------+
| 15         |
+------------+

[
  {
    "columns": [
      {
        "day(now())": {
          "type": "long"
        }
      }
    ],
    "data": [
      {
        "day(now())": 15
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select month(now());

POST /sql?mode=raw -d "select month(now())"

+--------------+
| month(now()) |
+--------------+
| 3            |
+--------------+

[
  {
    "columns": [
      {
        "month(now())": {
          "type": "long"
        }
      }
    ],
    "data": [
      {
        "month(now())": 3
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select quarter(now());

POST /sql?mode=raw -d "select quarter(now())"

+----------------+
| quarter(now()) |
+----------------+
| 2              |
+----------------+

[
  {
    "columns": [
      {
        "quarter(now())": {
          "type": "long"
        }
      }
    ],
    "data": [
      {
        "quarter(now())": 2
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select year(now());

POST /sql?mode=raw -d "select year(now())"

+-------------+
| year(now()) |
+-------------+
| 2024        |
+-------------+

[
  {
    "columns": [
      {
        "year(now())": {
          "type": "long"
        }
      }
    ],
    "data": [
      {
        "year(now())": 2024
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select dayname(now());

POST /sql?mode=raw -d "select dayname(now())"

+----------------+
| dayname(now()) |
+----------------+
| Wednesday      |
+----------------+

[
  {
    "columns": [
      {
        "dayname(now())": {
          "type": "string"
        }
      }
    ],
    "data": [
      {
        "dayname(now())": "Wednesday"
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select monthname(now());

POST /sql?mode=raw -d "select monthname(now())"

+------------------+
| monthname(now()) |
+------------------+
| August           |
+------------------+

[
  {
    "columns": [
      {
        "monthname(now())": {
          "type": "string"
        }
      }
    ],
    "data": [
      {
        "monthname(now())": "August"
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select dayofweek(now());

POST /sql?mode=raw -d "select dayofweek(now())"

+------------------+
| dayofweek(now()) |
+------------------+
| 5                |
+------------------+

[
  {
    "columns": [
      {
        "dayofweek(now())": {
          "type": "long"
        }
      }
    ],
    "data": [
      {
        "dayofweek(now())": 5
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select dayofyear(now());

POST /sql?mode=raw -d "select dayofyear(now())"

+------------------+
| dayofyear(now()) |
+------------------+
|              214 |
+------------------+

[
  {
    "columns": [
      {
        "dayofyear(now())": {
          "type": "long"
        }
      }
    ],
    "data": [
      {
        "dayofyear(now())": 214
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select yearweek(now());

POST /sql?mode=raw -d "select yearweek(now())"

+-----------------+
| yearweek(now()) |
+-----------------+
|         2023211 |
+-----------------+

[
  {
    "columns": [
      {
        "yearweek(now())": {
          "type": "long"
        }
      }
    ],
    "data": [
      {
        "yearweek(now())": 2023211
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select yearmonth(now());

POST /sql?mode=raw -d "select yearmonth(now())"

+------------------+
| yearmonth(now()) |
+------------------+
| 202103           |
+------------------+

[
  {
    "columns": [
      {
        "yearmonth(now())": {
          "type": "long"
        }
      }
    ],
    "data": [
      {
        "yearmonth(now())": 202103
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select yearmonthday(now());

POST /sql?mode=raw -d "select yearmonthday(now())"

+---------------------+
| yearmonthday(now()) |
+---------------------+
| 20210315            |
+---------------------+

[
  {
    "columns": [
      {
        "yearmonthday(now())": {
          "type": "long"
        }
      }
    ],
    "data": [
      {
        "yearmonthday(now())": 20210315
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select timediff(1615787586, 1613787583);

POST /sql?mode=raw -d "select timediff(1615787586, 1613787583)"

+----------------------------------+
| timediff(1615787586, 1613787583) |
+----------------------------------+
| 555:33:23                        |
+----------------------------------+

[
  {
    "columns": [
      {
        "timediff(1615787586, 1613787583)": {
          "type": "string"
        }
      }
    ],
    "data": [
      {
        "timediff(1615787586, 1613787583)": "555:33:23"
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select datediff(1615787586, 1613787583);

POST /sql?mode=raw -d "select datediff(1615787586, 1613787583)"

+----------------------------------+
| datediff(1615787586, 1613787583) |
+----------------------------------+
|                               23 |
+----------------------------------+

[
  {
    "columns": [
      {
        "datediff(1615787586, 1613787583)": {
          "type": "long long"
        }
      }
    ],
    "data": [
      {
        "datediff(1615787586, 1613787583)": 23
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select date(now());

POST /sql?mode=raw -d "select date(now())"

+-------------+
| date(now()) |
+-------------+
| 2023-08-02  |
+-------------+

[
  {
    "columns": [
      {
        "date(now())": {
          "type": "string"
        }
      }
    ],
    "data": [
      {
        "date(now())": "2023-08-02"
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

select time(now());

POST /sql?mode=raw -d "select time(now())"

+-------------+
| time(now()) |
+-------------+
| 15:21:27    |
+-------------+

[
  {
    "columns": [
      {
        "time(now())": {
          "type": "string"
        }
      }
    ],
    "data": [
      {
        "time(now())": "15:21:27"
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

SELECT DATE_FORMAT(NOW(), 'year %Y and time %T');

POST /sql?mode=raw -d "select DATE_FORMAT(NOW(), 'year %Y and time %T')"

+------------------------------------------+
| DATE_FORMAT(NOW(), 'year %Y and time %T') |
+------------------------------------------+
| year 2023 and time 11:54:52              |
+------------------------------------------+

[
  {
    "columns": [
      {
        "DATE_FORMAT(NOW(), 'year %Y and time %T')": {
          "type": "string"
        }
      }
    ],
    "data": [
      {
        "DATE_FORMAT(NOW(), 'year %Y and time %T')": "year 2023 and time 11:54:52"
      }
    ],
    "total": 1,
    "error": "",
    "warning": ""
  }
]

This example formats the current date and time, displaying the four-digit year and the time in 24-hour format.

DATE_HISTOGRAM(expr, {calendar_interval='unit_name'}) or DATE_HISTOGRAM(expr, {fixed_interval='interval'}) takes a bucket size as a unit name or fixed interval and returns the bucket number for the value. Values are rounded to the closest bucket. The key function is:

key_of_the_bucket = interval * floor ( value / interval )

Intervals can be specified using a unit name, like week, or as a single unit, such as 1M. However, multiple units, like 2d, are not supported with calendar_interval but are allowed with fixed_interval.

The valid intervals for calendar_interval are:

• minute, 1m
• hour, 1h
• day, 1d
• week, 1w (a week is the interval between the start day of the week, hour, minute, second and the next week but the same day and time of the week)
• month, 1M
• year, 1y (a year is the interval between the start day of the month, time and the next year but the same day of the month, time)

The valid intervals for fixed_interval are:

• ms, 1000ms
• s, 30s
• minute, 2m
• hour, 3h
• day, 5d

Used in aggregation, FACET, and grouping.

The JSON date_histogram aggregate also supports time_zone and offset with calendar_interval; see Facet over histogram date values.

Example:

SELECT COUNT(*),
DATE_HISTOGRAM(tm, {calendar_interval='month'}) AS months
FROM facets
GROUP BY months ORDER BY months ASC;

DATE_RANGE(expr, {range_from='date_math', range_to='date_math'}) takes a set of ranges and returns the bucket number for the value. The expression includes the range_from value and excludes the range_to value for each range. The range can be open - having only the range_from or only the range_to value. The difference between this and the RANGE() function is that the range_from and range_to values can be expressed in Date math expressions.

Used in aggregation, FACET, and grouping.

Example:

SELECT COUNT(*),
DATE_RANGE(tm, {range_to='2017||+2M/M'},{range_from='2017||+2M/M',range_to='2017||+5M/M'},{range_from='2017||+5M/M'}) AS points
FROM idx_dates
GROUP BY points ORDER BY points ASC;

Date math lets you work with dates and times directly in your searches. It's especially useful for handling data that changes over time. With date math, you can easily do things like find entries from a certain period, analyze data trends, or manage when information should be removed. It simplifies working with dates by letting you add or subtract time from a given date, round dates to the nearest time unit, and more, all within your search queries.

To use date math, you start with a base date, which can be:

• now for the current date and time,
• or a specific date string ending with ||.

Then, you can modify this date with operations like:

• +1y to add one year,
• -1h to subtract one hour,
• /m to round to the nearest month.

You can use these units in your operations:

• s for seconds,
• m for minutes,
• h (or H) for hours,
• d for days,
• w for weeks,
• M for months,
• y for years.

Here are some examples of how you might use date math:

• now+4h means four hours from now.
• now-2d/d is the time two days ago, rounded to the nearest day.
• 2010-04-20||+2M/d is June 20, 2010, rounded to the nearest day.

GEODIST(lat1, lon1, lat2, lon2, [...]) function calculates the geosphere distance between two points specified by their coordinates. Note that by default, both latitudes and longitudes must be in radians, and the result will be in meters. You can use arbitrary expressions for any of the four coordinates. An optimized path will be chosen when one pair of arguments directly refers to a pair of attributes, and the other one is constant.

GEODIST() also accepts an optional 5th argument, allowing you to easily convert between input and output units and select the specific geodistance formula to use. The complete syntax and a few examples are as follows:

GEODIST(lat1, lon1, lat2, lon2, { option=value, ... })
GEODIST(40.7643929, -73.9997683, 40.7642578, -73.9994565, {in=degrees, out=feet})
GEODIST(51.50, -0.12, 29.98, 31.13, {in=deg, out=mi})

The known options and their values are:

• in = {deg | degrees | rad | radians}, specifies the input units;
• out = {m | meters | km | kilometers | ft | feet | mi | miles | yd | yards | in | inch | cm | centimeters | mm | millimeters | NM | nmi | nauticalmiles}, specifies the output units;
• method = {adaptive | haversine}, specifies the geodistance calculation method.

The default method is "adaptive". It is a well-optimized implementation that is both more precise and much faster at all times than "haversine".

haversine uses a sphere with a radius of 6,384 km, and adaptive uses the WGS84 ellipsoid (a 6,371 km sphere for points more than 13° of longitude apart), so both can differ by up to about 0.3% from tools that use the 6,371.0088 km mean Earth radius. To match those, use method=haversine and multiply the result by 0.99796504 (6,371.0088 / 6,384).

GEODIST() returns a 32-bit float, so a distance is precise to about 7 significant digits.

To filter by distance, compute GEODIST() in the select list with an alias and filter on the alias. GEODIST() can't be used directly in WHERE: WHERE GEODIST(...) <= 3 fails with a P01: syntax error.

SELECT id, GEODIST(lat, lon, 51.5074, -0.1278, {in=deg, out=km}) AS dist FROM listings WHERE dist <= 3 ORDER BY dist ASC;

GEOPOLY2D(lat1,lon1,lat2,lon2,lat3,lon3...) creates a polygon to be used with the CONTAINS() function. This function takes into account the Earth's curvature by tessellating the polygon into smaller ones, and should be used for larger areas. For small areas, the POLY2D() function can be used instead. The function expects coordinates to be pairs of latitude/longitude coordinates in degrees; if radians are used, it will give the same result as POLY2D().

POLY2D(x1,y1,x2,y2,x3,y3...) creates a polygon to be used with the CONTAINS() function. This polygon assumes a flat Earth, so it should not be too large; for large areas, the GEOPOLY2D() function, which takes Earth's curvature into consideration, should be used.

Concatenates two or more strings into one. Non-string arguments must be explicitly converted to string using the TO_STRING() function.

CONCAT(TO_STRING(float_attr), ',', TO_STRING(int_attr), ',', title)

LEVENSHTEIN ( pattern, source, {normalize=0, length_delta=0}) returns number (Levenshtein distance) of single-character edits (insertions, deletions or substitutions) between pattern and source strings required to make in pattern to make it source.

• pattern, source - constant string, string field name, JSON field name, or any expression that produces a string (like e.g., SUBSTRING_INDEX())
• normalize - option to return the distance as a float number in the range [0.0 - 1.0], where 0.0 is an exact match, and 1.0 is the maximum difference. The default value is 0, meaning not to normalize and provide the result as an integer.
• length_delta - skips Levenshtein distance calculation and returns max(strlen(pattern), strlen(source)) if the option is set and the lengths of the strings differ by more than the length_delta value. The default value is 0, meaning to calculate Levenshtein distance for any input strings. This option can be useful when checking mostly similar strings.

SELECT LEVENSHTEIN('gily', attr1) AS dist, WEIGHT() AS w FROM test WHERE MATCH('test') ORDER BY w DESC, dist ASC;
SELECT LEVENSHTEIN('gily', j.name, {length_delta=6}) AS dist, WEIGHT() AS w FROM test WHERE MATCH('test') ORDER BY w DESC;
SELECT LEVENSHTEIN(title, j.name, {normalize=1}) AS dist, WEIGHT() AS w FROM test WHERE MATCH ('test') ORDER BY w DESC, dist ASC;

The REGEX(attr,expr) function returns 1 if a regular expression matches the attribute's string, and 0 otherwise. It works with both string and JSON attributes.

SELECT REGEX(content, 'box?') FROM test;
SELECT REGEX(j.color, 'red | pink') FROM test;

Expressions should adhere to the RE2 syntax. To perform a case-insensitive search, for instance, you can use:

SELECT REGEX(content, '(?i)box') FROM test;

The SNIPPET() function can be used to highlight search results within a given text. The first two arguments are: the text to be highlighted, and a query. Options can be passed to the function as the third, fourth, and so on arguments. SNIPPET() can obtain the text for highlighting directly from the table. In this case, the first argument should be the field name:

SELECT SNIPPET(body, QUERY()) FROM myIndex WHERE MATCH('my.query')

In this example, the QUERY() expression returns the current full-text query. SNIPPET() can also highlight non-indexed text:

mysql  SELECT id, SNIPPET('text to highlight', 'my.query', 'limit=100') FROM myIndex WHERE MATCH('my.query')

Additionally, it can be used to highlight text fetched from other sources using a User-Defined Function (UDF):

SELECT id, SNIPPET(myUdf(id), 'my.query', 'limit=100') FROM myIndex WHERE MATCH('my.query')

In this context, myUdf() is a User-Defined Function (UDF) that retrieves a document by its ID from an external storage source. The SNIPPET() function is considered a "post limit" function, which means that the computation of snippets is delayed until the entire final result set is prepared, and even after the LIMIT clause has been applied. For instance, if a LIMIT 20,10 clause is used, SNIPPET() will be called no more than 10 times.

It is important to note that SNIPPET() does not support field-based limitations. For this functionality, use HIGHLIGHT() instead.

SELECT SUBSTRING_INDEX('www.w3schools.com', '.', 2) FROM test;
SELECT SUBSTRING_INDEX(j.coord, ' ', 1) FROM test;
SELECT          SUBSTRING_INDEX('1.2 3.4', ' ',  1);  /* '1.2' */
SELECT          SUBSTRING_INDEX('1.2 3.4', ' ', -1);  /* '3.4' */
SELECT sint (   SUBSTRING_INDEX('1.2 3.4', ' ',  1)); /* 1 */
SELECT sint (   SUBSTRING_INDEX('1.2 3.4', ' ', -1)); /* 3 */
SELECT double ( SUBSTRING_INDEX('1.2 3.4', ' ',  1)); /* 1.200000 */
SELECT double ( SUBSTRING_INDEX('1.2 3.4', ' ', -1)); /* 3.400000 */

UPPER(string) convert argument to upper case, LOWER(string) convert argument to lower case.

Result also can be promoted to numeric, but only if string argument is convertible to a number. Numeric values could be promoted with arbitrary functions (BITINT, DOUBLE, etc.).

SELECT upper('www.w3schools.com', '.', 2); /* WWW.W3SCHOOLS.COM  */
SELECT double (upper ('1.2e3')); /* 1200.000000 */
SELECT integer (lower ('12345')); /* 12345 */