Parse from

src/ast.ts

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

src/ast/selectStatement.ts

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

src/ast/statement.ts

-import * as AST from "../ast";
-
-export enum StatementType {
-  SELECT = "SELECT",
-}
-
-export interface IStatementOptions {
-  type: StatementType;
-  arguments: AST.Primary[];
-}
-
-export class Statement {
-  public type: StatementType;
-  public arguments: AST.Primary[];
-
-  constructor(opts: IStatementOptions) {
-    this.type = opts.type;
-    this.arguments = opts.arguments;
-  }
-}

src/parser.ts

     if (isError(args)) {
       return args;
     }
-    return new AST.Statement({
+
+    const from =
+      this.currentToken().kind === TokenKind.FROM ? this.from() : null;
+    if (isError(from)) {
+      return from;
+    }
+
+    return new AST.SelectStatement({
       arguments: args,
-      type: AST.StatementType.SELECT,
+      from,
     });
   }
 
     return args;
   }
 
+  private from(): AST.Primary | Error {
+    this.eat(TokenKind.FROM);
+    return this.identifier();
+  }
+
   private primary(): AST.Primary | Error {
     const token = this.currentToken();
     switch (token.kind) {
         return this.identifier();
     }
 
-    return new Error(`Unexpected token ${token.kind} ${token.value}`, token.line);
+    return new Error(
+      `Unexpected token ${token.kind} ${token.value}`,
+      token.line,
+    );
   }
 
   private identifier(): AST.Identifier | Error {

test/parser.test.ts

   it("should parse a number selection", () => {
     const tree = parse("select 5");
     expect(tree).to.deep.equal([
-      new AST.Statement({
+      new AST.SelectStatement({
         arguments: [new AST.Number(5)],
-        type: AST.StatementType.SELECT,
       }),
     ]);
   });
   it("should parse a multiple number selection", () => {
     const tree = parse("select 5, 6");
     expect(tree).to.deep.equal([
-      new AST.Statement({
+      new AST.SelectStatement({
         arguments: [
           new AST.Number(5),
           new AST.Number(6),
         ],
-        type: AST.StatementType.SELECT,
       }),
     ]);
   });
   it("should parse a selection of identifiers", () => {
     const tree = parse("select a, b");
     expect(tree).to.deep.equal([
-      new AST.Statement({
+      new AST.SelectStatement({
         arguments: [
           new AST.Identifier("a"),
           new AST.Identifier("b"),
         ],
-        type: AST.StatementType.SELECT,
       }),
     ]);
   });
   it("should parse a selection of identifiers and numbers", () => {
     const tree = parse("select a, 5");
     expect(tree).to.deep.equal([
-      new AST.Statement({
+      new AST.SelectStatement({
         arguments: [
           new AST.Identifier("a"),
           new AST.Number(5),
         ],
-        type: AST.StatementType.SELECT,
+      }),
+    ]);
+  });
+
+  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"),
       }),
     ]);
   });