Merge pull request #3 from FSou1/feature/introduce-where-statement

Feature/introduce where statement

Author: FSou1

README.md

@@ -63,17 +63,25 @@ export interface IDirEntry {
 }
 ```
 
-## Example queries
+## Queries
+
+### Supported 
 
 `select * from .`
 
 `select * from root`
 
 `select * from root/sub-a`
 
-## TODO
+`select * from root where size > 1000000`
+
+`select * from root where size < 1000000`
+
+`select * from root where size = 1000000`
+
+`select * from root where size <> 1000000`
 
-`select * from root where size > 0`
+### TODO
 
 `select * from root where isDirectory = true`
 

deps.ts

@@ -5,4 +5,6 @@ export {
 export {
   assert,
   assertExists,
+  assertEquals,
+  assertThrows
 } from "https://deno.land/std@0.82.0/testing/asserts.ts";

docs/grammar.peg

@@ -1,3 +1,11 @@
+/**
+ * Grammar for validating simple SQL selects.
+ * @author Marcelo Camargo
+ * @since 2015/08/26
+ * 
+ * 2021/04/16: Add '>' and '<' operators (github/FSou1)
+ */
+
 {
   var Sql = {
     listToString: function(x, xs) {
@@ -8,52 +16,153 @@
 
 Start
   = Stmt
-  
+
 Stmt
   = SelectStmt
-  
+
+/* Statements */
+
 SelectStmt
-  = SelectToken
-  _ x:SelectField xs:SelectFieldRest*
-  _ FromToken 
-  _ from:Identifier {
-       return {
-         type: "select",
-         fields: [x].concat(xs),
-         from: from
-       };
-    }
-  
-SelectToken
-  = "select"
+  = _ SelectToken
+    _ x:SelectField xs:SelectFieldRest*
+    _ FromToken
+    _ from:Identifier
+    _ where:WhereExpr? {
+    return {
+      type: "SELECT",
+      fields: [x].concat(xs),
+      from: from,
+      where: where
+    };
+  }
 
-SeparatorToken
-  = ","
-  
-FromToken
-  = "from"
-  
 SelectField "select valid field"
-  = "*"
+  = Identifier
+  / "*"
 
 SelectFieldRest
-  = SeparatorToken _ s:SelectField {
+  = _ SeparatorToken _ s:SelectField {
     return s;
   }
 
+WhereExpr "where expression"
+  = WhereToken x:LogicExpr xs:LogicExprRest* {
+    return {
+      conditions: [x].concat(xs)
+    };
+  }
+
+LogicExpr
+  = _ "(" _ x:LogicExpr xs:LogicExprRest* _ ")" _ {
+    return [x].concat(xs);
+  }
+  / _ left:Expr _ op:Operator _ right:Expr _ {
+    return {
+      left: left,
+      op: op,
+      right: right
+    };
+  }
+
+LogicExprRest
+  = _ j:Joiner _ l:LogicExpr {
+    return {
+      joiner: j,
+      expression: l
+    };
+  }
+
+Joiner "joiner"
+  = OrToken  { return "Or";  }
+  / AndToken { return "And"; }
+
+Operator
+  = "<>"       { return "Different";     }
+  / ">"        { return "GreaterThan";   }
+  / "<"        { return "LessThan";      }
+  / "="        { return "Equal";         }
+  / LikeToken  { return "Like";          }
+
+/* Expressions */
+
+Expr
+  = Float
+  / Integer
+  / Identifier
+  / String
+
+Integer "integer"
+  = n:[0-9]+ {
+    return parseInt(n.join(""));
+  }
+
+Float "float"
+  = left:Integer "." right:Integer {
+    return parseFloat([
+      left.toString(),
+      right.toString()
+    ].join("."));
+  }
+
+String "string"
+  = "'" str:ValidStringChar* "'" {
+    return str.join("");
+  }
+
+ValidStringChar
+  = !"'" c:. {
+    return c;
+  }
+
+/* Tokens */
+
+SelectToken
+  = "SELECT"i !IdentRest
+
+SeparatorToken
+  = ","
+
+FromToken
+  = "FROM"i !IdentRest
+
+WhereToken
+  = "WHERE"i !IdentRest
+
+LikeToken
+  = "LIKE"i !IdentRest
+
+OrToken
+  = "OR"i !IdentRest
+
+AndToken
+  = "AND"i !IdentRest
+
+/* Identifier */
+
 Identifier "identifier"
   = x:IdentStart xs:IdentRest* {
     return Sql.listToString(x, xs);
   }
-  
+
 IdentStart
   = [a-z_./]i
-  
+
 IdentRest
   = [a-z0-9_/-]i
 
+/* Skip */
 _
-  = ( WhiteSpace )
-  
+  = ( WhiteSpace / NewLine )*
+
+NewLine "newline"
+  = "\r\n"
+  / "\r"
+  / "\n"
+  / "\u2028"
+  / "\u2029"
+
 WhiteSpace "whitespace"
-  = " "
+  = " "
+  / "\t"
+  / "\v"
+  / "\f"

mod_test.ts

@@ -4,15 +4,21 @@ import { fsselect } from "./mod.ts";
 
 Deno.test("if 'select * from .' works", async () => {
   const result = await fsselect("select * from .");
-  assert(result.length === 16);
+  assert(result.length === 18);
 });
 
 Deno.test("if 'select * from root' works", async () => {
   const result = await fsselect("select * from root");
-  assert(result.length === 3);
+  assert(result.length === 4);
 });
 
 Deno.test("if 'select * from root/test_folder_with_file' works", async () => {
   const result = await fsselect("select * from root/test_folder_with_file");
   assert(result.length === 1);
 });
+
+Deno.test("if 'select * from root/test_folder_with_files where size > 1000000' works", async () => {
+  const result = await fsselect("select * from root/test_folder_with_files where size > 1000000");
+  assert(result.length === 1);
+  assert(result[0].name === 'b-file-1MB.txt');
+});