Parse aliases

src/ast.ts

+import { Alias } from "./ast/alias";
 import { Identifier } from "./ast/identifier";
 import { Number as _Number } from "./ast/number";
 import { SelectStatement } from "./ast/selectStatement";
 
+export * from "./ast/alias";
 export * from "./ast/identifier";
 export * from "./ast/number";
 export * from "./ast/selectStatement";
 
 export type Primary = _Number | Identifier;
+export type Secondary = Primary | Alias;
 export type Statement = SelectStatement;

src/ast/alias.ts

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

src/ast/selectStatement.ts

 import * as AST from "../ast";
 
 export interface ISelectStatementOptions {
-  arguments: AST.Primary[];
-  from?: AST.Primary | null;
+  arguments: AST.Secondary[];
+  from?: AST.Secondary | null;
 }
 
 export class SelectStatement {
-  public arguments: AST.Primary[];
-  public from: AST.Primary | null;
+  public arguments: AST.Secondary[];
+  public from: AST.Secondary | null;
 
   constructor(opts: ISelectStatementOptions) {
     this.arguments = opts.arguments;

src/lexer.ts

     } else if (source.match(/^from/i)) {
       this.advance(4);
       return new Token(TokenKind.FROM, null, this.line);
+    } else if (source.match(/^as/i)) {
+      this.advance(2);
+      return new Token(TokenKind.AS, null, this.line);
     } else if (source.match(/^\*/)) {
       this.advance();
       return new Token(TokenKind.STAR, null, this.line);

src/parser.ts

     });
   }
 
-  private args(): AST.Primary[] | Error {
+  private args(): AST.Secondary[] | Error {
     const args = [];
 
     while (true) {
-      const arg = this.primary();
+      const arg = this.alias();
       if (isError(arg)) {
         return arg;
       }
     return args;
   }
 
-  private from(): AST.Primary | Error {
+  private from(): AST.Secondary | Error {
     this.eat(TokenKind.FROM);
-    return this.identifier();
+    return this.alias();
+  }
+
+  private alias(): AST.Secondary | Error {
+    const primary = this.primary();
+    if (isError(primary)) {
+      return primary;
+    }
+
+    if (this.currentToken().kind === TokenKind.AS) {
+      this.eat(TokenKind.AS);
+      const name = this.identifier();
+      if (isError(name)) {
+        return name;
+      }
+      return new AST.Alias(primary, name);
+    }
+
+    return primary;
   }
 
   private primary(): AST.Primary | Error {

src/token.ts

 export enum TokenKind {
+  AS = "AS",
   BACKTICK = "BACKTICK",
   COMMA = "COMMA",
   DOT = "DOT",

test/lexer.test.ts

 
 describe("Lexer", () => {
   it("scans uppercase keywords", () => {
-    const tokens = scan("SELECT FROM WHERE");
+    const tokens = scan("SELECT FROM WHERE AS");
     expect(tokens).to.deep.equal([
       new Token(TokenKind.SELECT, null, 1),
       new Token(TokenKind.FROM, null, 1),
       new Token(TokenKind.WHERE, null, 1),
+      new Token(TokenKind.AS, null, 1),
       new Token(TokenKind.EOF, null, 1),
     ]);
   });
 
   it("scans lowercase keywords", () => {
-    const tokens = scan("select from where");
+    const tokens = scan("select from where as");
     expect(tokens).to.deep.equal([
       new Token(TokenKind.SELECT, null, 1),
       new Token(TokenKind.FROM, null, 1),
       new Token(TokenKind.WHERE, null, 1),
+      new Token(TokenKind.AS, null, 1),
       new Token(TokenKind.EOF, null, 1),
     ]);
   });

test/parser.test.ts

     const tree = parse("select 5, 6");
     expect(tree).to.deep.equal([
       new AST.SelectStatement({
-        arguments: [
-          new AST.Number(5),
-          new AST.Number(6),
-        ],
+        arguments: [new AST.Number(5), new AST.Number(6)],
       }),
     ]);
   });
     const tree = parse("select a, b");
     expect(tree).to.deep.equal([
       new AST.SelectStatement({
-        arguments: [
-          new AST.Identifier("a"),
-          new AST.Identifier("b"),
-        ],
+        arguments: [new AST.Identifier("a"), new AST.Identifier("b")],
       }),
     ]);
   });
     const tree = parse("select a, 5");
     expect(tree).to.deep.equal([
       new AST.SelectStatement({
-        arguments: [
-          new AST.Identifier("a"),
-          new AST.Number(5),
-        ],
+        arguments: [new AST.Identifier("a"), new AST.Number(5)],
       }),
     ]);
   });
 
   it("should parse the from of a selection", () => {
     const tree = parse("select a from t");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [new AST.Identifier("a")],
+        from: new AST.Identifier("t"),
+      }),
+    ]);
+  });
+
+  it("should parse aliases", () => {
+    const tree = parse("select a as b");
     expect(tree).to.deep.equal([
       new AST.SelectStatement({
         arguments: [
-          new AST.Identifier("a"),
+          new AST.Alias(new AST.Identifier("a"), new AST.Identifier("b")),
         ],
-        from: new AST.Identifier("t"),
+      }),
+    ]);
+  });
+
+  it("should parse aliases as from targets", () => {
+    const tree = parse("select a from t as u");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [new AST.Identifier("a")],
+        from: new AST.Alias(new AST.Identifier("t"), new AST.Identifier("u")),
       }),
     ]);
   });