Allow selecting from subselect

src/ast.ts

 export type Statement = SelectStatement;
 export type Expr = Primary | Binary;
 export type SelectArgument = Expr;
-export type FromTarget = Identifier | Backtick | Alias;
+export type FromTarget = Identifier | Backtick | Alias | SelectStatement;

src/ast/alias.ts

 import * as AST from "../ast";
 
 export class Alias {
-  public object: AST.Expr;
+  public object: AST.Expr | AST.Statement;
   public name: AST.Identifier | AST.Backtick;
 
-  constructor(object: AST.Expr, name: AST.Identifier | AST.Backtick) {
+  constructor(object: AST.Expr | AST.Statement, name: AST.Identifier | AST.Backtick) {
     this.object = object;
     this.name = name;
   }

src/lexer.ts

     } else if (source.match(/^;/)) {
       this.advance();
       return new Token(TokenKind.SEMICOLON, null, this.line);
+    } else if (source.match(/^\(/)) {
+      this.advance();
+      return new Token(TokenKind.LPAREN, null, this.line);
+    } else if (source.match(/^\)/)) {
+      this.advance();
+      return new Token(TokenKind.RPAREN, null, this.line);
     } else if (source.match(/^[0-9]+(\.[0-9]+)?/)) {
       const match = source.match(/^[0-9]+(\.[0-9]+)?/);
       if (match) {

src/parser.ts

 
   private from(): AST.FromTarget | Error {
     this.eat(TokenKind.FROM);
-
     return this.fromTarget();
   }
 
   private fromTarget(): AST.FromTarget | Error {
+    if (this.match(TokenKind.LPAREN)) {
+      this.eat(TokenKind.LPAREN);
+      const stmt = this.select();
+      if (isError(stmt)) {
+        return stmt;
+      }
+
+      const rparen = this.eat(TokenKind.RPAREN);
+      if (isError(rparen)) {
+        return rparen;
+      }
+
+      if (this.match(TokenKind.AS)) {
+        return this.alias(stmt);
+      }
+
+      return stmt;
+    }
+
     const primary = this.backtickOrIdentifier();
-    if (!this.match(TokenKind.AS) || isError(primary)) {
+    if (isError(primary)) {
       return primary;
     }
 
+    return this.alias(primary);
+  }
+
+  private alias<T extends AST.Expr | AST.Statement>(obj: T): AST.Alias | T | Error {
+    if (!this.match(TokenKind.AS)) {
+      return obj;
+    }
+
     this.eat(TokenKind.AS);
 
     const token = this.currentToken();
       return alias;
     }
 
-    return new AST.Alias(primary, alias);
+    return new AST.Alias(obj, alias);
   }
 
   private where(): AST.Expr | Error {
 
     if (this.match(TokenKind.STAR)) {
       this.eat(TokenKind.STAR);
-      const right = this.alias();
+      const right = this.primary();
       if (isError(right)) {
         return right;
       }
 
     if (this.match(TokenKind.SLASH)) {
       this.eat(TokenKind.SLASH);
-      const right = this.alias();
+      const right = this.primary();
       if (isError(right)) {
         return right;
       }
     return left;
   }
 
-  private alias(): AST.Expr | Error {
-    const primary = this.primary();
-    if (isError(primary)) {
-      return primary;
-    }
-
-    if (this.match(TokenKind.AS)) {
-      this.eat(TokenKind.AS);
-
-      const name = this.match(TokenKind.BACKTICK) ? this.backtick() : this.identifier();
-
-      if (isError(name)) {
-        return name;
-      }
-
-      return new AST.Alias(primary, name);
-    }
-
-    return primary;
-  }
-
   private primary(): AST.Expr | Error {
     const token = this.currentToken();
 
           return this.identifier();
         case TokenKind.BACKTICK:
           return this.backtick();
+        case TokenKind.LPAREN:
+          return this.group();
         default:
           return new Error(`Unexpected token: ${token.repr()}`, token.line);
       }
     return primary;
   }
 
+  private group(): AST.Expr | Error {
+    this.eat(TokenKind.LPAREN);
+    const expr = this.expr();
+    const rparen = this.eat(TokenKind.RPAREN);
+    if (isError(rparen)) {
+      return rparen;
+    }
+    return expr;
+  }
+
   private backtickOrIdentifier(): AST.Backtick | AST.Identifier | Error {
     const token = this.currentToken();
     switch (token.kind) {

src/token.ts

   EQUALS = "EQUALS",
   FROM = "FROM",
   IDENTIFIER = "IDENTIFIER",
+  LPAREN = "LPAREN",
   MINUS = "MINUS",
   NUMBER = "NUMBER",
   OR = "OR",
   PLUS = "PLUS",
+  RPAREN = "RPAREN",
   SELECT = "SELECT",
   SEMICOLON = "SEMICOLON",
   SLASH = "SLASH",

test/lexer.test.ts

   });
 
   it("scans symbols", () => {
-    const tokens = scan("=,`;.+-*/");
+    const tokens = scan("=,`;.+-*/()");
     expect(tokens).to.deep.equal([
       new Token(TokenKind.EQUALS, null, 1),
       new Token(TokenKind.COMMA, null, 1),
       new Token(TokenKind.MINUS, null, 1),
       new Token(TokenKind.STAR, null, 1),
       new Token(TokenKind.SLASH, null, 1),
+      new Token(TokenKind.LPAREN, null, 1),
+      new Token(TokenKind.RPAREN, null, 1),
       new Token(TokenKind.EOF, null, 1),
     ]);
   });

test/parser.test.ts

       }),
     ]);
   });
+
+  it("should parse parens", () => {
+    const tree = parse("select a * (b + c)");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [
+          new AST.Binary({
+            left: new AST.Identifier("a"),
+            right: new AST.Binary({
+              left: new AST.Identifier("b"),
+              right: new AST.Identifier("c"),
+              type: AST.BinaryExpressionTypes.ADDITION,
+            }),
+            type: AST.BinaryExpressionTypes.MULTIPLICATION,
+          }),
+        ],
+      }),
+    ]);
+  });
+
+  it("should parse a parenthesized SELECT as a FROM target", () => {
+    const tree = parse("select a from (select b)");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [
+          new AST.Identifier("a"),
+        ],
+        from: new AST.SelectStatement({
+          arguments: [new AST.Identifier("b")],
+        }),
+      }),
+    ]);
+  });
+
+  it("should allow aliases on subselects", () => {
+    const tree = parse("select a from (select b) as c");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [
+          new AST.Identifier("a"),
+        ],
+        from: new AST.Alias(
+          new AST.SelectStatement({
+            arguments: [new AST.Identifier("b")],
+          }),
+          new AST.Identifier("c"),
+        ),
+      }),
+    ]);
+  });
 });