mirror of https://github.com/AMT-Cheif/drift.git
Remove part files of parser
This commit is contained in:
Simon Binder
parent
4ad25b9cce
commit
1ff10f47c2
|
|
@ -48,7 +48,6 @@ class IndexedColumn extends AstNode {
|
|||
/// The expression on which the index should be created. Most commonly a
|
||||
/// [Reference], for simple column names.
|
||||
Expression expression;
|
||||
// nullable
|
||||
final OrderingMode? ordering;
|
||||
|
||||
IndexedColumn(this.expression, [this.ordering]);
|
||||
|
|
|
|||
|
|
@ -1,867 +0,0 @@
|
|||
part of 'parser.dart';
|
||||
|
||||
const _startJoinOperators = [
|
||||
TokenType.natural,
|
||||
TokenType.left,
|
||||
TokenType.inner,
|
||||
TokenType.cross,
|
||||
TokenType.join,
|
||||
TokenType.comma,
|
||||
];
|
||||
|
||||
mixin CrudParser on ParserBase {
|
||||
CrudStatement? _crud() {
|
||||
final withClause = _withClause();
|
||||
|
||||
if (_check(TokenType.select) || _check(TokenType.$values)) {
|
||||
return select(withClause: withClause);
|
||||
} else if (_check(TokenType.delete)) {
|
||||
return _deleteStmt(withClause);
|
||||
} else if (_check(TokenType.update)) {
|
||||
return _update(withClause);
|
||||
} else if (_check(TokenType.insert) || _check(TokenType.replace)) {
|
||||
return _insertStmt(withClause);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
WithClause? _withClause() {
|
||||
if (!_matchOne(TokenType.$with)) return null;
|
||||
final withToken = _previous;
|
||||
|
||||
final recursive = _matchOne(TokenType.recursive);
|
||||
final recursiveToken = recursive ? _previous : null;
|
||||
|
||||
final ctes = <CommonTableExpression>[];
|
||||
do {
|
||||
final name = _consumeIdentifier('Expected name for common table');
|
||||
List<String>? columnNames;
|
||||
|
||||
// can optionally declare the column names in (foo, bar, baz) syntax
|
||||
if (_matchOne(TokenType.leftParen)) {
|
||||
columnNames = [];
|
||||
do {
|
||||
final identifier = _consumeIdentifier('Expected column name');
|
||||
columnNames.add(identifier.identifier);
|
||||
} while (_matchOne(TokenType.comma));
|
||||
|
||||
_consume(TokenType.rightParen,
|
||||
'Expected closing bracket after column names');
|
||||
}
|
||||
|
||||
final asToken = _consume(TokenType.as, 'Expected AS');
|
||||
|
||||
const msg = 'Expected select statement in brackets';
|
||||
_consume(TokenType.leftParen, msg);
|
||||
final selectStmt = select() ?? _error(msg);
|
||||
_consume(TokenType.rightParen, msg);
|
||||
|
||||
ctes.add(CommonTableExpression(
|
||||
cteTableName: name.identifier,
|
||||
columnNames: columnNames,
|
||||
as: selectStmt,
|
||||
)
|
||||
..setSpan(name, _previous)
|
||||
..asToken = asToken
|
||||
..tableNameToken = name);
|
||||
} while (_matchOne(TokenType.comma));
|
||||
|
||||
return WithClause(
|
||||
recursive: recursive,
|
||||
ctes: ctes,
|
||||
)
|
||||
..setSpan(withToken, _previous)
|
||||
..recursiveToken = recursiveToken
|
||||
..withToken = withToken;
|
||||
}
|
||||
|
||||
@override
|
||||
BaseSelectStatement? _fullSelect() {
|
||||
final clause = _withClause();
|
||||
return select(withClause: clause);
|
||||
}
|
||||
|
||||
@override
|
||||
BaseSelectStatement? select({bool? noCompound, WithClause? withClause}) {
|
||||
if (noCompound == true) {
|
||||
return _selectNoCompound(withClause);
|
||||
} else {
|
||||
final firstTokenOfBase = _peek;
|
||||
final first = _selectNoCompound(withClause);
|
||||
|
||||
if (first == null) {
|
||||
// _selectNoCompound returns null if there's no select statement at the
|
||||
// current position. That's fine if we didn't encounter an with clause
|
||||
// already
|
||||
if (withClause != null) {
|
||||
_error('Expected a SELECT statement to follow the WITH clause here');
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
final parts = <CompoundSelectPart>[];
|
||||
|
||||
for (;;) {
|
||||
final part = _compoundSelectPart();
|
||||
if (part != null) {
|
||||
parts.add(part);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (parts.isEmpty) {
|
||||
// no compound parts, just return the simple select statement.
|
||||
return first;
|
||||
} else {
|
||||
// remove with clause from base select, it belongs to the compound
|
||||
// select.
|
||||
first.withClause = null;
|
||||
first.first = firstTokenOfBase;
|
||||
|
||||
return CompoundSelectStatement(
|
||||
withClause: withClause,
|
||||
base: first,
|
||||
additional: parts,
|
||||
)..setSpan(withClause?.first ?? first.first!, _previous);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SelectStatementNoCompound? _selectNoCompound([WithClause? withClause]) {
|
||||
if (_peek.type == TokenType.$values) return _valuesSelect(withClause);
|
||||
if (!_match(const [TokenType.select])) return null;
|
||||
final selectToken = _previous;
|
||||
|
||||
var distinct = false;
|
||||
if (_matchOne(TokenType.distinct)) {
|
||||
distinct = true;
|
||||
} else if (_matchOne(TokenType.all)) {
|
||||
distinct = false;
|
||||
}
|
||||
|
||||
final resultColumns = <ResultColumn>[];
|
||||
do {
|
||||
resultColumns.add(_resultColumn());
|
||||
} while (_match(const [TokenType.comma]));
|
||||
|
||||
final from = _from();
|
||||
|
||||
final where = _where();
|
||||
final groupBy = _groupBy();
|
||||
final windowDecls = _windowDeclarations();
|
||||
final orderBy = _orderBy();
|
||||
final limit = _limit();
|
||||
|
||||
final first = withClause?.first ?? selectToken;
|
||||
return SelectStatement(
|
||||
withClause: withClause,
|
||||
distinct: distinct,
|
||||
columns: resultColumns,
|
||||
from: from,
|
||||
where: where,
|
||||
groupBy: groupBy,
|
||||
windowDeclarations: windowDecls,
|
||||
orderBy: orderBy,
|
||||
limit: limit,
|
||||
)..setSpan(first, _previous);
|
||||
}
|
||||
|
||||
ValuesSelectStatement? _valuesSelect([WithClause? withClause]) {
|
||||
if (!_matchOne(TokenType.$values)) return null;
|
||||
final firstToken = _previous;
|
||||
|
||||
final tuples = <Tuple>[];
|
||||
do {
|
||||
tuples.add(_consumeTuple() as Tuple);
|
||||
} while (_matchOne(TokenType.comma));
|
||||
|
||||
return ValuesSelectStatement(tuples, withClause: withClause)
|
||||
..setSpan(firstToken, _previous);
|
||||
}
|
||||
|
||||
CompoundSelectPart? _compoundSelectPart() {
|
||||
if (_match(
|
||||
const [TokenType.union, TokenType.intersect, TokenType.except])) {
|
||||
final firstModeToken = _previous;
|
||||
var mode = const {
|
||||
TokenType.union: CompoundSelectMode.union,
|
||||
TokenType.intersect: CompoundSelectMode.intersect,
|
||||
TokenType.except: CompoundSelectMode.except,
|
||||
}[firstModeToken.type];
|
||||
Token? allToken;
|
||||
|
||||
if (firstModeToken.type == TokenType.union && _matchOne(TokenType.all)) {
|
||||
allToken = _previous;
|
||||
mode = CompoundSelectMode.unionAll;
|
||||
}
|
||||
|
||||
final select = _selectNoCompound()!;
|
||||
|
||||
return CompoundSelectPart(
|
||||
mode: mode!,
|
||||
select: select,
|
||||
)
|
||||
..firstModeToken = firstModeToken
|
||||
..allToken = allToken
|
||||
..setSpan(firstModeToken, _previous);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/// Parses a [ResultColumn] or throws if none is found.
|
||||
/// https://www.sqlite.org/syntax/result-column.html
|
||||
ResultColumn _resultColumn() {
|
||||
if (_matchOne(TokenType.star)) {
|
||||
return StarResultColumn(null)..setSpan(_previous, _previous);
|
||||
}
|
||||
|
||||
final positionBefore = _current;
|
||||
|
||||
if (_matchOne(TokenType.identifier)) {
|
||||
// two options. the identifier could be followed by ".*", in which case
|
||||
// we have a star result column. If it's followed by anything else, it can
|
||||
// still refer to a column in a table as part of a expression
|
||||
// result column
|
||||
final identifier = _previous as IdentifierToken;
|
||||
|
||||
if (_matchOne(TokenType.dot)) {
|
||||
if (_matchOne(TokenType.star)) {
|
||||
return StarResultColumn(identifier.identifier)
|
||||
..setSpan(identifier, _previous);
|
||||
} else if (enableMoorExtensions && _matchOne(TokenType.doubleStar)) {
|
||||
return NestedStarResultColumn(identifier.identifier)
|
||||
..setSpan(identifier, _previous);
|
||||
}
|
||||
}
|
||||
|
||||
// not a star result column. go back and parse the expression.
|
||||
// todo this is a bit unorthodox. is there a better way to parse the
|
||||
// expression from before?
|
||||
_current = positionBefore;
|
||||
}
|
||||
|
||||
final tokenBefore = _peek;
|
||||
|
||||
final expr = expression();
|
||||
final as = _as();
|
||||
|
||||
return ExpressionResultColumn(expression: expr, as: as?.identifier)
|
||||
..setSpan(tokenBefore, _previous);
|
||||
}
|
||||
|
||||
/// Returns an identifier followed after an optional "AS" token in sql.
|
||||
/// Returns null if there is
|
||||
IdentifierToken? _as() {
|
||||
if (_match(const [TokenType.as])) {
|
||||
return _consume(TokenType.identifier, 'Expected an identifier')
|
||||
as IdentifierToken;
|
||||
} else if (_match(const [TokenType.identifier])) {
|
||||
return _previous as IdentifierToken;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
Queryable? _from() {
|
||||
if (!_matchOne(TokenType.from)) return null;
|
||||
|
||||
// Can either be a list of <TableOrSubquery> or a join. Joins also start
|
||||
// with a TableOrSubquery, so let's first parse that.
|
||||
final start = _tableOrSubquery();
|
||||
// parse join, if there is one
|
||||
return _joinClause(start) ?? start;
|
||||
}
|
||||
|
||||
TableOrSubquery _tableOrSubquery() {
|
||||
// this is what we're parsing: https://www.sqlite.org/syntax/table-or-subquery.html
|
||||
// we currently only support regular tables, table functions and nested
|
||||
// selects
|
||||
final tableRef = _tableReferenceOrNull();
|
||||
if (tableRef != null) {
|
||||
// this is a bit hacky. If the table reference only consists of one
|
||||
// identifer and it's followed by a (, it's a table-valued function
|
||||
if (tableRef.as == null && _matchOne(TokenType.leftParen)) {
|
||||
final params = _functionParameters();
|
||||
_consume(TokenType.rightParen, 'Expected closing parenthesis');
|
||||
final alias = _as();
|
||||
|
||||
return TableValuedFunction(tableRef.tableName, params,
|
||||
as: alias?.identifier)
|
||||
..setSpan(tableRef.first!, _previous);
|
||||
}
|
||||
|
||||
return tableRef;
|
||||
} else if (_matchOne(TokenType.leftParen)) {
|
||||
final first = _previous;
|
||||
final innerStmt = select()!;
|
||||
_consume(TokenType.rightParen,
|
||||
'Expected a right bracket to terminate the inner select');
|
||||
|
||||
final alias = _as();
|
||||
return SelectStatementAsSource(
|
||||
statement: innerStmt, as: alias?.identifier)
|
||||
..setSpan(first, _previous);
|
||||
}
|
||||
|
||||
_error('Expected a table name or a nested select statement');
|
||||
}
|
||||
|
||||
TableReference? _tableReferenceOrNull() {
|
||||
_suggestHint(const TableNameDescription());
|
||||
if (_check(TokenType.identifier)) return _tableReference();
|
||||
return null;
|
||||
}
|
||||
|
||||
TableReference _tableReference() {
|
||||
_suggestHint(const TableNameDescription());
|
||||
// ignore the schema name, it's not supported. Besides that, we're on the
|
||||
// first branch in the diagram here https://www.sqlite.org/syntax/table-or-subquery.html
|
||||
final firstToken = _consumeIdentifier('Expected a table reference');
|
||||
|
||||
final tableName = firstToken.identifier;
|
||||
final alias = _as();
|
||||
return TableReference(tableName, alias?.identifier)
|
||||
..setSpan(firstToken, _previous)
|
||||
..tableNameToken = firstToken;
|
||||
}
|
||||
|
||||
JoinClause? _joinClause(TableOrSubquery start) {
|
||||
var operator = _parseJoinOperator();
|
||||
if (operator == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
final joins = <Join>[];
|
||||
|
||||
while (operator != null) {
|
||||
final first = _peekNext;
|
||||
|
||||
final subquery = _tableOrSubquery();
|
||||
final constraint = _joinConstraint();
|
||||
JoinOperator resolvedOperator;
|
||||
if (operator.contains(TokenType.left)) {
|
||||
resolvedOperator = operator.contains(TokenType.outer)
|
||||
? JoinOperator.leftOuter
|
||||
: JoinOperator.left;
|
||||
} else if (operator.contains(TokenType.inner)) {
|
||||
resolvedOperator = JoinOperator.inner;
|
||||
} else if (operator.contains(TokenType.cross)) {
|
||||
resolvedOperator = JoinOperator.cross;
|
||||
} else if (operator.contains(TokenType.comma)) {
|
||||
resolvedOperator = JoinOperator.comma;
|
||||
} else {
|
||||
resolvedOperator = JoinOperator.none;
|
||||
}
|
||||
|
||||
joins.add(Join(
|
||||
natural: operator.contains(TokenType.natural),
|
||||
operator: resolvedOperator,
|
||||
query: subquery,
|
||||
constraint: constraint,
|
||||
)..setSpan(first, _previous));
|
||||
|
||||
// parse the next operator, if there is more than one join
|
||||
operator = _parseJoinOperator();
|
||||
}
|
||||
|
||||
return JoinClause(primary: start, joins: joins)
|
||||
..setSpan(start.first!, _previous);
|
||||
}
|
||||
|
||||
/// Parses https://www.sqlite.org/syntax/join-operator.html
|
||||
List<TokenType>? _parseJoinOperator() {
|
||||
if (_match(_startJoinOperators)) {
|
||||
final operators = [_previous.type];
|
||||
|
||||
if (_previous.type == TokenType.join ||
|
||||
_previous.type == TokenType.comma) {
|
||||
// just join or comma, without any specific operators
|
||||
return operators;
|
||||
} else {
|
||||
// natural is a prefix, another operator can follow.
|
||||
if (_previous.type == TokenType.natural) {
|
||||
if (_match([TokenType.left, TokenType.inner, TokenType.cross])) {
|
||||
operators.add(_previous.type);
|
||||
}
|
||||
}
|
||||
if (_previous.type == TokenType.left && _matchOne(TokenType.outer)) {
|
||||
operators.add(_previous.type);
|
||||
}
|
||||
|
||||
_consume(TokenType.join, 'Expected to see a join keyword here');
|
||||
return operators;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/// Parses https://www.sqlite.org/syntax/join-constraint.html
|
||||
JoinConstraint? _joinConstraint() {
|
||||
if (_matchOne(TokenType.on)) {
|
||||
return OnConstraint(expression: expression());
|
||||
} else if (_matchOne(TokenType.using)) {
|
||||
_consume(TokenType.leftParen, 'Expected an opening paranthesis');
|
||||
|
||||
final columnNames = <String>[];
|
||||
do {
|
||||
final identifier =
|
||||
_consume(TokenType.identifier, 'Expected a column name');
|
||||
columnNames.add((identifier as IdentifierToken).identifier);
|
||||
} while (_matchOne(TokenType.comma));
|
||||
|
||||
_consume(TokenType.rightParen, 'Expected an closing paranthesis');
|
||||
|
||||
return UsingConstraint(columnNames: columnNames);
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/// Parses a where clause if there is one at the current position
|
||||
Expression? _where() {
|
||||
if (_match(const [TokenType.where])) {
|
||||
return expression();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
GroupBy? _groupBy() {
|
||||
if (_matchOne(TokenType.group)) {
|
||||
final groupToken = _previous;
|
||||
|
||||
_consume(TokenType.by, 'Expected a "BY"');
|
||||
final by = <Expression>[];
|
||||
Expression? having;
|
||||
|
||||
do {
|
||||
by.add(expression());
|
||||
} while (_matchOne(TokenType.comma));
|
||||
|
||||
if (_matchOne(TokenType.having)) {
|
||||
having = expression();
|
||||
}
|
||||
|
||||
return GroupBy(by: by, having: having)..setSpan(groupToken, _previous);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
List<NamedWindowDeclaration> _windowDeclarations() {
|
||||
final declarations = <NamedWindowDeclaration>[];
|
||||
if (_matchOne(TokenType.window)) {
|
||||
do {
|
||||
final name = _consumeIdentifier('Expected a name for the window');
|
||||
_consume(TokenType.as,
|
||||
'Expected AS between the window name and its definition');
|
||||
final window = _windowDefinition();
|
||||
|
||||
declarations.add(NamedWindowDeclaration(name.identifier, window));
|
||||
} while (_matchOne(TokenType.comma));
|
||||
}
|
||||
return declarations;
|
||||
}
|
||||
|
||||
OrderByBase? _orderBy() {
|
||||
if (_matchOne(TokenType.order)) {
|
||||
final orderToken = _previous;
|
||||
_consume(TokenType.by, 'Expected "BY" after "ORDER" token');
|
||||
final terms = <OrderingTermBase>[];
|
||||
do {
|
||||
terms.add(_orderingTerm());
|
||||
} while (_matchOne(TokenType.comma));
|
||||
|
||||
// If we only hit a single ordering term and that term is a Dart
|
||||
// placeholder, we can upgrade that term to a full order by placeholder.
|
||||
// This gives users more control at runtime (they can specify multiple
|
||||
// terms).
|
||||
if (terms.length == 1 && terms.single is DartOrderingTermPlaceholder) {
|
||||
final termPlaceholder = terms.single as DartOrderingTermPlaceholder;
|
||||
return DartOrderByPlaceholder(name: termPlaceholder.name)
|
||||
..setSpan(orderToken, termPlaceholder.last!);
|
||||
}
|
||||
|
||||
return OrderBy(terms: terms)..setSpan(orderToken, _previous);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
OrderingTermBase _orderingTerm() {
|
||||
final expr = expression();
|
||||
final mode = _orderingModeOrNull();
|
||||
|
||||
OrderingBehaviorForNulls? nulls;
|
||||
|
||||
if (_matchOne(TokenType.nulls)) {
|
||||
if (_matchOne(TokenType.first)) {
|
||||
nulls = OrderingBehaviorForNulls.first;
|
||||
} else if (_matchOne(TokenType.last)) {
|
||||
nulls = OrderingBehaviorForNulls.last;
|
||||
} else {
|
||||
_error('Expected FIRST or LAST here');
|
||||
}
|
||||
}
|
||||
|
||||
// if there is nothing (asc/desc, nulls first/last) after a Dart
|
||||
// placeholder, we can upgrade the expression to an ordering term
|
||||
// placeholder and let users define the mode at runtime.
|
||||
if (mode == null && nulls == null && expr is DartExpressionPlaceholder) {
|
||||
return DartOrderingTermPlaceholder(name: expr.name)
|
||||
..setSpan(expr.first!, expr.last!);
|
||||
}
|
||||
|
||||
return OrderingTerm(expression: expr, orderingMode: mode, nulls: nulls)
|
||||
..setSpan(expr.first!, _previous);
|
||||
}
|
||||
|
||||
@override
|
||||
OrderingMode? _orderingModeOrNull() {
|
||||
if (_match(const [TokenType.asc, TokenType.desc])) {
|
||||
final mode = _previous.type == TokenType.asc
|
||||
? OrderingMode.ascending
|
||||
: OrderingMode.descending;
|
||||
return mode;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/// Parses a [Limit] clause, or returns null if there is no limit token after
|
||||
/// the current position.
|
||||
LimitBase? _limit() {
|
||||
if (!_matchOne(TokenType.limit)) return null;
|
||||
|
||||
final limitToken = _previous;
|
||||
|
||||
// Unintuitive, it's "$amount OFFSET $offset", but "$offset, $amount"
|
||||
// the order changes between the separator tokens.
|
||||
final first = expression();
|
||||
|
||||
if (_matchOne(TokenType.comma)) {
|
||||
final separator = _previous;
|
||||
final count = expression();
|
||||
return Limit(count: count, offsetSeparator: separator, offset: first)
|
||||
..setSpan(limitToken, _previous);
|
||||
} else if (_matchOne(TokenType.offset)) {
|
||||
final separator = _previous;
|
||||
final offset = expression();
|
||||
return Limit(count: first, offsetSeparator: separator, offset: offset)
|
||||
..setSpan(limitToken, _previous);
|
||||
} else {
|
||||
// no offset or comma was parsed (so just LIMIT $expr). In that case, we
|
||||
// want to provide additional flexibility to the user by interpreting the
|
||||
// expression as a whole limit clause.
|
||||
if (first is DartExpressionPlaceholder) {
|
||||
return DartLimitPlaceholder(name: first.name)
|
||||
..setSpan(limitToken, _previous);
|
||||
}
|
||||
return Limit(count: first)..setSpan(limitToken, _previous);
|
||||
}
|
||||
}
|
||||
|
||||
DeleteStatement? _deleteStmt([WithClause? withClause]) {
|
||||
if (!_matchOne(TokenType.delete)) return null;
|
||||
final deleteToken = _previous;
|
||||
|
||||
_consume(TokenType.from, 'Expected a FROM here');
|
||||
|
||||
final table = _tableReference();
|
||||
Expression? where;
|
||||
|
||||
if (_matchOne(TokenType.where)) {
|
||||
where = expression();
|
||||
}
|
||||
|
||||
return DeleteStatement(
|
||||
withClause: withClause,
|
||||
from: table,
|
||||
where: where,
|
||||
)..setSpan(withClause?.first ?? deleteToken, _previous);
|
||||
}
|
||||
|
||||
UpdateStatement? _update([WithClause? withClause]) {
|
||||
if (!_matchOne(TokenType.update)) return null;
|
||||
final updateToken = _previous;
|
||||
|
||||
FailureMode? failureMode;
|
||||
if (_matchOne(TokenType.or)) {
|
||||
failureMode = UpdateStatement.failureModeFromToken(_advance().type);
|
||||
}
|
||||
|
||||
final table = _tableReference();
|
||||
_consume(TokenType.set, 'Expected SET after the table name');
|
||||
|
||||
final set = _setComponents();
|
||||
|
||||
final where = _where();
|
||||
return UpdateStatement(
|
||||
withClause: withClause,
|
||||
or: failureMode,
|
||||
table: table,
|
||||
set: set,
|
||||
where: where,
|
||||
)..setSpan(withClause?.first ?? updateToken, _previous);
|
||||
}
|
||||
|
||||
List<SetComponent> _setComponents() {
|
||||
final set = <SetComponent>[];
|
||||
do {
|
||||
final columnName =
|
||||
_consume(TokenType.identifier, 'Expected a column name to set')
|
||||
as IdentifierToken;
|
||||
final reference = Reference(columnName: columnName.identifier)
|
||||
..setSpan(columnName, columnName);
|
||||
_consume(TokenType.equal, 'Expected = after the column name');
|
||||
final expr = expression();
|
||||
|
||||
set.add(SetComponent(column: reference, expression: expr)
|
||||
..setSpan(columnName, _previous));
|
||||
} while (_matchOne(TokenType.comma));
|
||||
|
||||
return set;
|
||||
}
|
||||
|
||||
InsertStatement? _insertStmt([WithClause? withClause]) {
|
||||
if (!_match(const [TokenType.insert, TokenType.replace])) return null;
|
||||
|
||||
final firstToken = _previous;
|
||||
InsertMode? insertMode;
|
||||
if (_previous.type == TokenType.insert) {
|
||||
// insert modes can have a failure clause (INSERT OR xxx)
|
||||
if (_matchOne(TokenType.or)) {
|
||||
const tokensToModes = {
|
||||
TokenType.replace: InsertMode.insertOrReplace,
|
||||
TokenType.rollback: InsertMode.insertOrRollback,
|
||||
TokenType.abort: InsertMode.insertOrAbort,
|
||||
TokenType.fail: InsertMode.insertOrFail,
|
||||
TokenType.ignore: InsertMode.insertOrIgnore
|
||||
};
|
||||
|
||||
if (_match(tokensToModes.keys)) {
|
||||
insertMode = tokensToModes[_previous.type];
|
||||
} else {
|
||||
_error('After the INSERT OR, expected an insert mode '
|
||||
'(REPLACE, ROLLBACK, etc.)');
|
||||
}
|
||||
} else {
|
||||
insertMode = InsertMode.insert;
|
||||
}
|
||||
} else {
|
||||
// if it wasn't an insert, it must have been a replace
|
||||
insertMode = InsertMode.replace;
|
||||
}
|
||||
assert(insertMode != null);
|
||||
_consume(TokenType.into, 'Expected INSERT INTO');
|
||||
|
||||
final table = _tableReference();
|
||||
final targetColumns = <Reference>[];
|
||||
|
||||
if (_matchOne(TokenType.leftParen)) {
|
||||
do {
|
||||
final columnRef = _consumeIdentifier('Expected a column');
|
||||
targetColumns.add(Reference(columnName: columnRef.identifier)
|
||||
..setSpan(columnRef, columnRef));
|
||||
} while (_matchOne(TokenType.comma));
|
||||
|
||||
_consume(TokenType.rightParen,
|
||||
'Expected clpsing parenthesis after column list');
|
||||
}
|
||||
final source = _insertSource();
|
||||
final upsert = _upsertClauseOrNull();
|
||||
|
||||
return InsertStatement(
|
||||
withClause: withClause,
|
||||
mode: insertMode!,
|
||||
table: table,
|
||||
targetColumns: targetColumns,
|
||||
source: source,
|
||||
upsert: upsert,
|
||||
)..setSpan(withClause?.first ?? firstToken, _previous);
|
||||
}
|
||||
|
||||
InsertSource _insertSource() {
|
||||
if (_matchOne(TokenType.$values)) {
|
||||
final first = _previous;
|
||||
final values = <Tuple>[];
|
||||
do {
|
||||
// it will be a tuple, we don't turn on "orSubQuery"
|
||||
values.add(_consumeTuple() as Tuple);
|
||||
} while (_matchOne(TokenType.comma));
|
||||
|
||||
return ValuesSource(values)..setSpan(first, _previous);
|
||||
} else if (_matchOne(TokenType.$default)) {
|
||||
final first = _previous;
|
||||
_consume(TokenType.$values, 'Expected DEFAULT VALUES');
|
||||
return DefaultValues()..setSpan(first, _previous);
|
||||
} else {
|
||||
final first = _previous;
|
||||
return SelectInsertSource(
|
||||
_fullSelect() ?? _error('Expeced a select statement'),
|
||||
)..setSpan(first, _previous);
|
||||
}
|
||||
}
|
||||
|
||||
UpsertClause? _upsertClauseOrNull() {
|
||||
if (!_matchOne(TokenType.on)) return null;
|
||||
|
||||
final first = _previous;
|
||||
_consume(TokenType.conflict, 'Expected CONFLICT keyword for upsert clause');
|
||||
|
||||
List<IndexedColumn>? indexedColumns;
|
||||
Expression? where;
|
||||
if (_matchOne(TokenType.leftParen)) {
|
||||
indexedColumns = _indexedColumns();
|
||||
|
||||
_consume(TokenType.rightParen, 'Expected closing paren here');
|
||||
if (_matchOne(TokenType.where)) {
|
||||
where = expression();
|
||||
}
|
||||
}
|
||||
|
||||
_consume(TokenType.$do,
|
||||
'Expected DO, followed by the action (NOTHING or UPDATE SET)');
|
||||
|
||||
late UpsertAction action;
|
||||
if (_matchOne(TokenType.nothing)) {
|
||||
action = DoNothing()..setSpan(_previous, _previous);
|
||||
} else if (_check(TokenType.update)) {
|
||||
action = _doUpdate();
|
||||
}
|
||||
|
||||
return UpsertClause(
|
||||
onColumns: indexedColumns,
|
||||
where: where,
|
||||
action: action,
|
||||
)..setSpan(first, _previous);
|
||||
}
|
||||
|
||||
DoUpdate _doUpdate() {
|
||||
_consume(TokenType.update, 'Expected UPDATE SET keyword here');
|
||||
final first = _previous;
|
||||
_consume(TokenType.set, 'Expected UPDATE SET keyword here');
|
||||
|
||||
final set = _setComponents();
|
||||
Expression? where;
|
||||
if (_matchOne(TokenType.where)) {
|
||||
where = expression();
|
||||
}
|
||||
|
||||
return DoUpdate(set, where: where)..setSpan(first, _previous);
|
||||
}
|
||||
|
||||
@override
|
||||
WindowDefinition _windowDefinition() {
|
||||
_consume(TokenType.leftParen, 'Expected opening parenthesis');
|
||||
final leftParen = _previous;
|
||||
|
||||
String? baseWindowName;
|
||||
OrderByBase? orderBy;
|
||||
|
||||
final partitionBy = <Expression>[];
|
||||
if (_matchOne(TokenType.identifier)) {
|
||||
baseWindowName = (_previous as IdentifierToken).identifier;
|
||||
}
|
||||
|
||||
if (_matchOne(TokenType.partition)) {
|
||||
_consume(TokenType.by, 'Expected PARTITION BY');
|
||||
do {
|
||||
partitionBy.add(expression());
|
||||
} while (_matchOne(TokenType.comma));
|
||||
}
|
||||
|
||||
if (_peek.type == TokenType.order) {
|
||||
orderBy = _orderBy();
|
||||
}
|
||||
|
||||
final spec = _frameSpec();
|
||||
|
||||
_consume(TokenType.rightParen, 'Expected closing parenthesis');
|
||||
return WindowDefinition(
|
||||
baseWindowName: baseWindowName,
|
||||
partitionBy: partitionBy,
|
||||
orderBy: orderBy,
|
||||
frameSpec: spec ?? (FrameSpec()..synthetic = true),
|
||||
)..setSpan(leftParen, _previous);
|
||||
}
|
||||
|
||||
/// https://www.sqlite.org/syntax/frame-spec.html
|
||||
FrameSpec? _frameSpec() {
|
||||
if (!_match(const [TokenType.range, TokenType.rows, TokenType.groups])) {
|
||||
return null;
|
||||
}
|
||||
|
||||
final typeToken = _previous;
|
||||
|
||||
final frameType = const {
|
||||
TokenType.range: FrameType.range,
|
||||
TokenType.rows: FrameType.rows,
|
||||
TokenType.groups: FrameType.groups
|
||||
}[typeToken.type];
|
||||
|
||||
FrameBoundary start, end;
|
||||
|
||||
// if there is no between token, we just read the start boundary and set the
|
||||
// end to currentRow. See the link in the docs
|
||||
if (_matchOne(TokenType.between)) {
|
||||
start = _frameBoundary(isStartBounds: true, parseExprFollowing: true);
|
||||
_consume(TokenType.and, 'Expected AND followed by the ending boundary');
|
||||
end = _frameBoundary(isStartBounds: false, parseExprFollowing: true);
|
||||
} else {
|
||||
// <expr> FOLLOWING is not supported in the short-hand syntax
|
||||
start = _frameBoundary(isStartBounds: true, parseExprFollowing: false);
|
||||
end = FrameBoundary.currentRow();
|
||||
}
|
||||
|
||||
var exclude = ExcludeMode.noOthers;
|
||||
if (_matchOne(TokenType.exclude)) {
|
||||
if (_matchOne(TokenType.ties)) {
|
||||
exclude = ExcludeMode.ties;
|
||||
} else if (_matchOne(TokenType.group)) {
|
||||
exclude = ExcludeMode.group;
|
||||
} else if (_matchOne(TokenType.current)) {
|
||||
_consume(TokenType.row, 'Expected EXCLUDE CURRENT ROW');
|
||||
exclude = ExcludeMode.currentRow;
|
||||
} else if (_matchOne(TokenType.no)) {
|
||||
_consume(TokenType.others, 'Expected EXCLUDE NO OTHERS');
|
||||
exclude = ExcludeMode.noOthers;
|
||||
}
|
||||
}
|
||||
|
||||
return FrameSpec(
|
||||
type: frameType,
|
||||
excludeMode: exclude,
|
||||
start: start,
|
||||
end: end,
|
||||
)..setSpan(typeToken, _previous);
|
||||
}
|
||||
|
||||
FrameBoundary _frameBoundary(
|
||||
{bool isStartBounds = true, bool parseExprFollowing = true}) {
|
||||
// the CURRENT ROW boundary is supported for all modes
|
||||
if (_matchOne(TokenType.current)) {
|
||||
_consume(TokenType.row, 'Expected ROW to finish CURRENT ROW boundary');
|
||||
return FrameBoundary.currentRow();
|
||||
}
|
||||
if (_matchOne(TokenType.unbounded)) {
|
||||
// if this is a start boundary, only UNBOUNDED PRECEDING makes sense.
|
||||
// Otherwise, only UNBOUNDED FOLLOWING makes sense
|
||||
if (isStartBounds) {
|
||||
_consume(TokenType.preceding, 'Expected UNBOUNDED PRECEDING');
|
||||
return FrameBoundary.unboundedPreceding();
|
||||
} else {
|
||||
_consume(TokenType.following, 'Expected UNBOUNDED FOLLOWING');
|
||||
return FrameBoundary.unboundedFollowing();
|
||||
}
|
||||
}
|
||||
|
||||
// ok, not unbounded or CURRENT ROW. It must be <expr> PRECEDING|FOLLOWING
|
||||
// then
|
||||
final amount = expression();
|
||||
if (parseExprFollowing && _matchOne(TokenType.following)) {
|
||||
return FrameBoundary.following(amount);
|
||||
} else if (_matchOne(TokenType.preceding)) {
|
||||
return FrameBoundary.preceding(amount);
|
||||
}
|
||||
|
||||
_error('Expected either PRECEDING or FOLLOWING here');
|
||||
}
|
||||
}
|
||||
|
|
@ -1,477 +0,0 @@
|
|||
part of 'parser.dart';
|
||||
|
||||
/// Parses expressions. Expressions have the following precedence, in descending
|
||||
/// order
|
||||
/// - primary expressions: Parenthesis, etc.
|
||||
/// - Case expressions
|
||||
/// - postfix expressions: NOT NULL, etc.
|
||||
/// - `-`, `+`, `~`, unary not
|
||||
/// - `||` (concatenation)
|
||||
/// - `*`, '/', '%'
|
||||
/// - `+`, `-`
|
||||
/// - `<<`, `>>`, `&`, `|`
|
||||
/// - `<`, `<=`, `>`, `>=`
|
||||
/// - `=`, `==`, `!=`, `<>`, `IS`, `IS NOT`, `IN`, `LIKE`, `GLOB`, `MATCH`,
|
||||
/// `REGEXP`
|
||||
/// - `AND`
|
||||
/// - `OR`
|
||||
mixin ExpressionParser on ParserBase {
|
||||
@override
|
||||
Expression expression() {
|
||||
return _or();
|
||||
}
|
||||
|
||||
/// Parses an expression of the form a <T> b, where <T> is in [types] and
|
||||
/// both a and b are expressions with a higher precedence parsed from
|
||||
/// [higherPrecedence].
|
||||
Expression _parseSimpleBinary(
|
||||
List<TokenType> types, Expression Function() higherPrecedence) {
|
||||
var expression = higherPrecedence();
|
||||
|
||||
while (_match(types)) {
|
||||
final operator = _previous;
|
||||
final right = higherPrecedence();
|
||||
expression = BinaryExpression(expression, operator, right)
|
||||
..setSpan(expression.first!, _previous);
|
||||
}
|
||||
return expression;
|
||||
}
|
||||
|
||||
Expression _or() => _parseSimpleBinary(const [TokenType.or], _and);
|
||||
Expression _and() => _parseSimpleBinary(const [TokenType.and], _in);
|
||||
|
||||
Expression _in() {
|
||||
final left = _equals();
|
||||
|
||||
if (_checkWithNot(TokenType.$in)) {
|
||||
final not = _matchOne(TokenType.not);
|
||||
_matchOne(TokenType.$in);
|
||||
|
||||
final inside = _variableOrNull() ?? _consumeTuple(orSubQuery: true);
|
||||
return InExpression(left: left, inside: inside, not: not)
|
||||
..setSpan(left.first!, _previous);
|
||||
}
|
||||
|
||||
return left;
|
||||
}
|
||||
|
||||
/// Parses expressions with the "equals" precedence. This contains
|
||||
/// comparisons, "IS (NOT) IN" expressions, between expressions and "like"
|
||||
/// expressions.
|
||||
Expression _equals() {
|
||||
var expression = _comparison();
|
||||
final first = expression.first;
|
||||
|
||||
const ops = [
|
||||
TokenType.equal,
|
||||
TokenType.doubleEqual,
|
||||
TokenType.exclamationEqual,
|
||||
TokenType.lessMore,
|
||||
TokenType.$is,
|
||||
];
|
||||
const stringOps = [
|
||||
TokenType.like,
|
||||
TokenType.glob,
|
||||
TokenType.match,
|
||||
TokenType.regexp,
|
||||
];
|
||||
|
||||
for (;;) {
|
||||
if (_checkWithNot(TokenType.between)) {
|
||||
final not = _matchOne(TokenType.not);
|
||||
_consume(TokenType.between, 'expected a BETWEEN');
|
||||
|
||||
final lower = _comparison();
|
||||
_consume(TokenType.and, 'expected AND');
|
||||
final upper = _comparison();
|
||||
|
||||
expression = BetweenExpression(
|
||||
not: not, check: expression, lower: lower, upper: upper)
|
||||
..setSpan(first!, _previous);
|
||||
} else if (_match(ops)) {
|
||||
final operator = _previous;
|
||||
if (operator.type == TokenType.$is) {
|
||||
final not = _match(const [TokenType.not]);
|
||||
// special case: is not expression
|
||||
expression = IsExpression(not, expression, _comparison())
|
||||
..setSpan(first!, _previous);
|
||||
} else {
|
||||
expression = BinaryExpression(expression, operator, _comparison())
|
||||
..setSpan(first!, _previous);
|
||||
}
|
||||
} else if (_checkAnyWithNot(stringOps)) {
|
||||
final not = _matchOne(TokenType.not);
|
||||
_match(stringOps); // will consume, existence was verified with check
|
||||
final operator = _previous;
|
||||
|
||||
final right = _comparison();
|
||||
Expression? escape;
|
||||
if (_matchOne(TokenType.escape)) {
|
||||
escape = _comparison();
|
||||
}
|
||||
|
||||
expression = StringComparisonExpression(
|
||||
not: not,
|
||||
left: expression,
|
||||
operator: operator,
|
||||
right: right,
|
||||
escape: escape)
|
||||
..setSpan(first!, _previous);
|
||||
} else {
|
||||
break; // no matching operator with this precedence was found
|
||||
}
|
||||
}
|
||||
|
||||
return expression;
|
||||
}
|
||||
|
||||
Expression _comparison() {
|
||||
return _parseSimpleBinary(_comparisonOperators, _binaryOperation);
|
||||
}
|
||||
|
||||
Expression _binaryOperation() {
|
||||
return _parseSimpleBinary(_binaryOperators, _addition);
|
||||
}
|
||||
|
||||
Expression _addition() {
|
||||
return _parseSimpleBinary(const [
|
||||
TokenType.plus,
|
||||
TokenType.minus,
|
||||
], _multiplication);
|
||||
}
|
||||
|
||||
Expression _multiplication() {
|
||||
return _parseSimpleBinary(const [
|
||||
TokenType.star,
|
||||
TokenType.slash,
|
||||
TokenType.percent,
|
||||
], _concatenation);
|
||||
}
|
||||
|
||||
Expression _concatenation() {
|
||||
return _parseSimpleBinary(const [TokenType.doublePipe], _unary);
|
||||
}
|
||||
|
||||
Expression _unary() {
|
||||
if (_match(const [
|
||||
TokenType.minus,
|
||||
TokenType.plus,
|
||||
TokenType.tilde,
|
||||
TokenType.not,
|
||||
])) {
|
||||
final operator = _previous;
|
||||
final expression = _unary();
|
||||
return UnaryExpression(operator, expression)
|
||||
..setSpan(operator, expression.last!);
|
||||
} else if (_matchOne(TokenType.exists)) {
|
||||
final existsToken = _previous;
|
||||
_consume(
|
||||
TokenType.leftParen, 'Expected opening parenthesis after EXISTS');
|
||||
final selectStmt = _fullSelect() ?? _error('Expected a select statement');
|
||||
_consume(TokenType.rightParen,
|
||||
'Expected closing paranthesis to finish EXISTS expression');
|
||||
return ExistsExpression(select: selectStmt)
|
||||
..setSpan(existsToken, _previous);
|
||||
}
|
||||
|
||||
return _postfix();
|
||||
}
|
||||
|
||||
Expression _postfix() {
|
||||
var expression = _case();
|
||||
|
||||
// todo we don't currently parse "NOT NULL" (2 tokens) because of ambiguity
|
||||
// with NOT BETWEEN / NOT IN / ... expressions
|
||||
const matchedTokens = [
|
||||
TokenType.collate,
|
||||
TokenType.notNull,
|
||||
TokenType.isNull
|
||||
];
|
||||
|
||||
while (_match(matchedTokens)) {
|
||||
final operator = _previous;
|
||||
switch (operator.type) {
|
||||
case TokenType.collate:
|
||||
final collateOp = _previous;
|
||||
final collateFun =
|
||||
_consume(TokenType.identifier, 'Expected a collating sequence')
|
||||
as IdentifierToken;
|
||||
expression = CollateExpression(
|
||||
inner: expression,
|
||||
operator: collateOp,
|
||||
collateFunction: collateFun,
|
||||
);
|
||||
break;
|
||||
case TokenType.isNull:
|
||||
expression = IsNullExpression(expression);
|
||||
break;
|
||||
case TokenType.notNull:
|
||||
expression = IsNullExpression(expression, true);
|
||||
break;
|
||||
default:
|
||||
// we checked with _match, this may never happen
|
||||
throw AssertionError();
|
||||
}
|
||||
expression.setSpan(operator, _previous);
|
||||
}
|
||||
|
||||
return expression;
|
||||
}
|
||||
|
||||
Expression _case() {
|
||||
if (_matchOne(TokenType.$case)) {
|
||||
final caseToken = _previous;
|
||||
|
||||
final base = _check(TokenType.when) ? null : _primary();
|
||||
final whens = <WhenComponent>[];
|
||||
Expression? $else;
|
||||
|
||||
while (_matchOne(TokenType.when)) {
|
||||
final whenToken = _previous;
|
||||
|
||||
final whenExpr = _or();
|
||||
_consume(TokenType.then, 'Expected THEN');
|
||||
final then = expression();
|
||||
whens.add(WhenComponent(when: whenExpr, then: then)
|
||||
..setSpan(whenToken, _previous));
|
||||
}
|
||||
|
||||
if (_matchOne(TokenType.$else)) {
|
||||
$else = expression();
|
||||
}
|
||||
|
||||
_consume(TokenType.end, 'Expected END to finish the case operator');
|
||||
return CaseExpression(whens: whens, base: base, elseExpr: $else)
|
||||
..setSpan(caseToken, _previous);
|
||||
}
|
||||
|
||||
return _primary();
|
||||
}
|
||||
|
||||
@override
|
||||
Literal? _literalOrNull() {
|
||||
final token = _peek;
|
||||
|
||||
Literal? _parseInner() {
|
||||
if (_matchOne(TokenType.numberLiteral)) {
|
||||
final number = token as NumericToken;
|
||||
return NumericLiteral(number.parsedNumber, token);
|
||||
}
|
||||
if (_matchOne(TokenType.stringLiteral)) {
|
||||
return StringLiteral(token as StringLiteralToken);
|
||||
}
|
||||
if (_matchOne(TokenType.$null)) {
|
||||
return NullLiteral(token);
|
||||
}
|
||||
if (_matchOne(TokenType.$true)) {
|
||||
return BooleanLiteral.withTrue(token);
|
||||
}
|
||||
if (_matchOne(TokenType.$false)) {
|
||||
return BooleanLiteral.withFalse(token);
|
||||
}
|
||||
|
||||
const timeLiterals = {
|
||||
TokenType.currentTime: TimeConstantKind.currentTime,
|
||||
TokenType.currentDate: TimeConstantKind.currentDate,
|
||||
TokenType.currentTimestamp: TimeConstantKind.currentTimestamp,
|
||||
};
|
||||
|
||||
if (_match(timeLiterals.keys)) {
|
||||
final token = _previous;
|
||||
return TimeConstantLiteral(timeLiterals[token.type]!, token);
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
final literal = _parseInner();
|
||||
literal?.setSpan(token, token);
|
||||
return literal;
|
||||
}
|
||||
|
||||
Expression _primary() {
|
||||
final literal = _literalOrNull();
|
||||
if (literal != null) return literal;
|
||||
|
||||
final variable = _variableOrNull();
|
||||
if (variable != null) return variable;
|
||||
|
||||
if (_matchOne(TokenType.leftParen)) {
|
||||
final left = _previous;
|
||||
|
||||
final selectStmt = _fullSelect(); // returns null if there's no select
|
||||
if (selectStmt != null) {
|
||||
_consume(TokenType.rightParen, 'Expected a closing bracket');
|
||||
return SubQuery(select: selectStmt)..setSpan(left, _previous);
|
||||
} else {
|
||||
final expr = expression();
|
||||
|
||||
if (_matchOne(TokenType.comma)) {
|
||||
// It's a row value!
|
||||
final expressions = [expr];
|
||||
|
||||
do {
|
||||
expressions.add(expression());
|
||||
} while (_matchOne(TokenType.comma));
|
||||
|
||||
_consume(TokenType.rightParen, 'Expected a closing bracket');
|
||||
return Tuple(expressions: expressions, usedAsRowValue: true)
|
||||
..setSpan(left, _previous);
|
||||
}
|
||||
|
||||
_consume(TokenType.rightParen, 'Expected a closing bracket');
|
||||
return Parentheses(left, expr, _previous)..setSpan(left, _previous);
|
||||
}
|
||||
} else if (_matchOne(TokenType.dollarSignVariable)) {
|
||||
if (enableMoorExtensions) {
|
||||
final typedToken = _previous as DollarSignVariableToken;
|
||||
return DartExpressionPlaceholder(name: typedToken.name)
|
||||
..token = typedToken
|
||||
..setSpan(_previous, _previous);
|
||||
}
|
||||
} else if (_matchOne(TokenType.cast)) {
|
||||
final first = _previous;
|
||||
|
||||
_consume(TokenType.leftParen, 'Expected opening parenthesis after CAST');
|
||||
final operand = expression();
|
||||
_consume(TokenType.as, 'Expected AS operator here');
|
||||
final type = _typeName()!;
|
||||
final typeName = type.lexeme;
|
||||
_consume(TokenType.rightParen, 'Expected closing bracket here');
|
||||
|
||||
return CastExpression(operand, typeName)..setSpan(first, _previous);
|
||||
} else if (_checkIdentifier()) {
|
||||
final first = _consumeIdentifier(
|
||||
'This error message should never be displayed. Please report.');
|
||||
|
||||
// could be table.column, function(...) or just column
|
||||
if (_matchOne(TokenType.dot)) {
|
||||
final second =
|
||||
_consumeIdentifier('Expected a column name here', lenient: true);
|
||||
return Reference(
|
||||
tableName: first.identifier, columnName: second.identifier)
|
||||
..setSpan(first, second);
|
||||
} else if (_matchOne(TokenType.leftParen)) {
|
||||
// regular function invocation
|
||||
final parameters = _functionParameters();
|
||||
final rightParen = _consume(TokenType.rightParen,
|
||||
'Expected closing bracket after argument list');
|
||||
|
||||
if (_peek.type == TokenType.filter || _peek.type == TokenType.over) {
|
||||
return _aggregate(first, parameters);
|
||||
}
|
||||
|
||||
return FunctionExpression(
|
||||
name: first.identifier, parameters: parameters)
|
||||
..setSpan(first, rightParen);
|
||||
} else {
|
||||
return Reference(columnName: first.identifier)..setSpan(first, first);
|
||||
}
|
||||
}
|
||||
|
||||
if (_peek is KeywordToken) {
|
||||
_error('Could not parse this expression. Note: This is a reserved '
|
||||
'keyword, you can escape it in double ticks');
|
||||
} else {
|
||||
_error('Could not parse this expression');
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Variable? _variableOrNull() {
|
||||
if (_matchOne(TokenType.questionMarkVariable)) {
|
||||
return NumberedVariable(_previous as QuestionMarkVariableToken)
|
||||
..setSpan(_previous, _previous);
|
||||
} else if (_matchOne(TokenType.colonVariable)) {
|
||||
return ColonNamedVariable(_previous as ColonVariableToken)
|
||||
..setSpan(_previous, _previous);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
@override
|
||||
FunctionParameters _functionParameters() {
|
||||
if (_matchOne(TokenType.star)) {
|
||||
return StarFunctionParameter()
|
||||
..starToken = _previous
|
||||
..setSpan(_previous, _previous);
|
||||
}
|
||||
|
||||
if (_check(TokenType.rightParen)) {
|
||||
// nothing between the brackets -> empty parameter list. We mark it as
|
||||
// synthetic because it has an empty span in the file
|
||||
return ExprFunctionParameters(parameters: const [])..synthetic = true;
|
||||
}
|
||||
|
||||
final distinct = _matchOne(TokenType.distinct);
|
||||
final parameters = <Expression>[];
|
||||
final first = _peek;
|
||||
|
||||
do {
|
||||
parameters.add(expression());
|
||||
} while (_matchOne(TokenType.comma));
|
||||
|
||||
return ExprFunctionParameters(distinct: distinct, parameters: parameters)
|
||||
..setSpan(first, _previous);
|
||||
}
|
||||
|
||||
AggregateExpression _aggregate(
|
||||
IdentifierToken name, FunctionParameters params) {
|
||||
Expression? filter;
|
||||
|
||||
// https://www.sqlite.org/syntax/filter.html (it's optional)
|
||||
if (_matchOne(TokenType.filter)) {
|
||||
_consume(TokenType.leftParen,
|
||||
'Expected opening parenthesis after filter statement');
|
||||
_consume(TokenType.where, 'Expected WHERE clause');
|
||||
filter = expression();
|
||||
_consume(TokenType.rightParen, 'Expecteded closing parenthes');
|
||||
}
|
||||
|
||||
_consume(TokenType.over, 'Expected OVER to begin window clause');
|
||||
|
||||
String? windowName;
|
||||
WindowDefinition? window;
|
||||
|
||||
if (_matchOne(TokenType.identifier)) {
|
||||
windowName = (_previous as IdentifierToken).identifier;
|
||||
} else {
|
||||
window = _windowDefinition();
|
||||
}
|
||||
|
||||
return AggregateExpression(
|
||||
function: name,
|
||||
parameters: params,
|
||||
filter: filter,
|
||||
windowDefinition: window,
|
||||
windowName: windowName,
|
||||
)..setSpan(name, _previous);
|
||||
}
|
||||
|
||||
@override
|
||||
Expression _consumeTuple({bool orSubQuery = false}) {
|
||||
final firstToken =
|
||||
_consume(TokenType.leftParen, 'Expected opening parenthesis for tuple');
|
||||
final expressions = <Expression>[];
|
||||
|
||||
// if desired, attempt to parse select statement
|
||||
final subQuery = orSubQuery ? _fullSelect() : null;
|
||||
if (subQuery == null) {
|
||||
// no sub query found. read expressions that form the tuple.
|
||||
// tuples can be empty `()`, so only start parsing values when it's not
|
||||
if (_peek.type != TokenType.rightParen) {
|
||||
do {
|
||||
expressions.add(expression());
|
||||
} while (_matchOne(TokenType.comma));
|
||||
}
|
||||
|
||||
_consume(
|
||||
TokenType.rightParen, 'Expected right parenthesis to close tuple');
|
||||
return Tuple(expressions: expressions)..setSpan(firstToken, _previous);
|
||||
} else {
|
||||
_consume(TokenType.rightParen,
|
||||
'Expected right parenthesis to finish subquery');
|
||||
return SubQuery(select: subQuery)..setSpan(firstToken, _previous);
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,705 +0,0 @@
|
|||
part of 'parser.dart';
|
||||
|
||||
mixin SchemaParser on ParserBase {
|
||||
SchemaStatement? _create() {
|
||||
if (!_matchOne(TokenType.create)) return null;
|
||||
|
||||
if (_check(TokenType.table) || _check(TokenType.virtual)) {
|
||||
return _createTable();
|
||||
} else if (_check(TokenType.trigger)) {
|
||||
return _createTrigger();
|
||||
} else if (_check(TokenType.unique) || _check(TokenType.$index)) {
|
||||
return _createIndex();
|
||||
} else if (_check(TokenType.view)) {
|
||||
return _createView();
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/// Parses a `CREATE TABLE` statement, assuming that the `CREATE` token has
|
||||
/// already been matched.
|
||||
TableInducingStatement _createTable() {
|
||||
final first = _previous;
|
||||
assert(first.type == TokenType.create);
|
||||
|
||||
final virtual = _matchOne(TokenType.virtual);
|
||||
|
||||
_consume(TokenType.table, 'Expected TABLE keyword here');
|
||||
|
||||
final ifNotExists = _ifNotExists();
|
||||
|
||||
final tableIdentifier = _consumeIdentifier('Expected a table name');
|
||||
|
||||
if (virtual) {
|
||||
return _virtualTable(first, ifNotExists, tableIdentifier);
|
||||
}
|
||||
|
||||
// we don't currently support CREATE TABLE x AS SELECT ... statements
|
||||
final leftParen = _consume(
|
||||
TokenType.leftParen, 'Expected opening parenthesis to list columns');
|
||||
|
||||
final columns = <ColumnDefinition>[];
|
||||
final tableConstraints = <TableConstraint>[];
|
||||
// the columns must come before the table constraints!
|
||||
var encounteredTableConstraint = false;
|
||||
|
||||
do {
|
||||
try {
|
||||
final tableConstraint = _tableConstraintOrNull();
|
||||
|
||||
if (tableConstraint != null) {
|
||||
encounteredTableConstraint = true;
|
||||
tableConstraints.add(tableConstraint);
|
||||
} else {
|
||||
if (encounteredTableConstraint) {
|
||||
_error('Expected another table constraint');
|
||||
} else {
|
||||
columns.add(_columnDefinition());
|
||||
}
|
||||
}
|
||||
} on ParsingError {
|
||||
// if we're at the closing bracket, don't try to parse another column
|
||||
if (_check(TokenType.rightParen)) break;
|
||||
// error while parsing a column definition or table constraint. We try
|
||||
// to recover to the next comma.
|
||||
_synchronize(TokenType.comma);
|
||||
if (_check(TokenType.rightParen)) break;
|
||||
}
|
||||
} while (_matchOne(TokenType.comma));
|
||||
|
||||
final rightParen =
|
||||
_consume(TokenType.rightParen, 'Expected closing parenthesis');
|
||||
|
||||
var withoutRowId = false;
|
||||
if (_matchOne(TokenType.without)) {
|
||||
_consume(
|
||||
TokenType.rowid, 'Expected ROWID to complete the WITHOUT ROWID part');
|
||||
withoutRowId = true;
|
||||
}
|
||||
|
||||
final overriddenName = _overriddenDataClassName();
|
||||
|
||||
return CreateTableStatement(
|
||||
ifNotExists: ifNotExists,
|
||||
tableName: tableIdentifier.identifier,
|
||||
withoutRowId: withoutRowId,
|
||||
columns: columns,
|
||||
tableConstraints: tableConstraints,
|
||||
overriddenDataClassName: overriddenName,
|
||||
)
|
||||
..setSpan(first, _previous)
|
||||
..openingBracket = leftParen
|
||||
..closingBracket = rightParen
|
||||
..tableNameToken = tableIdentifier;
|
||||
}
|
||||
|
||||
/// Parses a `CREATE VIRTUAL TABLE` statement, after the `CREATE VIRTUAL TABLE
|
||||
/// <name>` tokens have already been read.
|
||||
CreateVirtualTableStatement _virtualTable(
|
||||
Token first, bool ifNotExists, IdentifierToken nameToken) {
|
||||
_consume(TokenType.using, 'Expected USING for virtual table declaration');
|
||||
final moduleName = _consumeIdentifier('Expected a module name');
|
||||
final args = <SourceSpanWithContext>[];
|
||||
|
||||
if (_matchOne(TokenType.leftParen)) {
|
||||
// args can be just about anything, so we accept any token until the right
|
||||
// parenthesis closing it of.
|
||||
Token? currentStart;
|
||||
var levelOfParens = 0;
|
||||
|
||||
void addCurrent() {
|
||||
if (currentStart == null) {
|
||||
_error('Expected at least one token for the previous argument');
|
||||
} else {
|
||||
args.add(currentStart!.span.expand(_previous.span));
|
||||
currentStart = null;
|
||||
}
|
||||
}
|
||||
|
||||
for (;;) {
|
||||
// begin reading a single argument, which is stopped by a comma or
|
||||
// maybe with a ), if the current depth is one
|
||||
while (_peek.type != TokenType.rightParen &&
|
||||
_peek.type != TokenType.comma) {
|
||||
_advance();
|
||||
if (_previous.type == TokenType.leftParen) {
|
||||
levelOfParens++;
|
||||
}
|
||||
currentStart ??= _previous;
|
||||
}
|
||||
|
||||
// if we just read the last ) of the argument list, finish. Otherwise
|
||||
// just handle the ) and continue reading the same argument
|
||||
if (_peek.type == TokenType.rightParen) {
|
||||
levelOfParens--;
|
||||
if (levelOfParens < 0) {
|
||||
addCurrent();
|
||||
_advance(); // consume the rightParen
|
||||
break;
|
||||
} else {
|
||||
_advance(); // add the rightParen to the current argument
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// finished while loop above, but not with a ), so it must be a comma
|
||||
// that finishes the current argument
|
||||
assert(_peek.type == TokenType.comma);
|
||||
addCurrent();
|
||||
_advance(); // consume the comma
|
||||
}
|
||||
}
|
||||
|
||||
final moorDataClassName = _overriddenDataClassName();
|
||||
return CreateVirtualTableStatement(
|
||||
ifNotExists: ifNotExists,
|
||||
tableName: nameToken.identifier,
|
||||
moduleName: moduleName.identifier,
|
||||
arguments: args,
|
||||
overriddenDataClassName: moorDataClassName,
|
||||
)
|
||||
..setSpan(first, _previous)
|
||||
..tableNameToken = nameToken
|
||||
..moduleNameToken = moduleName;
|
||||
}
|
||||
|
||||
String? _overriddenDataClassName() {
|
||||
if (enableMoorExtensions && _matchOne(TokenType.as)) {
|
||||
return _consumeIdentifier('Expected the name for the data class')
|
||||
.identifier;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/// Parses a "CREATE TRIGGER" statement, assuming that the create token has
|
||||
/// already been consumed.
|
||||
CreateTriggerStatement? _createTrigger() {
|
||||
final create = _previous;
|
||||
assert(create.type == TokenType.create);
|
||||
|
||||
if (!_matchOne(TokenType.trigger)) return null;
|
||||
|
||||
final ifNotExists = _ifNotExists();
|
||||
final trigger = _consumeIdentifier('Expected a name for the identifier');
|
||||
|
||||
TriggerMode mode;
|
||||
if (_matchOne(TokenType.before)) {
|
||||
mode = TriggerMode.before;
|
||||
} else if (_matchOne(TokenType.after)) {
|
||||
mode = TriggerMode.after;
|
||||
} else {
|
||||
const msg = 'Expected BEFORE, AFTER or INSTEAD OF';
|
||||
_consume(TokenType.instead, msg);
|
||||
_consume(TokenType.of, msg);
|
||||
mode = TriggerMode.insteadOf;
|
||||
}
|
||||
|
||||
TriggerTarget target;
|
||||
if (_matchOne(TokenType.delete)) {
|
||||
target = DeleteTarget()
|
||||
..deleteToken = _previous
|
||||
..setSpan(_previous, _previous);
|
||||
} else if (_matchOne(TokenType.insert)) {
|
||||
target = InsertTarget()
|
||||
..insertToken = _previous
|
||||
..setSpan(_previous, _previous);
|
||||
} else {
|
||||
final updateToken = _consume(
|
||||
TokenType.update, 'Expected DELETE, INSERT or UPDATE as a trigger');
|
||||
final names = <Reference>[];
|
||||
|
||||
if (_matchOne(TokenType.of)) {
|
||||
do {
|
||||
final name = _consumeIdentifier('Expected column name in ON clause');
|
||||
final reference = Reference(columnName: name.identifier)
|
||||
..setSpan(name, name);
|
||||
names.add(reference);
|
||||
} while (_matchOne(TokenType.comma));
|
||||
}
|
||||
|
||||
target = UpdateTarget(names)
|
||||
..updateToken = updateToken
|
||||
..setSpan(updateToken, _previous);
|
||||
}
|
||||
|
||||
_consume(TokenType.on, 'Expected ON');
|
||||
_suggestHint(const TableNameDescription());
|
||||
final nameToken = _consumeIdentifier('Expected a table name');
|
||||
final tableRef = TableReference(nameToken.identifier)
|
||||
..setSpan(nameToken, nameToken);
|
||||
|
||||
if (_matchOne(TokenType.$for)) {
|
||||
const msg = 'Expected FOR EACH ROW';
|
||||
_consume(TokenType.each, msg);
|
||||
_consume(TokenType.row, msg);
|
||||
}
|
||||
|
||||
Expression? when;
|
||||
if (_matchOne(TokenType.when)) {
|
||||
when = expression();
|
||||
}
|
||||
|
||||
final block = _consumeBlock();
|
||||
|
||||
return CreateTriggerStatement(
|
||||
ifNotExists: ifNotExists,
|
||||
triggerName: trigger.identifier,
|
||||
mode: mode,
|
||||
target: target,
|
||||
onTable: tableRef,
|
||||
when: when,
|
||||
action: block,
|
||||
)
|
||||
..setSpan(create, _previous)
|
||||
..triggerNameToken = trigger;
|
||||
}
|
||||
|
||||
/// Parses a [CreateViewStatement]. The `CREATE` token must have already been
|
||||
/// accepted.
|
||||
CreateViewStatement? _createView() {
|
||||
final create = _previous;
|
||||
assert(create.type == TokenType.create);
|
||||
|
||||
if (!_matchOne(TokenType.view)) return null;
|
||||
|
||||
final ifNotExists = _ifNotExists();
|
||||
final name = _consumeIdentifier('Expected a name for this view');
|
||||
|
||||
List<String>? columnNames;
|
||||
if (_matchOne(TokenType.leftParen)) {
|
||||
columnNames = _columnNames();
|
||||
_consume(TokenType.rightParen, 'Expected closing bracket');
|
||||
}
|
||||
|
||||
_consume(TokenType.as, 'Expected AS SELECT');
|
||||
|
||||
final query = _fullSelect()!;
|
||||
|
||||
return CreateViewStatement(
|
||||
ifNotExists: ifNotExists,
|
||||
viewName: name.identifier,
|
||||
columns: columnNames,
|
||||
query: query,
|
||||
)
|
||||
..viewNameToken = name
|
||||
..setSpan(create, _previous);
|
||||
}
|
||||
|
||||
/// Parses a [CreateIndexStatement]. The `CREATE` token must have already been
|
||||
/// accepted.
|
||||
CreateIndexStatement? _createIndex() {
|
||||
final create = _previous;
|
||||
assert(create.type == TokenType.create);
|
||||
|
||||
final unique = _matchOne(TokenType.unique);
|
||||
if (!_matchOne(TokenType.$index)) return null;
|
||||
|
||||
final ifNotExists = _ifNotExists();
|
||||
final name = _consumeIdentifier('Expected a name for this index');
|
||||
|
||||
_consume(TokenType.on, 'Expected ON table');
|
||||
_suggestHint(const TableNameDescription());
|
||||
final nameToken = _consumeIdentifier('Expected a table name');
|
||||
final tableRef = TableReference(nameToken.identifier)
|
||||
..setSpan(nameToken, nameToken);
|
||||
|
||||
_consume(TokenType.leftParen, 'Expected indexed columns in parentheses');
|
||||
|
||||
final indexes = _indexedColumns();
|
||||
|
||||
_consume(TokenType.rightParen, 'Expected closing bracket');
|
||||
|
||||
Expression? where;
|
||||
if (_matchOne(TokenType.where)) {
|
||||
where = expression();
|
||||
}
|
||||
|
||||
return CreateIndexStatement(
|
||||
indexName: name.identifier,
|
||||
unique: unique,
|
||||
ifNotExists: ifNotExists,
|
||||
on: tableRef,
|
||||
columns: indexes,
|
||||
where: where,
|
||||
)
|
||||
..nameToken = name
|
||||
..setSpan(create, _previous);
|
||||
}
|
||||
|
||||
List<String> _columnNames() {
|
||||
final columns = <String>[];
|
||||
do {
|
||||
final colName = _consumeIdentifier('Expected a name for this column');
|
||||
|
||||
columns.add(colName.identifier);
|
||||
} while (_matchOne(TokenType.comma));
|
||||
|
||||
return columns;
|
||||
}
|
||||
|
||||
@override
|
||||
List<IndexedColumn> _indexedColumns() {
|
||||
final indexes = <IndexedColumn>[];
|
||||
do {
|
||||
final expr = expression();
|
||||
final mode = _orderingModeOrNull();
|
||||
|
||||
indexes.add(IndexedColumn(expr, mode)..setSpan(expr.first!, _previous));
|
||||
} while (_matchOne(TokenType.comma));
|
||||
|
||||
return indexes;
|
||||
}
|
||||
|
||||
/// Parses `IF NOT EXISTS` | epsilon
|
||||
bool _ifNotExists() {
|
||||
if (_matchOne(TokenType.$if)) {
|
||||
_consume(TokenType.not, 'Expected IF to be followed by NOT EXISTS');
|
||||
_consume(TokenType.exists, 'Expected IF NOT to be followed by EXISTS');
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
ColumnDefinition _columnDefinition() {
|
||||
final name = _consume(TokenType.identifier, 'Expected a column name')
|
||||
as IdentifierToken;
|
||||
|
||||
final typeTokens = _typeName();
|
||||
String? typeName;
|
||||
|
||||
if (typeTokens != null) {
|
||||
typeName = typeTokens.lexeme;
|
||||
}
|
||||
|
||||
final constraints = <ColumnConstraint>[];
|
||||
ColumnConstraint? constraint;
|
||||
while ((constraint = _columnConstraint(orNull: true)) != null) {
|
||||
constraints.add(constraint!);
|
||||
}
|
||||
|
||||
return ColumnDefinition(
|
||||
columnName: name.identifier,
|
||||
typeName: typeName,
|
||||
constraints: constraints,
|
||||
)
|
||||
..setSpan(name, _previous)
|
||||
..typeNames = typeTokens
|
||||
..nameToken = name;
|
||||
}
|
||||
|
||||
@override
|
||||
List<Token>? _typeName() {
|
||||
// sqlite doesn't really define what a type name is and has very loose rules
|
||||
// at turning them into a type affinity. We support this pattern:
|
||||
// typename = identifier [ "(" { identifier | comma | number_literal } ")" ]
|
||||
if (!_matchOne(TokenType.identifier)) return null;
|
||||
|
||||
final typeNames = [_previous];
|
||||
|
||||
if (_matchOne(TokenType.leftParen)) {
|
||||
typeNames.add(_previous);
|
||||
|
||||
const inBrackets = [
|
||||
TokenType.identifier,
|
||||
TokenType.comma,
|
||||
TokenType.numberLiteral
|
||||
];
|
||||
while (_match(inBrackets)) {
|
||||
typeNames.add(_previous);
|
||||
}
|
||||
|
||||
_consume(TokenType.rightParen,
|
||||
'Expected closing parenthesis to finish type name');
|
||||
typeNames.add(_previous);
|
||||
}
|
||||
|
||||
return typeNames;
|
||||
}
|
||||
|
||||
ColumnConstraint? _columnConstraint({bool orNull = false}) {
|
||||
final first = _peek;
|
||||
|
||||
final resolvedName = _constraintNameOrNull()?.identifier;
|
||||
|
||||
if (_matchOne(TokenType.primary)) {
|
||||
_suggestHint(HintDescription.token(TokenType.key));
|
||||
_consume(TokenType.key, 'Expected KEY to complete PRIMARY KEY clause');
|
||||
|
||||
final mode = _orderingModeOrNull();
|
||||
final conflict = _conflictClauseOrNull();
|
||||
|
||||
_suggestHint(HintDescription.token(TokenType.autoincrement));
|
||||
final hasAutoInc = _matchOne(TokenType.autoincrement);
|
||||
|
||||
return PrimaryKeyColumn(resolvedName,
|
||||
autoIncrement: hasAutoInc, mode: mode, onConflict: conflict)
|
||||
..setSpan(first, _previous);
|
||||
}
|
||||
if (_matchOne(TokenType.$null)) {
|
||||
final nullToken = _previous;
|
||||
return NullColumnConstraint(resolvedName, $null: nullToken)
|
||||
..setSpan(nullToken, nullToken);
|
||||
}
|
||||
if (_matchOne(TokenType.not)) {
|
||||
_suggestHint(HintDescription.token(TokenType.$null));
|
||||
|
||||
final notToken = _previous;
|
||||
final nullToken =
|
||||
_consume(TokenType.$null, 'Expected NULL to complete NOT NULL');
|
||||
|
||||
return NotNull(resolvedName, onConflict: _conflictClauseOrNull())
|
||||
..setSpan(first, _previous)
|
||||
..not = notToken
|
||||
..$null = nullToken;
|
||||
}
|
||||
if (_matchOne(TokenType.unique)) {
|
||||
return UniqueColumn(resolvedName, _conflictClauseOrNull())
|
||||
..setSpan(first, _previous);
|
||||
}
|
||||
if (_matchOne(TokenType.check)) {
|
||||
final expr = _expressionInParentheses();
|
||||
return CheckColumn(resolvedName, expr)..setSpan(first, _previous);
|
||||
}
|
||||
if (_matchOne(TokenType.$default)) {
|
||||
Expression? expr = _literalOrNull();
|
||||
|
||||
// when not a literal, expect an expression in parentheses
|
||||
expr ??= _expressionInParentheses();
|
||||
|
||||
return Default(resolvedName, expr)..setSpan(first, _previous);
|
||||
}
|
||||
if (_matchOne(TokenType.collate)) {
|
||||
final collation = _consumeIdentifier('Expected the collation name');
|
||||
|
||||
return CollateConstraint(resolvedName, collation.identifier)
|
||||
..setSpan(first, _previous);
|
||||
}
|
||||
if (_peek.type == TokenType.references) {
|
||||
final clause = _foreignKeyClause();
|
||||
return ForeignKeyColumnConstraint(resolvedName, clause)
|
||||
..setSpan(first, _previous);
|
||||
}
|
||||
if (enableMoorExtensions && _matchOne(TokenType.mapped)) {
|
||||
_consume(TokenType.by, 'Expected a MAPPED BY constraint');
|
||||
|
||||
final dartExpr = _consume(
|
||||
TokenType.inlineDart, 'Expected Dart expression in backticks');
|
||||
|
||||
return MappedBy(resolvedName, dartExpr as InlineDartToken)
|
||||
..setSpan(first, _previous);
|
||||
}
|
||||
if (enableMoorExtensions && _matchOne(TokenType.json)) {
|
||||
final jsonToken = _previous;
|
||||
final keyToken =
|
||||
_consume(TokenType.key, 'Expected a JSON KEY constraint');
|
||||
final name = _consumeIdentifier('Expected a name for for the json key');
|
||||
|
||||
return JsonKey(resolvedName, name)
|
||||
..setSpan(first, _previous)
|
||||
..json = jsonToken
|
||||
..key = keyToken;
|
||||
}
|
||||
if (enableMoorExtensions && _matchOne(TokenType.as)) {
|
||||
final asToken = _previous;
|
||||
final nameToken = _consumeIdentifier('Expected Dart getter name');
|
||||
|
||||
return MoorDartName(resolvedName, nameToken)
|
||||
..setSpan(first, _previous)
|
||||
..as = asToken;
|
||||
}
|
||||
|
||||
// no known column constraint matched. If orNull is set and we're not
|
||||
// guaranteed to be in a constraint clause (started with CONSTRAINT), we
|
||||
// can return null
|
||||
if (orNull && resolvedName == null) {
|
||||
return null;
|
||||
}
|
||||
_error('Expected a constraint (primary key, nullability, etc.)');
|
||||
}
|
||||
|
||||
TableConstraint? _tableConstraintOrNull() {
|
||||
final first = _peek;
|
||||
final nameToken = _constraintNameOrNull();
|
||||
final name = nameToken?.identifier;
|
||||
|
||||
TableConstraint? result;
|
||||
if (_match([TokenType.unique, TokenType.primary])) {
|
||||
final isPrimaryKey = _previous.type == TokenType.primary;
|
||||
|
||||
if (isPrimaryKey) {
|
||||
_consume(TokenType.key, 'Expected KEY to start PRIMARY KEY clause');
|
||||
}
|
||||
|
||||
final columns = _listColumnsInParentheses(allowEmpty: false);
|
||||
final conflictClause = _conflictClauseOrNull();
|
||||
|
||||
result = KeyClause(name,
|
||||
isPrimaryKey: isPrimaryKey,
|
||||
indexedColumns: columns,
|
||||
onConflict: conflictClause);
|
||||
} else if (_matchOne(TokenType.check)) {
|
||||
final expr = _expressionInParentheses();
|
||||
result = CheckTable(name, expr);
|
||||
} else if (_matchOne(TokenType.foreign)) {
|
||||
_consume(TokenType.key, 'Expected KEY to start FOREIGN KEY clause');
|
||||
final columns = _listColumnsInParentheses(allowEmpty: false);
|
||||
final clause = _foreignKeyClause();
|
||||
|
||||
result =
|
||||
ForeignKeyTableConstraint(name, columns: columns, clause: clause);
|
||||
}
|
||||
|
||||
if (result != null) {
|
||||
result
|
||||
..setSpan(first, _previous)
|
||||
..nameToken = nameToken;
|
||||
return result;
|
||||
}
|
||||
|
||||
if (name != null) {
|
||||
// if a constraint was started with CONSTRAINT <name> but then we didn't
|
||||
// find a constraint, that's an syntax error
|
||||
_error('Expected a table constraint (e.g. a primary key)');
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
IdentifierToken? _constraintNameOrNull() {
|
||||
if (_matchOne(TokenType.constraint)) {
|
||||
final name = _consumeIdentifier('Expect a name for the constraint here');
|
||||
return name;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
Expression _expressionInParentheses() {
|
||||
_consume(TokenType.leftParen, 'Expected opening parenthesis');
|
||||
final expr = expression();
|
||||
_consume(TokenType.rightParen, 'Expected closing parenthesis');
|
||||
return expr;
|
||||
}
|
||||
|
||||
ConflictClause? _conflictClauseOrNull() {
|
||||
_suggestHint(HintDescription.token(TokenType.on));
|
||||
if (_matchOne(TokenType.on)) {
|
||||
_consume(TokenType.conflict,
|
||||
'Expected CONFLICT to complete ON CONFLICT clause');
|
||||
|
||||
const modes = {
|
||||
TokenType.rollback: ConflictClause.rollback,
|
||||
TokenType.abort: ConflictClause.abort,
|
||||
TokenType.fail: ConflictClause.fail,
|
||||
TokenType.ignore: ConflictClause.ignore,
|
||||
TokenType.replace: ConflictClause.replace,
|
||||
};
|
||||
_suggestHint(HintDescription.tokens(modes.keys.toList()));
|
||||
|
||||
if (_match(modes.keys)) {
|
||||
return modes[_previous.type];
|
||||
} else {
|
||||
_error('Expected a conflict handler (rollback, abort, etc.) here');
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
ForeignKeyClause _foreignKeyClause() {
|
||||
// https://www.sqlite.org/syntax/foreign-key-clause.html
|
||||
_consume(TokenType.references, 'Expected REFERENCES');
|
||||
final firstToken = _previous;
|
||||
|
||||
final foreignTable = _consumeIdentifier('Expected a table name');
|
||||
final foreignTableName = TableReference(foreignTable.identifier, null)
|
||||
..setSpan(foreignTable, foreignTable);
|
||||
|
||||
final columnNames = _listColumnsInParentheses(allowEmpty: true);
|
||||
|
||||
ReferenceAction? onDelete, onUpdate;
|
||||
|
||||
_suggestHint(HintDescription.token(TokenType.on));
|
||||
while (_matchOne(TokenType.on)) {
|
||||
_suggestHint(
|
||||
const HintDescription.tokens([TokenType.delete, TokenType.update]));
|
||||
if (_matchOne(TokenType.delete)) {
|
||||
onDelete = _referenceAction();
|
||||
} else if (_matchOne(TokenType.update)) {
|
||||
onUpdate = _referenceAction();
|
||||
} else {
|
||||
_error('Expected either DELETE or UPDATE');
|
||||
}
|
||||
}
|
||||
|
||||
DeferrableClause? deferrable;
|
||||
if (_checkWithNot(TokenType.deferrable)) {
|
||||
final first = _peekNext;
|
||||
|
||||
final not = _matchOne(TokenType.not);
|
||||
_consume(TokenType.deferrable);
|
||||
|
||||
InitialDeferrableMode? mode;
|
||||
if (_matchOne(TokenType.initially)) {
|
||||
if (_matchOne(TokenType.deferred)) {
|
||||
mode = InitialDeferrableMode.deferred;
|
||||
} else if (_matchOne(TokenType.immediate)) {
|
||||
mode = InitialDeferrableMode.immediate;
|
||||
} else {
|
||||
_error('Expected DEFERRED or IMMEDIATE here');
|
||||
}
|
||||
}
|
||||
|
||||
deferrable = DeferrableClause(not, mode)..setSpan(first, _previous);
|
||||
}
|
||||
|
||||
return ForeignKeyClause(
|
||||
foreignTable: foreignTableName,
|
||||
columnNames: columnNames,
|
||||
onUpdate: onUpdate,
|
||||
onDelete: onDelete,
|
||||
deferrable: deferrable,
|
||||
)..setSpan(firstToken, _previous);
|
||||
}
|
||||
|
||||
ReferenceAction _referenceAction() {
|
||||
if (_matchOne(TokenType.cascade)) {
|
||||
return ReferenceAction.cascade;
|
||||
} else if (_matchOne(TokenType.restrict)) {
|
||||
return ReferenceAction.restrict;
|
||||
} else if (_matchOne(TokenType.no)) {
|
||||
_consume(TokenType.action, 'Expect ACTION to complete NO ACTION clause');
|
||||
return ReferenceAction.noAction;
|
||||
} else if (_matchOne(TokenType.set)) {
|
||||
if (_matchOne(TokenType.$null)) {
|
||||
return ReferenceAction.setNull;
|
||||
} else if (_matchOne(TokenType.$default)) {
|
||||
return ReferenceAction.setDefault;
|
||||
} else {
|
||||
_error('Expected either NULL or DEFAULT as set action here');
|
||||
}
|
||||
} else {
|
||||
_error('Not a valid action, expected CASCADE, SET NULL, etc..');
|
||||
}
|
||||
}
|
||||
|
||||
List<Reference> _listColumnsInParentheses({bool allowEmpty = false}) {
|
||||
final columnNames = <Reference>[];
|
||||
if (_matchOne(TokenType.leftParen)) {
|
||||
do {
|
||||
final referenceId = _consumeIdentifier('Expected a column name');
|
||||
final reference = Reference(columnName: referenceId.identifier)
|
||||
..setSpan(referenceId, referenceId);
|
||||
columnNames.add(reference);
|
||||
} while (_matchOne(TokenType.comma));
|
||||
|
||||
_consume(TokenType.rightParen,
|
||||
'Expected closing paranthesis after column names');
|
||||
} else {
|
||||
if (!allowEmpty) {
|
||||
_error('Expected a list of columns in parantheses');
|
||||
}
|
||||
}
|
||||
|
||||
return columnNames;
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue