Parse chained AND and OR

src/parser.ts

@@ -96,18 +96,19 @@ export default class Parser {
   }
 
   private or(): AST.Expr | Error {
-    const left = this.and();
+    let left = this.and();
     if (isError(left)) {
       return left;
     }
 
-    if (this.match(TokenKind.OR)) {
+    while (this.match(TokenKind.OR)) {
       this.eat(TokenKind.OR);
       const right = this.and();
       if (isError(right)) {
         return right;
       }
-      return new AST.Binary({
+
+      left = new AST.Binary({
         left,
         right,
         type: AST.BinaryExpressionTypes.OR,
@@ -118,18 +119,19 @@ export default class Parser {
   }
 
   private and(): AST.Expr | Error {
-    const left = this.equality();
+    let left = this.equality();
     if (isError(left)) {
       return left;
     }
 
-    if (this.match(TokenKind.AND)) {
+    while (this.match(TokenKind.AND)) {
       this.eat(TokenKind.AND);
       const right = this.equality();
       if (isError(right)) {
         return right;
       }
-      return new AST.Binary({
+
+      left = new AST.Binary({
         left,
         right,
         type: AST.BinaryExpressionTypes.AND,

test/parser.test.ts

@@ -222,4 +222,42 @@ describe("Parser", () => {
       }),
     ]);
   });
+
+  it("should parse chained ANDs", () => {
+    const tree = parse("select a from b where c and d and 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.AND,
+          }),
+          right: new AST.Identifier("e"),
+          type: AST.BinaryExpressionTypes.AND,
+        }),
+      }),
+    ]);
+  });
+
+  it("should parse chained ORs", () => {
+    const tree = parse("select a from b where c or d or 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.OR,
+          }),
+          right: new AST.Identifier("e"),
+          type: AST.BinaryExpressionTypes.OR,
+        }),
+      }),
+    ]);
+  });
 });