Report errors when ORDER or LIMIT is used in compound stmt

moor/lib/src/runtime/statements/query.dart

@@ -121,7 +121,7 @@ abstract class Selectable<T> {
     return watch().transform(singleElements());
   }
 
-  /// Maps this selectable by using [mapper].
+  /// Maps this selectable by the [mapper] function.
   ///
   /// Each entry emitted by this [Selectable] will be transformed by the
   /// [mapper] and then emitted to the selectable returned.

sqlparser/lib/src/analysis/analysis.dart

@@ -11,7 +11,7 @@ part 'schema/references.dart';
 part 'schema/table.dart';
 
 part 'steps/column_resolver.dart';
-part 'steps/reference_finder.dart';
+part 'steps/prepare_ast.dart';
 part 'steps/reference_resolver.dart';
 part 'steps/set_parent_visitor.dart';
 part 'steps/type_resolver.dart';

sqlparser/lib/src/analysis/error.dart

@@ -55,6 +55,9 @@ enum AnalysisErrorType {
   referencedUnknownColumn,
   ambiguousReference,
 
+  /// Note that most syntax errors are reported as [ParsingError]
+  synctactic,
+
   unknownFunction,
   other,
 }

sqlparser/lib/src/analysis/steps/prepare_ast.dart

@@ -1,17 +1,20 @@
 part of '../analysis.dart';
 
-/// Walks the AST and
+/// Prepares the AST for further analysis. This visitor:
 /// - attaches the global scope containing table names and builtin functions
-/// - creates [ReferenceScope] for sub-queries
+/// - creates [ReferenceScope]s for sub-queries
 /// - in each scope, registers every table or subquery that can be referenced to
 ///   the local [ReferenceScope].
 /// - determines the [Variable.resolvedIndex] for each [Variable] in this
 ///   statement.
-class ReferenceFinder extends RecursiveVisitor<void> {
+/// - reports syntactic errors that aren't handled in the parser to keep that
+///   implementation simpler.
+class AstPreparingVisitor extends RecursiveVisitor<void> {
   final ReferenceScope globalScope;
   final List<Variable> _foundVariables = [];
+  final AnalysisContext context;
 
-  ReferenceFinder({@required this.globalScope});
+  AstPreparingVisitor({@required this.globalScope, this.context});
 
   void start(AstNode root) {
     root
@@ -46,6 +49,40 @@ class ReferenceFinder extends RecursiveVisitor<void> {
       e.scope.register(windowDecl.name, windowDecl);
     }
 
+    // only the last statement in a compound select statement may have an order
+    // by or a limit clause
+    if (e.parent is CompoundSelectPart || e.parent is CompoundSelectStatement) {
+      bool isLast;
+      if (e.parent is CompoundSelectPart) {
+        final part = e.parent as CompoundSelectPart;
+        final compoundSelect = part.parent as CompoundSelectStatement;
+
+        final index = compoundSelect.additional.indexOf(part);
+        isLast = index == compoundSelect.additional.length - 1;
+      } else {
+        // if the parent is the compound select statement, this select query is
+        // the [CompoundSelectStatement.base], so definitely not the last query.
+        isLast = false;
+      }
+
+      if (!isLast) {
+        if (e.limit != null) {
+          context.reportError(AnalysisError(
+            type: AnalysisErrorType.synctactic,
+            message: 'Limit clause must appear in the last compound statement',
+            relevantNode: e.limit,
+          ));
+        }
+        if (e.orderBy != null) {
+          context.reportError(AnalysisError(
+            type: AnalysisErrorType.synctactic,
+            message: 'Order by clause must appear in the compound statement',
+            relevantNode: e.orderBy,
+          ));
+        }
+      }
+    }
+
     visitChildren(e);
   }
 

sqlparser/lib/src/engine/sql_engine.dart

@@ -122,7 +122,7 @@ class SqlEngine {
     final scope = _constructRootScope();
 
     try {
-      ReferenceFinder(globalScope: scope).start(node);
+      AstPreparingVisitor(globalScope: scope, context: context).start(node);
 
       if (node is CrudStatement) {
         node

sqlparser/test/analysis/errors/limit_or_order_by_in_compound_test.dart

@@ -0,0 +1,33 @@
+import 'package:sqlparser/sqlparser.dart';
+import 'package:test/test.dart';
+
+void main() {
+  test('reports error if LIMIT is used before last part', () {
+    final engine = SqlEngine();
+    final analyzed = engine.analyze('SELECT 1 ORDER BY 3 UNION SELECT 2');
+
+    expect(analyzed.errors, hasLength(1));
+    final error = analyzed.errors.single;
+
+    expect(error.type, AnalysisErrorType.synctactic);
+    final wrongLimit = (analyzed.root as CompoundSelectStatement).base.orderBy;
+    expect(error.relevantNode, wrongLimit);
+  });
+
+  test('reports error if ORDER BY is used before last part', () {
+    final engine = SqlEngine();
+    final analyzed = engine.analyze('''
+      SELECT 1 UNION
+      SELECT 1 ORDER BY 2 INTERSECT
+      SELECT 1
+    ''');
+
+    expect(analyzed.errors, hasLength(1));
+    final error = analyzed.errors.single;
+
+    expect(error.type, AnalysisErrorType.synctactic);
+    final wrongOrderBy =
+        (analyzed.root as CompoundSelectStatement).additional[0].select.orderBy;
+    expect(error.relevantNode, wrongOrderBy);
+  });
+}