Allow dot expressions

src/ast.ts

 export * from "./ast/number";
 export * from "./ast/selectStatement";
 
-export type Primary = _Number | Identifier | Backtick;
-export type Secondary = Primary | Alias;
+export type Primary = _Number | Identifier | Backtick | Alias;
 export type Statement = SelectStatement;
-export type Expr = Secondary | Binary;
+export type Expr = Primary | Binary;
+export type FromTarget = Identifier | Backtick | Alias;

src/ast/alias.ts

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

src/ast/binary.ts

   ADDITION = "ADDITION",
   AND = "AND",
   DIVISION = "DIVISION",
+  DOT = "DOT",
   EQUALITY = "EQUALITY",
   MULTIPLICATION = "MULTIPLICATION",
   OR = "OR",

src/ast/selectStatement.ts

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

src/parser.ts

         return this.select();
     }
 
-    return new Error(`Unexpected token ${token.kind}`, token.line);
+    return new Error(`Unexpected token: ${token.repr()}`, token.line);
   }
 
   private select(): AST.Statement | Error {
     });
   }
 
-  private args(): AST.Secondary[] | Error {
+  private args(): AST.Expr[] | Error {
     const args = [];
 
     while (true) {
-      const arg = this.alias();
+      const arg = this.expr();
       if (isError(arg)) {
         return arg;
       }
     return args;
   }
 
-  private from(): AST.Secondary | Error {
+  private from(): AST.FromTarget | Error {
     this.eat(TokenKind.FROM);
 
-    if (this.match(TokenKind.BACKTICK)) {
-      return this.alias(this.backtick);
+    return this.fromTarget();
+  }
+
+  private fromTarget(): AST.FromTarget | Error {
+    const token = this.currentToken();
+    switch (token.kind) {
+      case TokenKind.BACKTICK:
+        const backtick = this.backtick();
+        if (isError(backtick)) {
+          return backtick;
+        }
+
+        if (this.match(TokenKind.AS)) {
+          return this.fromTargetAlias(backtick);
+        }
+
+        return backtick;
+      case TokenKind.IDENTIFIER:
+        const identifier = this.identifier();
+        if (isError(identifier)) {
+          return identifier;
+        }
+
+        if (this.match(TokenKind.AS)) {
+          return this.fromTargetAlias(identifier);
+        }
+
+        return identifier;
     }
 
-    return this.alias(this.identifier);
+    return new Error(`Unexpected token: ${token.repr()}`, token.line);
+  }
+
+  private fromTargetAlias(obj: AST.Identifier | AST.Backtick): AST.Alias | Error {
+    this.eat(TokenKind.AS);
+
+    const token = this.currentToken();
+    const alias = this.match(TokenKind.BACKTICK)
+      ? this.backtick()
+      : this.match(TokenKind.IDENTIFIER)
+        ? this.identifier()
+        : new Error(`Unexpected token: ${token.repr()}`, token.line);
+
+    if (isError(alias)) {
+      return alias;
+    }
+
+    return new AST.Alias(obj, alias);
   }
 
   private where(): AST.Expr | Error {
 
     if (this.match(TokenKind.STAR)) {
       this.eat(TokenKind.STAR);
-      const right = this.primary();
+      const right = this.alias();
       if (isError(right)) {
         return right;
       }
 
     if (this.match(TokenKind.SLASH)) {
       this.eat(TokenKind.SLASH);
-      const right = this.primary();
+      const right = this.alias();
       if (isError(right)) {
         return right;
       }
     return left;
   }
 
-  private alias(fn: () => AST.Primary | Error = this.primary): AST.Secondary | Error {
-    const primary = fn.bind(this)();
+  private alias(): AST.Expr | Error {
+    const primary = this.primary();
     if (isError(primary)) {
       return primary;
     }
     return primary;
   }
 
-  private primary(): AST.Primary | Error {
+  private primary(): AST.Expr | Error {
     const token = this.currentToken();
-    switch (token.kind) {
-      case TokenKind.NUMBER:
-        return this.number();
-      case TokenKind.IDENTIFIER:
-        return this.identifier();
-      case TokenKind.BACKTICK:
-        return this.backtick();
+
+    const primary = (() => {
+      switch (token.kind) {
+        case TokenKind.NUMBER:
+          return this.number();
+        case TokenKind.IDENTIFIER:
+          return this.identifier();
+        case TokenKind.BACKTICK:
+          return this.backtick();
+        default:
+          return new Error(`Unexpected token: ${token.repr()}`, token.line);
+      }
+    })();
+
+    if (isError(primary)) {
+      return primary;
     }
 
-    return new Error(
-      `Unexpected token ${token.kind} ${token.value}`,
-      token.line,
-    );
+    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);
+    } else if (this.match(TokenKind.DOT)) {
+      this.eat(TokenKind.DOT);
+
+      const right = this.match(TokenKind.BACKTICK) ? this.backtick() : this.identifier();
+      if (isError(right)) {
+        return right;
+      }
+
+      return new AST.Binary({
+        left: primary,
+        right,
+        type: AST.BinaryExpressionTypes.DOT,
+      });
+    }
+
+    return primary;
   }
 
   private backtick(): AST.Backtick | Error {
       return token;
     }
 
-    const repr = `{ kind: ${token.kind}${token.value ? `, value: ${token.value} }` : " }"}`;
-
-    return new Error(`Unexpected token: ${repr}`, token.line);
+    return new Error(`Unexpected token: ${token.repr()}`, token.line);
   }
 
   private match(kind: TokenKind): boolean {

src/token.ts

     this.value = value;
     this.line = line;
   }
+
+  public repr(): string {
+    return `{ kind: ${this.kind}${this.value ? `, value: ${this.value} }` : " }"}`;
+  }
 }

test/parser.test.ts

       }),
     ]);
   });
+
+  it("should parse expressions as select arguments", () => {
+    const tree = parse("select a = b");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [
+          new AST.Binary({
+            left: new AST.Identifier("a"),
+            right: new AST.Identifier("b"),
+            type: AST.BinaryExpressionTypes.EQUALITY,
+          }),
+        ],
+      }),
+    ]);
+  });
+
+  it("should parse dot operators", () => {
+    const tree = parse("select a.b");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [
+          new AST.Binary({
+            left: new AST.Identifier("a"),
+            right: new AST.Identifier("b"),
+            type: AST.BinaryExpressionTypes.DOT,
+          }),
+        ],
+      }),
+    ]);
+  });
 });