Parse *

src/ast.ts

 import { Identifier } from "./ast/identifier";
 import { Number as _Number } from "./ast/number";
 import { SelectStatement } from "./ast/selectStatement";
+import { Star } from "./ast/star";
 
 export * from "./ast/alias";
 export * from "./ast/backtick";
 export * from "./ast/identifier";
 export * from "./ast/number";
 export * from "./ast/selectStatement";
+export * from "./ast/star";
 
 export type Primary = _Number | Identifier | Backtick | Alias;
 export type Statement = SelectStatement;
 export type Expr = Primary | Binary;
-export type SelectArgument = Expr;
+export type SelectArgument = Expr | Star;
 export type FromTarget = Identifier | Backtick | Alias | SelectStatement;

src/ast/binary.ts

 interface IBinaryOptions {
   type: BinaryExpressionTypes;
   left: AST.Expr;
-  right: AST.Expr;
+  right: AST.Expr | AST.Star;
 }
 
 export class Binary {
   public type: BinaryExpressionTypes;
   public left: AST.Expr;
-  public right: AST.Expr;
+  public right: AST.Expr | AST.Star;
 
   constructor(opts: IBinaryOptions) {
     this.type = opts.type;

src/ast/selectStatement.ts

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

src/ast/star.ts

+export class Star {}

src/parser.ts

     const args = [];
 
     while (true) {
-      const arg = this.expr();
-      if (isError(arg)) {
-        return arg;
+      if (this.match(TokenKind.STAR)) {
+        this.eat(TokenKind.STAR);
+        args.push(new AST.Star());
+      } else if (this.match(TokenKind.IDENTIFIER) && this.peek_match(TokenKind.DOT)) {
+        const left = this.identifier();
+        if (isError(left)) {
+          return left;
+        }
+        const right = this.selectArgumentDotExpression(left);
+        if (isError(right)) {
+          return right;
+        }
+        args.push(right);
+      } else if (this.match(TokenKind.BACKTICK) && this.peek_match(TokenKind.DOT, 3)) {
+        const left = this.backtick();
+        if (isError(left)) {
+          return left;
+        }
+        const right = this.selectArgumentDotExpression(left);
+        if (isError(right)) {
+          return right;
+        }
+        args.push(right);
+      } else {
+        const arg = this.expr();
+        if (isError(arg)) {
+          return arg;
+        }
+        args.push(arg);
       }
-      args.push(arg);
 
       if (this.match(TokenKind.COMMA)) {
         this.eat(TokenKind.COMMA);
     return args;
   }
 
+  private selectArgumentDotExpression(left: AST.Identifier | AST.Backtick): AST.Expr | Error {
+    this.eat(TokenKind.DOT);
+
+    if (this.match(TokenKind.STAR)) {
+      this.eat(TokenKind.STAR);
+      const right = new AST.Star();
+      return new AST.Binary({ left, right, type: AST.BinaryExpressionTypes.DOT });
+    } else {
+      const right = this.expr();
+      if (isError(right)) {
+        return right;
+      }
+      return new AST.Binary({ left, right, type: AST.BinaryExpressionTypes.DOT });
+    }
+  }
+
   private from(): AST.FromTarget | Error {
     this.eat(TokenKind.FROM);
     return this.fromTarget();
     return this.currentToken().kind === kind;
   }
 
+  private peek_match(kind: TokenKind, step: number = 1): boolean {
+    const token = this.tokens[this.position + step];
+    return token && token.kind === kind;
+  }
+
   private currentToken(): Token {
     return this.tokens[this.position];
   }

test/parser.test.ts

       }),
     ]);
   });
+
+  it("should parse SELECT *", () => {
+    const tree = parse("select *");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [
+          new AST.Star(),
+        ],
+      }),
+    ]);
+  });
+
+  it("should parse * on the right hand side of a dot in a SELECT", () => {
+    const tree = parse("select a.*");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [
+          new AST.Binary({
+            left: new AST.Identifier("a"),
+            right: new AST.Star(),
+            type: AST.BinaryExpressionTypes.DOT,
+          }),
+        ],
+      }),
+    ]);
+  });
+
+  it("should parse * on the right of a dot where the left is a backtick", () => {
+    const tree = parse("select `a`.*");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [
+          new AST.Binary({
+            left: new AST.Backtick(new AST.Identifier("a")),
+            right: new AST.Star(),
+            type: AST.BinaryExpressionTypes.DOT,
+          }),
+        ],
+      }),
+    ]);
+  });
+
+  it("should not allow stars in arithmetic operations", () => {
+    expect(() => parse("select 1 + *")).to.throw("Unexpected token: { kind: STAR }");
+    expect(() => parse("select 1 + a.*")).to.throw("Unexpected token: { kind: STAR }");
+    expect(() => parse("select * + 1")).to.throw("Unexpected token: { kind: PLUS }");
+    expect(() => parse("select a.* + b.*")).to.throw("Unexpected token: { kind: PLUS }");
+    expect(() => parse("select a from b where c.*")).to.throw("Unexpected token: { kind: STAR }");
+  });
 });