From 57da59fdc1edaf94f7907ae8550b41121cc5492d Mon Sep 17 00:00:00 2001 From: Christoph Dyllick-Brenzinger Date: Fri, 20 Mar 2026 15:24:20 +0100 Subject: [PATCH] Restructure SQL docs: add function coverage table, fix errors, consolidate pages MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Overview of changes: - Add function support overview table to functions.md with all tested functions and their MySQL equivalents (tested against SeaTable 6.1.8) - Fix substract() → subtract() typo in functions.md - Mark hours() and isoweeknum() as not supported in SQL queries - Document that constants (pi, e) only work inside function calls - Fix incorrect ORDER BY rule (column does NOT need to be in SELECT) Structural improvements: - Merge clauses.md into select.md (WHERE, GROUP BY, HAVING, ORDER BY) - Move list operators (HAS ANY OF, etc.) from extended-syntax.md to select.md - Move formulas-in-SQL notes and Big Data indexes to index.md - Add quick reference tables (supported/not supported) to index.md - Remove clauses.md and extended-syntax.md, add redirects - Update mkdocs.yml navigation New structure: SQL/ ├── index.md — Intro + Quick Reference + Formulas + Big Data ├── select.md — SELECT with all clauses, operators, JOINs ├── insert-update-delete.md (unchanged) ├── data-types.md (unchanged) └── functions.md — Coverage table + complete function reference Co-Authored-By: Claude Opus 4.6 (1M context) --- docs/sql/clauses.md | 56 --------------- docs/sql/extended-syntax.md | 41 ----------- docs/sql/functions.md | 139 +++++++++++++++++++++++++++++++++--- docs/sql/index.md | 50 +++++++++++++ docs/sql/select.md | 104 ++++++++++++++++++++++----- mkdocs.yml | 4 +- 6 files changed, 268 insertions(+), 126 deletions(-) delete mode 100644 docs/sql/clauses.md delete mode 100644 docs/sql/extended-syntax.md diff --git a/docs/sql/clauses.md b/docs/sql/clauses.md deleted file mode 100644 index 4df718bc..00000000 --- a/docs/sql/clauses.md +++ /dev/null @@ -1,56 +0,0 @@ -# Clauses - -!!! info "Backticks for special names" - Escape table or column names that contain spaces, special characters, or match [SQL function](./functions.md) names with backticks: `` SELECT * FROM `My Table` ``. - -## WHERE - -Most SQL syntax can be used in the `WHERE` clause: arithmetic expressions, comparison operators, `[NOT] LIKE`, `IN`, `BETWEEN ... AND ...`, `AND`, `OR`, `NOT`, `IS [NOT] TRUE`, `IS [NOT] NULL`. - -- Arithmetic expressions only support numbers -- Time constants must be strings in ISO format (e.g. `"2020-09-08 00:11:23"`). Since version 2.8, RFC 3339 format is also supported (e.g. `"2020-12-31T23:59:60Z"`) - -## GROUP BY - -`GROUP BY` uses strict syntax. Selected fields must appear in the GROUP BY list, except for aggregation functions (`COUNT`, `SUM`, `MAX`, `MIN`, `AVG`) and formulas. - -## HAVING - -`HAVING` filters rows resulting from `GROUP BY`. Only fields in the GROUP BY list or aggregation functions can be used. Other syntax is the same as WHERE. - -## ORDER BY - -Fields in the `ORDER BY` list must be a column or expression that appears in the selected fields. - -__Valid:__ -``` -SELECT a, b FROM table ORDER BY b -SELECT abs(a), b FROM table ORDER BY abs(a) -``` - -__Invalid:__ -``` -SELECT a FROM table ORDER BY b -``` - -## LIKE - -`LIKE` only supports strings. Use `ILIKE` for case-insensitive matching. The percent sign `%` represents zero, one, or multiple characters. - -__Example__ - -``` -SELECT `Full Name` FROM Contacts WHERE `Full Name` LIKE "% M%" -``` - -Returns every record with a last name starting with M. - -## BETWEEN - -`BETWEEN lowerLimit AND upperLimit` supports numbers and time. Both limits are included. They must be in the correct order. - -__Example__ - -``` -SELECT * FROM Contacts WHERE Age BETWEEN 18 AND 25 -``` diff --git a/docs/sql/extended-syntax.md b/docs/sql/extended-syntax.md deleted file mode 100644 index 78b7a058..00000000 --- a/docs/sql/extended-syntax.md +++ /dev/null @@ -1,41 +0,0 @@ -# Extended Syntax - -## Formulas in SQL queries - -You can use SeaTable formula syntax directly in SQL queries. A few differences from SeaTable's built-in formulas: - -- Link formulas (e.g. `{link.age}`) are **not** supported -- Column references are **not** enclosed in curly brackets: use `abs(column)`, not `abs({column})` -- Use backticks for column names with spaces or hyphens: `` abs(`column-a`) `` -- Column aliases cannot be used in formulas: `abs(t.column)` is invalid -- Formulas can be used in `GROUP BY` and `ORDER BY` clauses - -For the complete list of available functions, see the [function reference](./functions.md). - -## Extended list operators - -SeaTable supports special operators for list-type columns (multiple select, collaborator, etc.): - -| Operator | Description | -|---|---| -| `HAS ANY OF` | Row contains at least one of the values | -| `HAS ALL OF` | Row contains all of the values | -| `HAS NONE OF` | Row contains none of the values | -| `IS EXACTLY` | Row contains exactly these values (order-independent) | - -Values are enclosed in parentheses, like the `IN` operator. - -__Example__ - -``` -SELECT * FROM table WHERE city HAS ANY OF ("New York", "Paris") -``` - -## Big Data storage indexes - -SeaTable automatically creates indexes for rows in big data storage to improve query performance. Indexed column types: text, number, date, single select, multiple select, collaborators, creator, create date, modifier, modification date. - -Indexes are updated when: - -1. The table is archived the next time -2. A user triggers index management from the "Big data management" menu in the base diff --git a/docs/sql/functions.md b/docs/sql/functions.md index 28a28b55..b684d908 100644 --- a/docs/sql/functions.md +++ b/docs/sql/functions.md @@ -15,6 +15,124 @@ The functions supported in SQL are roughly the same as the set of functions supp - [Logical functions](#logical-functions) - [Statistical functions](#statistical-functions) +## Function support overview + +The following table shows at a glance which functions are supported in SeaTable SQL. Standard SQL/MySQL function names (e.g. `SUBSTR`, `CONCAT`) are **not** supported — use the SeaTable equivalents instead. + +??? note "Operators" + + | Function | Supported | Notes | + | :------- | :-------: | :---- | + | `add(num1, num2)` | :white_check_mark: | | + | `subtract(num1, num2)` | :white_check_mark: | | + | `multiply(num1, num2)` | :white_check_mark: | | + | `divide(num1, num2)` | :white_check_mark: | | + | `mod(num1, num2)` | :white_check_mark: | | + | `power(num1, num2)` | :white_check_mark: | | + | `greater(num1, num2)` | :white_check_mark: | | + | `lessthan(num1, num2)` | :white_check_mark: | | + | `greatereq(num1, num2)` | :white_check_mark: | | + | `lessthaneq(num1, num2)` | :white_check_mark: | | + | `equal(num1, num2)` | :white_check_mark: | | + | `unequal(num1, num2)` | :white_check_mark: | | + | Standard `+`, `-`, `*`, `/` | :white_check_mark: | Work in `SELECT` expressions | + +??? note "Mathematical functions" + + | Function | Supported | Notes | + | :------- | :-------: | :---- | + | `abs(number)` | :white_check_mark: | | + | `ceiling(number, significance)` | :white_check_mark: | MySQL `CEIL` is not supported | + | `even(number)` | :white_check_mark: | | + | `exp(number)` | :white_check_mark: | | + | `floor(number, significance)` | :white_check_mark: | | + | `int(number)` | :white_check_mark: | | + | `lg(number)` | :white_check_mark: | | + | `log(number, base)` | :white_check_mark: | | + | `odd(number)` | :white_check_mark: | | + | `round(number, digits)` | :white_check_mark: | | + | `rounddown(number, digits)` | :white_check_mark: | | + | `roundup(number, digits)` | :white_check_mark: | | + | `sign(number)` | :white_check_mark: | | + | `sqrt(number)` | :white_check_mark: | | + +??? note "Text functions" + + | Function | Supported | Notes | + | :------- | :-------: | :---- | + | `concatenate(str1, str2, ...)` | :white_check_mark: | MySQL `CONCAT` is not supported | + | `exact(str1, str2)` | :white_check_mark: | | + | `find(findStr, sourceStr, start)` | :white_check_mark: | MySQL `LOCATE`/`INSTR` are not supported | + | `left(string, count)` | :white_check_mark: | | + | `len(string)` | :white_check_mark: | MySQL `LENGTH`/`CHAR_LENGTH` are not supported | + | `lower(string)` | :white_check_mark: | MySQL `LCASE` is not supported | + | `mid(string, start, count)` | :white_check_mark: | MySQL `SUBSTR`/`SUBSTRING` are not supported | + | `replace(str, start, count, new)` | :white_check_mark: | Different signature than MySQL `REPLACE(str, from, to)` | + | `rept(string, number)` | :white_check_mark: | MySQL `REPEAT` is not supported | + | `right(string, count)` | :white_check_mark: | | + | `search(findStr, sourceStr, start)` | :white_check_mark: | Case-insensitive version of `find` | + | `substitute(str, old, new, index)` | :white_check_mark: | | + | `T(value)` | :white_check_mark: | | + | `text(number, format)` | :white_check_mark: | | + | `trim(string)` | :white_check_mark: | | + | `upper(string)` | :white_check_mark: | MySQL `UCASE` is not supported | + | `value(string)` | :white_check_mark: | | + +??? note "Date functions" + + | Function | Supported | Notes | + | :------- | :-------: | :---- | + | `date(year, month, day)` | :white_check_mark: | | + | `dateAdd(date, count, unit)` | :white_check_mark: | MySQL `DATE_ADD` with `INTERVAL` syntax is not supported | + | `dateDif(start, end, unit)` | :white_check_mark: | MySQL `DATEDIFF(d1, d2)` is not supported | + | `day(date)` | :white_check_mark: | | + | `eomonth(startDate, n)` | :white_check_mark: | | + | `hour(date)` | :white_check_mark: | | + | `hours(startDate, endDate)` | :x: | Not supported in SQL; use `dateDif` instead | + | `isodate(date)` | :white_check_mark: | | + | `isomonth(date)` | :white_check_mark: | | + | `isoweeknum(date)` | :x: | Not supported in SQL; use `weeknum(date, 21)` | + | `minute(date)` | :white_check_mark: | | + | `month(date)` | :white_check_mark: | | + | `months(startDate, endDate)` | :white_check_mark: | | + | `networkdays(start, end, ...)` | :white_check_mark: | | + | `now()` | :white_check_mark: | MySQL `CURDATE`/`CURRENT_DATE` are not supported | + | `quarter(date)` | :white_check_mark: | | + | `second(date)` | :white_check_mark: | | + | `startofweek(date, weekStart)` | :white_check_mark: | | + | `today()` | :white_check_mark: | | + | `weekday(date, weekStart)` | :white_check_mark: | | + | `weeknum(date, return_type)` | :white_check_mark: | Use `return_type` 21 for ISO week numbers | + | `year(date)` | :white_check_mark: | | + +??? note "Geo, logical, and statistical functions" + + | Function | Supported | Notes | + | :------- | :-------: | :---- | + | `country(geolocation)` | :white_check_mark: | Requires geolocation column | + | `if(logical, trueVal, falseVal)` | :white_check_mark: | MySQL `CASE WHEN` is not supported | + | `ifs(logical1, val1, ...)` | :white_check_mark: | | + | `and(logical1, logical2, ...)` | :white_check_mark: | | + | `or(logical1, logical2, ...)` | :white_check_mark: | | + | `not(boolean)` | :white_check_mark: | | + | `switch(logical, m1, v1, ...)` | :white_check_mark: | | + | `xor(logical1, logical2, ...)` | :white_check_mark: | | + | `average(num1, num2, ...)` | :white_check_mark: | | + | `counta(val1, val2, ...)` | :white_check_mark: | | + | `countall(val1, val2, ...)` | :white_check_mark: | | + | `countblank(val1, val2, ...)` | :white_check_mark: | | + | `countItems(column)` | :white_check_mark: | Requires multi-select, collaborator, file, or image column | + +??? note "Standard SQL aggregate functions" + + | Function | Supported | Notes | + | :------- | :-------: | :---- | + | `COUNT(*)` | :white_check_mark: | | + | `SUM(column)` | :white_check_mark: | | + | `MIN(column)` | :white_check_mark: | | + | `MAX(column)` | :white_check_mark: | | + | `AVG(column)` | :white_check_mark: | | + !!! info "Backticks for table or column names containing or special characters or using reserved words" For SQL queries, you can use numbers, special characters or spaces in the names of your tables and columns. However, you'll **have to** escape these names with backticks in order for your query to be correctly interpreted, for example `` select * from `My Table` ``. @@ -23,7 +141,7 @@ The functions supported in SQL are roughly the same as the set of functions supp ## Constants -You can use the following constants in the functions: +You can use the following constants as arguments inside functions (e.g., `multiply(pi, 2)`). Note: in SQL, constants cannot be used as standalone expressions in `SELECT` — `SELECT pi FROM table` will fail because `pi` is interpreted as a column name. | VARIABLE | DESCRIPTION | | :------- | :-------------------------------------- | @@ -47,14 +165,14 @@ Parameters must be strings or numbers. If a number is passed to a parameter that __Example__ `add(1,2)` returns `3` -!!! abstract "substract" +!!! abstract "subtract" Subtracts one numeric value (`num2`) from another (`num1`). ``` - substract(num1,num2) + subtract(num1,num2) ``` - __Example__ `substract(5,4)` returns `1` + __Example__ `subtract(5,4)` returns `1` !!! abstract "multiply" Multiplies two numeric values. @@ -571,18 +689,21 @@ When passing a parameter with time or date type, you can specify a constant in " !!! abstract "hours" Returns the number of hours between two date values (`startDate` and `endDate`). The minutes in the date values are not taken into account. - + ``` hours(startDate, endDate) ``` - + __Example__ `hours('2025-02-14 13:14', '2025-02-14 15:14')` returns `2` If no hours are included in the time specification (`startDate` or `endDate`), 0 o'clock on this day is automatically assumed. - - + + __Example__ `hours('2020-02-14', '2020-02-14 15:14')` returns `15` + !!! warning "Not supported in SQL" + `hours()` is only available in formulas, not in SQL queries. Use `dateDif(startDate, endDate, 'S')` and divide by 3600 as a workaround. + !!! abstract "minute" Returns the minutes of a time specification (`date`) as a number. The number returned is between 0 and 59. @@ -676,7 +797,7 @@ When passing a parameter with time or date type, you can specify a constant in " __Example__ `weekday('2025-01-01', 'Thursday') OR weekday('2025-01-01')` returns `4` !!! abstract "weeknum" - Returns the absolute week number of a `date` as a number. The returned number is between 1 and 53, where you can define the first day of the week (`return_type`). Enter the number 1 or 2, or 11 to 17, and 21 as `return_type` to define the start of a week: 1/Sunday, 2/Monday, 11/Monday, 12/Tuesday, 13/Wednesday, 14/Thursday, 15/Friday, 16/Saturday, 17/Sunday. If you want the week number to be returned according to ISO standard, specify the number of 21 as `return_type`, or use the function `isoweeknum`. + Returns the absolute week number of a `date` as a number. The returned number is between 1 and 53, where you can define the first day of the week (`return_type`). Enter the number 1 or 2, or 11 to 17, and 21 as `return_type` to define the start of a week: 1/Sunday, 2/Monday, 11/Monday, 12/Tuesday, 13/Wednesday, 14/Thursday, 15/Friday, 16/Saturday, 17/Sunday. If you want the week number to be returned according to ISO standard, specify the number of 21 as `return_type`. Note: the standalone function `isoweeknum` is only available in formulas, not in SQL queries — use `weeknum(date, 21)` instead. ``` weeknum(date, return_type) diff --git a/docs/sql/index.md b/docs/sql/index.md index be60774a..08283b15 100644 --- a/docs/sql/index.md +++ b/docs/sql/index.md @@ -19,3 +19,53 @@ SQL syntax is case insensitive. We use upper-cased keywords for readability. !!! tip "New to SQL?" Try the [SQL query plugin](https://seatable.com/help/anleitung-zum-sql-abfrage-plugin/) in SeaTable to experiment with queries interactively. + +## Quick reference + +### Supported + +| Feature | Notes | +|:---|:---| +| `SELECT`, `INSERT`, `UPDATE`, `DELETE` | [INSERT requires Big Data storage](insert-update-delete.md) | +| `WHERE` with `=`, `!=`, `<>`, `>`, `<`, `>=`, `<=` | | +| `LIKE`, `ILIKE`, `IN`, `NOT IN`, `BETWEEN`, `IS [NOT] NULL` | | +| `AND`, `OR`, `NOT` | | +| `GROUP BY`, `HAVING`, `ORDER BY`, `LIMIT`, `OFFSET` | | +| `DISTINCT`, `AS` aliases | | +| `COUNT`, `SUM`, `MIN`, `MAX`, `AVG` | Standard SQL aggregates | +| Implicit joins: `FROM T1, T2 WHERE T1.col = T2.col` | Inner join only | +| Arithmetic operators `+`, `-`, `*`, `/` in `SELECT` | | +| [SeaTable functions](functions.md) in `SELECT`, `WHERE`, `GROUP BY`, `HAVING`, `ORDER BY` | | +| [Extended list operators](select.md#extended-list-operators): `HAS ANY OF`, `HAS ALL OF`, etc. | For multi-select and collaborator columns | + +### Not supported + +| Feature | Alternative | +|:---|:---| +| `JOIN` keyword (`INNER JOIN`, `LEFT JOIN`, etc.) | Use implicit joins | +| Subqueries | Split into multiple queries | +| `UNION` / `UNION ALL` | Split into multiple queries | +| `CASE WHEN ... THEN ... END` | Use SeaTable `if()` or `ifs()` function | +| MySQL functions (`SUBSTR`, `CONCAT`, `LENGTH`, etc.) | Use [SeaTable equivalents](functions.md): `mid()`, `concatenate()`, `len()` | +| Functions or expressions in `UPDATE SET` | Read with `SELECT`, compute, write with API | +| Functions in `INSERT VALUES` | Use API `appendRow` instead | + +## Formulas in SQL queries + +You can use SeaTable formula syntax directly in SQL queries. A few differences from SeaTable's built-in formulas: + +- Link formulas (e.g. `{link.age}`) are **not** supported +- Column references are **not** enclosed in curly brackets: use `abs(column)`, not `abs({column})` +- Use backticks for column names with spaces or hyphens: `` abs(`column-a`) `` +- Column aliases cannot be used in formulas: `abs(t.column)` is invalid + +For the complete list of available functions, see the [function reference](./functions.md). + +## Big Data storage indexes + +SeaTable automatically creates indexes for rows in big data storage to improve query performance. Indexed column types: text, number, date, single select, multiple select, collaborators, creator, create date, modifier, modification date. + +Indexes are updated when: + +1. The table is archived the next time +2. A user triggers index management from the "Big data management" menu in the base diff --git a/docs/sql/select.md b/docs/sql/select.md index a57bad6e..9198e565 100644 --- a/docs/sql/select.md +++ b/docs/sql/select.md @@ -10,8 +10,6 @@ SELECT [Column List] FROM tableName [WHERE ...] [GROUP BY ...] [HAVING ...] [ORD `[Column List]` is a comma-separated list of columns. Use `*` to retrieve all columns. -See [Clauses](clauses.md) for details on WHERE, GROUP BY, HAVING, and ORDER BY. - ## Limits Unless you specify a higher limit, the method returns a maximum of **100 rows**. The absolute maximum is **10,000 rows**. @@ -34,34 +32,86 @@ Returns the next 10,000 rows. By default, returned rows use column **names** as keys (when using `base.query` in Python or JavaScript). The raw API returns column **keys**. This can be controlled with the `convert_keys` parameter. -## JOIN +## Field aliases -Since version 4.3, basic implicit join queries are supported: +Field aliases with `AS` are supported: ``` -SELECT ... FROM Table1, Table2 WHERE Table1.column1 = Table2.column2 AND ... +SELECT table.amount AS a, COUNT(*) FROM Invoices AS i GROUP BY a HAVING a > 100 ``` -Restrictions: +- Aliases **can** be used in `GROUP BY`, `HAVING`, and `ORDER BY` +- Aliases **cannot** be used in `WHERE` -- Do **not** use the `JOIN` keyword explicitly -- Only inner join is supported (no left, right, or full join) -- Tables in the `FROM` clause must be unique -- Each table must have at least one join condition -- Join conditions use equality only: `Table1.column1 = Table2.column2` -- Join conditions must be placed in the `WHERE` clause, connected with `AND` -- Columns in join conditions must be indexed (unless the table is not archived) +## WHERE -## Field aliases +!!! info "Backticks for special names" + Escape table or column names that contain spaces, special characters, or match [SQL function](./functions.md) names with backticks: `` SELECT * FROM `My Table` ``. -Field aliases with `AS` are supported: +Most SQL syntax can be used in the `WHERE` clause: arithmetic expressions, comparison operators, `[NOT] LIKE`, `IN`, `BETWEEN ... AND ...`, `AND`, `OR`, `NOT`, `IS [NOT] TRUE`, `IS [NOT] NULL`. + +- Arithmetic expressions only support numbers +- Time constants must be strings in ISO format (e.g. `"2020-09-08 00:11:23"`). Since version 2.8, RFC 3339 format is also supported (e.g. `"2020-12-31T23:59:60Z"`) + +### LIKE + +`LIKE` only supports strings. Use `ILIKE` for case-insensitive matching. The percent sign `%` represents zero, one, or multiple characters. + +__Example__ ``` -SELECT table.amount AS a, COUNT(*) FROM Invoices AS i GROUP BY a HAVING a > 100 +SELECT `Full Name` FROM Contacts WHERE `Full Name` LIKE "% M%" ``` -- Aliases **can** be used in `GROUP BY`, `HAVING`, and `ORDER BY` -- Aliases **cannot** be used in `WHERE` +Returns every record with a last name starting with M. + +### BETWEEN + +`BETWEEN lowerLimit AND upperLimit` supports numbers and time. Both limits are included. They must be in the correct order. + +__Example__ + +``` +SELECT * FROM Contacts WHERE Age BETWEEN 18 AND 25 +``` + +### Extended list operators + +SeaTable supports special operators for list-type columns (multiple select, collaborator, etc.): + +| Operator | Description | +|---|---| +| `HAS ANY OF` | Row contains at least one of the values | +| `HAS ALL OF` | Row contains all of the values | +| `HAS NONE OF` | Row contains none of the values | +| `IS EXACTLY` | Row contains exactly these values (order-independent) | + +Values are enclosed in parentheses, like the `IN` operator. + +__Example__ + +``` +SELECT * FROM table WHERE city HAS ANY OF ("New York", "Paris") +``` + +## GROUP BY + +`GROUP BY` uses strict syntax. Selected fields must appear in the GROUP BY list, except for aggregation functions (`COUNT`, `SUM`, `MAX`, `MIN`, `AVG`) and formulas. + +## HAVING + +`HAVING` filters rows resulting from `GROUP BY`. Only fields in the GROUP BY list or aggregation functions can be used. Other syntax is the same as WHERE. + +## ORDER BY + +Fields in the `ORDER BY` list can be columns, expressions, or functions. + +__Example__ + +``` +SELECT name, age FROM table ORDER BY age DESC +SELECT name, abs(score) FROM table ORDER BY abs(score) +``` ## Aggregation functions @@ -80,3 +130,21 @@ __Example__ ``` SELECT Customer, SUM(Amount) FROM Invoices GROUP BY Customer ``` + +## JOIN + +Since version 4.3, basic implicit join queries are supported: + +``` +SELECT ... FROM Table1, Table2 WHERE Table1.column1 = Table2.column2 AND ... +``` + +Restrictions: + +- Do **not** use the `JOIN` keyword explicitly +- Only inner join is supported (no left, right, or full join) +- Tables in the `FROM` clause must be unique +- Each table must have at least one join condition +- Join conditions use equality only: `Table1.column1 = Table2.column2` +- Join conditions must be placed in the `WHERE` clause, connected with `AND` +- Columns in join conditions must be indexed (unless the table is not archived) diff --git a/mkdocs.yml b/mkdocs.yml index f6befdcc..3586c123 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -103,6 +103,8 @@ plugins: 'scripts/javascript/examples/compute-attendance-statistics.md': 'javascript/index.md' 'scripts/sql/introduction.md': 'sql/index.md' 'scripts/sql/functions.md': 'sql/functions.md' + 'sql/clauses.md': 'sql/select.md' + 'sql/extended-syntax.md': 'sql/index.md' # Old "Client APIs" section → new language sections 'clients/index.md': 'index.md' @@ -218,9 +220,7 @@ nav: - sql/index.md - SELECT: sql/select.md - INSERT, UPDATE, DELETE: sql/insert-update-delete.md - - Clauses: sql/clauses.md - Data Types: sql/data-types.md - - Extended Syntax: sql/extended-syntax.md - Functions: sql/functions.md - Plugin Development: - plugins/index.md