Parse binary expressions

src/ast.ts

 import { Alias } from "./ast/alias";
+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/binary";
 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;
-export type Expr = Secondary;
+export type Expr = Secondary | Binary;

src/ast/binary.ts

+import * as AST from "../ast";
+
+export enum BinaryExpressionTypes {
+  ADDITION,
+  SUBTRACTION,
+  MULTIPLICATION,
+  DIVISION,
+  EQUALITY,
+}
+
+interface IBinaryOptions {
+  type: BinaryExpressionTypes;
+  left: AST.Expr;
+  right: AST.Expr;
+}
+
+export class Binary {
+  public type: BinaryExpressionTypes;
+  public left: AST.Expr;
+  public right: AST.Expr;
+
+  constructor(opts: IBinaryOptions) {
+    this.type = opts.type;
+    this.left = opts.left;
+    this.right = opts.right;
+  }
+}

src/lexer.ts

     } 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.PLUS, null, this.line);
+    } else if (source.match(/^-/)) {
+      this.advance();
+      return new Token(TokenKind.MINUS, null, this.line);
     } else if (source.match(/^\*/)) {
       this.advance();
       return new Token(TokenKind.STAR, null, this.line);
+    } else if (source.match(/^\//)) {
+      this.advance();
+      return new Token(TokenKind.SLASH, null, this.line);
     } else if (source.match(/^=/)) {
       this.advance();
       return new Token(TokenKind.EQUALS, null, this.line);

src/parser.ts

       return args;
     }
 
-    const from = this.currentToken().kind === TokenKind.FROM ? this.from() : null;
+    const from = this.match(TokenKind.FROM) ? this.from() : null;
     if (isError(from)) {
       return from;
     }
 
-    const where = this.currentToken().kind === TokenKind.WHERE ? this.where() : null;
+    const where = this.match(TokenKind.WHERE) ? this.where() : null;
     if (isError(where)) {
       return where;
     }
       }
       args.push(arg);
 
-      if (this.currentToken().kind === TokenKind.COMMA) {
+      if (this.match(TokenKind.COMMA)) {
         this.eat(TokenKind.COMMA);
       } else {
         break;
   }
 
   private expr(): AST.Expr | Error {
-    return this.alias();
+    return this.equality();
+  }
+
+  private equality(): AST.Expr | Error {
+    const left = this.addition();
+    if (isError(left)) {
+      return left;
+    }
+
+    if (this.match(TokenKind.EQUALS)) {
+      this.eat(TokenKind.EQUALS);
+      const right = this.addition();
+      if (isError(right)) {
+        return right;
+      }
+
+      return new AST.Binary({
+        left,
+        right,
+        type: AST.BinaryExpressionTypes.EQUALITY,
+      });
+    }
+
+    return left;
+  }
+
+  private addition(): AST.Expr | Error {
+    const left = this.multiplication();
+    if (isError(left)) {
+      return left;
+    }
+
+    if (this.match(TokenKind.PLUS)) {
+      this.eat(TokenKind.PLUS);
+      const right = this.multiplication();
+      if (isError(right)) {
+        return right;
+      }
+
+      return new AST.Binary({
+        left,
+        right,
+        type: AST.BinaryExpressionTypes.ADDITION,
+      });
+    }
+
+    if (this.match(TokenKind.MINUS)) {
+      this.eat(TokenKind.MINUS);
+      const right = this.multiplication();
+      if (isError(right)) {
+        return right;
+      }
+
+      return new AST.Binary({
+        left,
+        right,
+        type: AST.BinaryExpressionTypes.SUBTRACTION,
+      });
+    }
+
+    return left;
+  }
+
+  private multiplication(): AST.Expr | Error {
+    const left = this.primary();
+    if (isError(left)) {
+      return left;
+    }
+
+    if (this.match(TokenKind.STAR)) {
+      this.eat(TokenKind.STAR);
+      const right = this.primary();
+      if (isError(right)) {
+        return right;
+      }
+
+      return new AST.Binary({
+        left,
+        right,
+        type: AST.BinaryExpressionTypes.MULTIPLICATION,
+      });
+    }
+
+    if (this.match(TokenKind.SLASH)) {
+      this.eat(TokenKind.SLASH);
+      const right = this.primary();
+      if (isError(right)) {
+        return right;
+      }
+
+      return new AST.Binary({
+        left,
+        right,
+        type: AST.BinaryExpressionTypes.DIVISION,
+      });
+    }
+
+    return left;
   }
 
   private alias(fn: () => AST.Primary | Error = this.primary): AST.Secondary | Error {
       return primary;
     }
 
-    if (this.currentToken().kind === TokenKind.AS) {
+    if (this.match(TokenKind.AS)) {
       this.eat(TokenKind.AS);
       const name = this.identifier();
       if (isError(name)) {
     return new Error(`Unexpected token: ${repr}`, token.line);
   }
 
+  private match(kind: TokenKind): boolean {
+    return this.currentToken().kind === kind;
+  }
+
   private currentToken(): Token {
     return this.tokens[this.position];
   }
   }
 
   private atEnd(): boolean {
-    return this.currentToken().kind === TokenKind.EOF;
+    return this.match(TokenKind.EOF);
   }
 }

src/token.ts

   EQUALS = "EQUALS",
   FROM = "FROM",
   IDENTIFIER = "IDENTIFIER",
+  MINUS = "MINUS",
   NUMBER = "NUMBER",
+  PLUS = "PLUS",
   SELECT = "SELECT",
   SEMICOLON = "SEMICOLON",
+  SLASH = "SLASH",
   STAR = "STAR",
   WHERE = "WHERE",
 }

