Merge pull request #14 from FSou1/feature/6-where-name-eq-value

#6 Implement the filter by name

Author: FSou1

README.md

@@ -83,10 +83,10 @@ The list of supported operators: `>`, `<`, `=`, `<>`.
 
 `select * from root where isFile <> false`
 
-### TODO
-
 `select * from root where name = 'root.txt'`
 
+### TODO
+
 `select * from root where name like '%txt'`
 
 `select * from root where name like '%txt%'`

mod_test.ts

@@ -107,4 +107,44 @@ Deno.test("if 'select * from root where isFile <> false' works", async () => {
   assertEquals(result[0].name, "root.txt");
   assertEquals(result[0].isDirectory, false);
   assertEquals(result[0].isFile, true);
+});
+
+Deno.test("if select * from root where name = 'test_folder_with_file' works", async () => {
+  const result = await fsselect("select * from root where name = 'test_folder_with_file'");
+  assert(result.length === 1);
+  assertEquals(result[0].name, "test_folder_with_file");
+  assertEquals(result[0].isDirectory, true);
+});
+
+Deno.test("if select * from root where name = 'root.txt' works", async () => {
+  const result = await fsselect("select * from root where name = 'root.txt'");
+  assert(result.length === 1);
+  assertEquals(result[0].name, "root.txt");
+  assertEquals(result[0].isFile, true);
+});
+
+Deno.test("if select * from root where name <> 'test_folder_with_file' works", async () => {
+  const result = await fsselect("select * from root where name <> 'test_folder_with_file'");
+  assert(result.length === 3);
+
+  const names = result.map((i) => i.name as string);
+  const expectedNames = [
+    "root.txt",
+    "test_folder_with_files",
+    "test_folder_with_folder",
+  ];
+  assertArrayIncludes<string>(names, expectedNames);
+});
+
+Deno.test("if select * from root where name <> 'root.txt' works", async () => {
+  const result = await fsselect("select * from root where name <> 'root.txt'");
+  assert(result.length === 3);
+
+  const names = result.map((i) => i.name as string);
+  const expectedNames = [
+    "test_folder_with_file",
+    "test_folder_with_files",
+    "test_folder_with_folder",
+  ];
+  assertArrayIncludes<string>(names, expectedNames);
 });

select_test.ts

@@ -309,3 +309,114 @@ Deno.test("if 3 folders are returned when the where clause has isFile <> true",
   ];
   assertArrayIncludes<string>(names, expectedNames);
 });
+
+Deno.test("if the 'root.txt' is returned when the where clause has name = 'root.txt'", async () => {
+  const query: IQuery = {
+    type: "select",
+    fields: ["*"],
+    from: "root",
+    where: {
+      conditions: [
+        {
+          left: "name",
+          op: "Equal",
+          right: "root.txt",
+        },
+      ],
+    },
+  };
+
+  const result = await select(query);
+
+  assert(result.length === 1);
+  assertEquals(result[0].name, "root.txt");
+  assertEquals(result[0].isDirectory, false);
+  assertEquals(result[0].isFile, true);
+});
+
+Deno.test("if a folder is returned when the where clause has name = 'test_folder_with_folder'", async () => {
+  const query: IQuery = {
+    type: "select",
+    fields: ["*"],
+    from: "root",
+    where: {
+      conditions: [
+        {
+          left: "name",
+          op: "Equal",
+          right: "test_folder_with_folder",
+        },
+      ],
+    },
+  };
+
+  const result = await select(query);
+
+  assert(result.length === 1);
+  assertEquals(result[0].name, "test_folder_with_folder");
+  assertEquals(result[0].isDirectory, true);
+  assertEquals(result[0].isFile, false);
+});
+
+
+
+
+
+
+
+
+Deno.test("if the 'root.txt' is not returned when the where clause has name <> 'root.txt'", async () => {
+  const query: IQuery = {
+    type: "select",
+    fields: ["*"],
+    from: "root",
+    where: {
+      conditions: [
+        {
+          left: "name",
+          op: "Different",
+          right: "root.txt",
+        },
+      ],
+    },
+  };
+
+  const result = await select(query);
+
+  assert(result.length === 3);
+  const names = result.map((i) => i.name as string);
+  const expectedNames = [
+    "test_folder_with_file",
+    "test_folder_with_files",
+    "test_folder_with_folder",
+  ];
+  assertArrayIncludes<string>(names, expectedNames);
+});
+
+Deno.test("if a folder is returned when the where clause has name <> 'test_folder_with_folder'", async () => {
+  const query: IQuery = {
+    type: "select",
+    fields: ["*"],
+    from: "root",
+    where: {
+      conditions: [
+        {
+          left: "name",
+          op: "Different",
+          right: "test_folder_with_folder",
+        },
+      ],
+    },
+  };
+
+  const result = await select(query);
+
+  assert(result.length === 3);
+  const names = result.map((i) => i.name as string);
+  const expectedNames = [
+    "test_folder_with_file",
+    "test_folder_with_files",
+    "root.txt",
+  ];
+  assertArrayIncludes<string>(names, expectedNames);
+});

where.ts

@@ -34,7 +34,7 @@ function meet(entry: IDirEntry, condition: IWhereCondition): boolean {
       );
     }
 
-    return operation(entry.size, <number>right);
+    return operation(entry.size, <number> right);
   } else if (left === "isDirectory") {
     const operations = {
       "GreaterThan": null,
@@ -69,6 +69,23 @@ function meet(entry: IDirEntry, condition: IWhereCondition): boolean {
     }
 
     return operation(entry.isFile, JSON.parse(right as string));
+  } else if (left === "name") {
+    const operations = {
+      "GreaterThan": null,
+      "LessThan": null,
+      "Equal": equalString,
+      "Different": differentString,
+      "Like": null,
+    };
+
+    const operation = operations[op];
+    if (!operation) {
+      throw new Error(
+        `The operation '${op}' is not supported for the '${left}' property`,
+      );
+    }
+
+    return operation(entry.name, right as string);
   }
 
   return false;
@@ -98,4 +115,13 @@ function equalBoolean(left: boolean | undefined, right: boolean): boolean {
 
 function differentBoolean(left: boolean | undefined, right: boolean): boolean {
   return typeof left !== "undefined" && left !== right;
-}
+}
+
+/* String */
+function equalString(left: string | undefined, right: string): boolean {
+  return typeof left !== "undefined" && left === right;
+}
+
+function differentString(left: string | undefined, right: string): boolean {
+  return typeof left !== "undefined" && left !== right;
+}