Parse backticks

src/ast.ts

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

src/ast/alias.ts

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

src/ast/backtick.ts

+import * as AST from "../ast";
+
+export class Backtick {
+  public value: AST.Identifier;
+
+  constructor(value: AST.Identifier) {
+    this.value = value;
+  }
+}

src/parser.ts

 
   private from(): AST.Secondary | Error {
     this.eat(TokenKind.FROM);
+
+    if (this.match(TokenKind.BACKTICK)) {
+      return this.alias(this.backtick);
+    }
+
     return this.alias(this.identifier);
   }
 
 
     if (this.match(TokenKind.AS)) {
       this.eat(TokenKind.AS);
-      const name = this.identifier();
+
+      const name = this.match(TokenKind.BACKTICK) ? this.backtick() : this.identifier();
+
       if (isError(name)) {
         return name;
       }
+
       return new AST.Alias(primary, name);
     }
 
         return this.number();
       case TokenKind.IDENTIFIER:
         return this.identifier();
+      case TokenKind.BACKTICK:
+        return this.backtick();
     }
 
     return new Error(
     );
   }
 
+  private backtick(): AST.Backtick | Error {
+    this.eat(TokenKind.BACKTICK);
+    const identifier = this.identifier();
+    if (isError(identifier)) {
+      return identifier;
+    }
+
+    const closeTick = this.eat(TokenKind.BACKTICK);
+    if (isError(closeTick)) {
+      return closeTick;
+    }
+
+    return new AST.Backtick(identifier);
+  }
+
   private identifier(): AST.Identifier | Error {
     const identifier = this.eat(TokenKind.IDENTIFIER);
     if (isError(identifier)) {
       return token;
     }
 
-    const repr = `{ kind: ${token.kind}${token.value ? `, value: ${token.value} }` : ""}`;
+    const repr = `{ kind: ${token.kind}${token.value ? `, value: ${token.value} }` : " }"}`;
 
     return new Error(`Unexpected token: ${repr}`, token.line);
   }

test/parser.test.ts

       }),
     ]);
   });
+
+  it("should parse backticked column names", () => {
+    const tree = parse("select `a` from b");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [new AST.Backtick(new AST.Identifier("a"))],
+        from: new AST.Identifier("b"),
+      }),
+    ]);
+  });
+
+  it("should not allow unbalanced backticks", () => {
+    const fn = () => parse("select `a from b");
+    expect(fn).to.throw("Unexpected token: { kind: FROM }");
+  });
+
+  it("should parse backticked FROM targets", () => {
+    const tree = parse("select a from `b`");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [new AST.Identifier("a")],
+        from: new AST.Backtick(new AST.Identifier("b")),
+      }),
+    ]);
+  });
+
+  it("should parse backticked aliases", () => {
+    const tree = parse("select a as `b`");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [new AST.Alias(new AST.Identifier("a"), new AST.Backtick(new AST.Identifier("b")))],
+      }),
+    ]);
+  });
+
+  it("should parse backticked aliases", () => {
+    const tree = parse("select a as `b`");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [new AST.Alias(new AST.Identifier("a"), new AST.Backtick(new AST.Identifier("b")))],
+      }),
+    ]);
+  });
+
+  it("should parse backticked where operands", () => {
+    const tree = parse("select a where `b` = `c`");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [new AST.Identifier("a")],
+        where: new AST.Binary({
+          left: new AST.Backtick(new AST.Identifier("b")),
+          right: new AST.Backtick(new AST.Identifier("c")),
+          type: AST.BinaryExpressionTypes.EQUALITY,
+        }),
+      }),
+    ]);
+  });
 });