mirror of
https://github.com/jackfoxy/urQL.git
synced 2024-12-16 12:11:58 +03:00
100 lines
2.9 KiB
Markdown
100 lines
2.9 KiB
Markdown
```
|
|
<query> ::=
|
|
[WITH <common-table-expression> ]
|
|
FROM { [<ship-qualifer>]<table-view> [ [AS] <alias> ]
|
|
[ { JOIN | LEFT JOIN | RIGHT JOIN | OUTER JOIN [ALL] }
|
|
<ship-qualifer><table-view> [ [AS] <alias> ]
|
|
ON <predicate>
|
|
]
|
|
} [ ,...n ]
|
|
[ WHERE <predicate> ]
|
|
SELECT [ TOP <n> ] [ DISTINCT ]
|
|
{ *
|
|
| {
|
|
{ [<ship-qualifer>]<table-view> | <alias> }. ] *
|
|
| <expression> [ [ AS ] column_alias ]
|
|
| column_alias = expression
|
|
} [ ,...n ]
|
|
}
|
|
[ GROUP BY { <column> | <column-ordinal> } [ ,...n ] ]
|
|
[ HAVING <predicate> ]
|
|
[ INTO <new-table> ]
|
|
[ ORDER BY { <column> | <column-ordinal> } [ ,...n ] ]
|
|
[ { UNION [ WITH DUPS ]
|
|
| EXCEPT
|
|
| INTERSECT
|
|
| DIVIDED BY [ WITH REMAINDER ]
|
|
| CROSS JOIN [ ( { { 1 | 2 }:{ * | 1..n } } ) ] } <query> ] [ ...n ]
|
|
```
|
|
|
|
```
|
|
<predicate> ::=
|
|
{ [ NOT ] <predicate> | ( <simple-predicate> ) }
|
|
[ { { AND | OR } [ NOT ] { <predicate> | ( <simple-predicate> ) }
|
|
[ ...n ]
|
|
]
|
|
```
|
|
|
|
```
|
|
<simple-predicate> ::=
|
|
{ expression <binary-operator> expression
|
|
| expression [ NOT ] BETWEEN expression AND expression
|
|
| expression IS [ NOT ] NULL
|
|
| expression IS [ NOT ] DISTINCT FROM expression
|
|
| expression [ NOT ] IN
|
|
( { <one-column-query> ) | expression [ ,...n ] } )
|
|
| expression <binary-operator> { ALL | ANY} ( <one-column-query> )
|
|
| EXISTS ( <query> ) }
|
|
```
|
|
|
|
```
|
|
<expression> ::=
|
|
{
|
|
constant
|
|
| <scalar-function>
|
|
| <column>
|
|
| [ <unary-operator> ] <expression>
|
|
| <expression> <binary-operator> <expression>
|
|
}
|
|
```
|
|
|
|
```
|
|
<binary-operator> ::=
|
|
{ = | <> | != | > | >= | !> | < | <= | !< }
|
|
```
|
|
|
|
```
|
|
`<column> ::=
|
|
{ [ { <alias>. | <table-view>. } ]<column-name>
|
|
| <constant>
|
|
| <column-alias> }
|
|
```
|
|
|
|
```
|
|
<scalar-function> ::=
|
|
IF <predicate> THEN <expression> ELSE <expression> ENDIF
|
|
| CASE <expression>`
|
|
WHEN { <predicate> | <expression> } THEN <expression> [ ...n ]
|
|
[ ELSE <expression> ]
|
|
END
|
|
| COALESCE ( <expression> [ ,...n ] )
|
|
| native hoon (stretch goal)
|
|
```
|
|
|
|
Discussion:
|
|
Not shown in diagrams, parentheses distinguish order of operations for binary conjunctions `AND` and `OR`.
|
|
|
|
Set operators apply the previous result set to the next query unless otherwise qualified by parentheses.
|
|
|
|
`ORDER BY` is not allowed in Common Table Experessions (CTE, WITH clause) or in any query joined by set operators except for the last of the queries.
|
|
|
|
`SELECT INTO` targets an existing table not otherwise in the query.
|
|
|
|
`COALESCE` returns the first `<expression>` in the list that does not evaluate to `~` (in the case of unit) or not in the selected `<expression>` due to `LEFT` or `RIGHT JOIN`.
|
|
|
|
If a `CASE WHEN` expression is a `<predicate>`, the expected boolean (or loobean) logic applies. If it is a <expression> atom value 0 is treated as false and any other value as true (not loobean).
|
|
|
|
Cross database joins are allowed, but not cross ship joins.
|
|
|
|
`DISTINCT FROM` is like equals, `=`, except comparing two nulls will yield false.
|