test/lexer.test.ts

   });
 
   it("scans symbols", () => {
-    const tokens = scan("*=,`;.");
+    const tokens = scan("=,`;.+-*/");
     expect(tokens).to.deep.equal([
-      new Token(TokenKind.STAR, null, 1),
       new Token(TokenKind.EQUALS, null, 1),
       new Token(TokenKind.COMMA, null, 1),
       new Token(TokenKind.BACKTICK, null, 1),
       new Token(TokenKind.SEMICOLON, null, 1),
       new Token(TokenKind.DOT, null, 1),
+      new Token(TokenKind.PLUS, null, 1),
+      new Token(TokenKind.MINUS, null, 1),
+      new Token(TokenKind.STAR, null, 1),
+      new Token(TokenKind.SLASH, null, 1),
       new Token(TokenKind.EOF, null, 1),
     ]);
   });

test/parser.test.ts

       }),
     ]);
   });
+
+  it("should parse a where with an equality", () => {
+    const tree = parse("select a from b where c = d");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [new AST.Identifier("a")],
+        from: new AST.Identifier("b"),
+        where: new AST.Binary({
+          left: new AST.Identifier("c"),
+          right: new AST.Identifier("d"),
+          type: AST.BinaryExpressionTypes.EQUALITY,
+        }),
+      }),
+    ]);
+  });
+
+  it("should parse a where with an addition", () => {
+    const tree = parse("select a from b where c + d");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [new AST.Identifier("a")],
+        from: new AST.Identifier("b"),
+        where: new AST.Binary({
+          left: new AST.Identifier("c"),
+          right: new AST.Identifier("d"),
+          type: AST.BinaryExpressionTypes.ADDITION,
+        }),
+      }),
+    ]);
+  });
+
+  it("should parse a where with a subtraction", () => {
+    const tree = parse("select a from b where c - d");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [new AST.Identifier("a")],
+        from: new AST.Identifier("b"),
+        where: new AST.Binary({
+          left: new AST.Identifier("c"),
+          right: new AST.Identifier("d"),
+          type: AST.BinaryExpressionTypes.SUBTRACTION,
+        }),
+      }),
+    ]);
+  });
+
+  it("should parse a where with a multiplication", () => {
+    const tree = parse("select a from b where c * d");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [new AST.Identifier("a")],
+        from: new AST.Identifier("b"),
+        where: new AST.Binary({
+          left: new AST.Identifier("c"),
+          right: new AST.Identifier("d"),
+          type: AST.BinaryExpressionTypes.MULTIPLICATION,
+        }),
+      }),
+    ]);
+  });
+
+  it("should parse a where with a division", () => {
+    const tree = parse("select a from b where c / d");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [new AST.Identifier("a")],
+        from: new AST.Identifier("b"),
+        where: new AST.Binary({
+          left: new AST.Identifier("c"),
+          right: new AST.Identifier("d"),
+          type: AST.BinaryExpressionTypes.DIVISION,
+        }),
+      }),
+    ]);
+  });
+
+  it("should parse a where with a complex binary expression", () => {
+    const tree = parse("select a from b where c + d = e");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [new AST.Identifier("a")],
+        from: new AST.Identifier("b"),
+        where: new AST.Binary({
+          left: new AST.Binary({
+            left: new AST.Identifier("c"),
+            right: new AST.Identifier("d"),
+            type: AST.BinaryExpressionTypes.ADDITION,
+          }),
+          right: new AST.Identifier("e"),
+          type: AST.BinaryExpressionTypes.EQUALITY,
+        }),
+      }),
+    ]);
+  });
 });