spice-couchbase 2.0.45 → 2.0.47

package/src/utility.test.js

@@ -0,0 +1,1017 @@
+"use strict";
+
+const assert = require("assert");
+const {
+  buildCoveringIndex,
+  extractWhereFields,
+  extractSelectFields,
+  extractGroupByFields,
+  extractOrderByFields,
+  generateHash,
+} = require("./utility");
+
+// Test utilities
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`✓ ${name}`);
+    passed++;
+  } catch (error) {
+    console.log(`✗ ${name}`);
+    console.log(`  Error: ${error.message}`);
+    failed++;
+  }
+}
+
+function arraysEqual(a, b) {
+  if (a.length !== b.length) return false;
+  const sortedA = [...a].sort();
+  const sortedB = [...b].sort();
+  return sortedA.every((val, i) => val === sortedB[i]);
+}
+
+// ============================================
+// Tests for generateHash
+// ============================================
+console.log("\n--- generateHash tests ---");
+
+test("generates 8 character hash", () => {
+  const hash = generateHash("test query");
+  assert.strictEqual(hash.length, 8);
+});
+
+test("generates consistent hash for same input", () => {
+  const hash1 = generateHash("SELECT * FROM users");
+  const hash2 = generateHash("SELECT * FROM users");
+  assert.strictEqual(hash1, hash2);
+});
+
+test("generates different hash for different input", () => {
+  const hash1 = generateHash("SELECT * FROM users");
+  const hash2 = generateHash("SELECT * FROM orders");
+  assert.notStrictEqual(hash1, hash2);
+});
+
+// ============================================
+// Tests for extractWhereFields
+// ============================================
+console.log("\n--- extractWhereFields tests ---");
+
+test("extracts simple equality field", () => {
+  const query = "SELECT name FROM users WHERE status = 'active'";
+  const fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+
+test("extracts multiple fields with AND", () => {
+  const query = "SELECT name FROM users WHERE status = 'active' AND type = 'admin'";
+  const fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["status", "type"]));
+});
+
+test("extracts fields with comparison operators", () => {
+  const query = "SELECT name FROM users WHERE age > 18 AND score <= 100";
+  const fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["age", "score"]));
+});
+
+test("extracts backtick-quoted fields", () => {
+  const query = "SELECT name FROM users WHERE `first_name` = 'John'";
+  const fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["first_name"]));
+});
+
+test("extracts fields with IN clause", () => {
+  const query = "SELECT name FROM users WHERE status IN ['active', 'pending']";
+  const fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+
+test("extracts fields with LIKE clause", () => {
+  const query = "SELECT name FROM users WHERE name LIKE '%john%'";
+  const fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["name"]));
+});
+
+test("extracts fields with IS MISSING", () => {
+  const query = "SELECT name FROM users WHERE deleted IS MISSING";
+  const fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["deleted"]));
+});
+
+test("extracts fields with IS NULL", () => {
+  const query = "SELECT name FROM users WHERE email IS NULL";
+  const fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["email"]));
+});
+
+test("extracts fields from LOWER function", () => {
+  const query = "SELECT name FROM users WHERE LOWER(email) = 'test@test.com'";
+  const fields = extractWhereFields(query);
+  assert.ok(fields.includes("email"));
+});
+
+test("returns empty array when no WHERE clause", () => {
+  const query = "SELECT name FROM users";
+  const fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, []));
+});
+
+test("handles deleted check pattern", () => {
+  const query = "SELECT name FROM users WHERE (deleted = false OR deleted IS MISSING) AND status = 'active'";
+  const fields = extractWhereFields(query);
+  assert.ok(fields.includes("deleted"));
+  assert.ok(fields.includes("status"));
+});
+
+test("stops at ORDER BY", () => {
+  const query = "SELECT name FROM users WHERE status = 'active' ORDER BY created_at";
+  const fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+  assert.ok(!fields.includes("created_at"));
+});
+
+test("stops at LIMIT", () => {
+  const query = "SELECT name FROM users WHERE status = 'active' LIMIT 10";
+  const fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+
+test("stops at OFFSET", () => {
+  const query = "SELECT name FROM users WHERE status = 'active' OFFSET 20";
+  const fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+
+test("handles type field (legacy pattern)", () => {
+  const query = "SELECT name FROM bucket WHERE type = 'user' AND status = 'active'";
+  const fields = extractWhereFields(query);
+  assert.ok(fields.includes("type"));
+  assert.ok(fields.includes("status"));
+});
+
+test("handles not equals operator !=", () => {
+  const query = "SELECT name FROM users WHERE status != 'deleted'";
+  const fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+
+test("handles not equals operator <>", () => {
+  const query = "SELECT name FROM users WHERE status <> 'deleted'";
+  const fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+
+test("handles BETWEEN clause", () => {
+  const query = "SELECT name FROM users WHERE age BETWEEN 18 AND 65";
+  const fields = extractWhereFields(query);
+  assert.ok(fields.includes("age"));
+});
+
+test("handles OR conditions", () => {
+  const query = "SELECT name FROM users WHERE status = 'active' OR status = 'pending'";
+  const fields = extractWhereFields(query);
+  assert.ok(fields.includes("status"));
+});
+
+test("handles nested parentheses", () => {
+  const query = "SELECT name FROM users WHERE ((status = 'active') AND (type = 'admin'))";
+  const fields = extractWhereFields(query);
+  assert.ok(fields.includes("status"));
+  assert.ok(fields.includes("type"));
+});
+
+test("handles complex deleted pattern with additional conditions", () => {
+  const query = `SELECT first_name, last_name FROM users 
+    WHERE (deleted = false OR deleted IS MISSING) 
+    AND status = 'active' 
+    AND type = 'user'
+    ORDER BY created_at`;
+  const fields = extractWhereFields(query);
+  assert.ok(fields.includes("deleted"));
+  assert.ok(fields.includes("status"));
+  assert.ok(fields.includes("type"));
+  assert.ok(!fields.includes("created_at")); // ORDER BY field should not be included
+});
+
+test("stops at GROUP BY", () => {
+  const query = "SELECT COUNT(status) FROM users WHERE type = 'admin' GROUP BY status";
+  const fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["type"]));
+});
+
+test("stops at HAVING", () => {
+  const query = "SELECT status FROM users WHERE type = 'admin' GROUP BY status HAVING COUNT(*) > 5";
+  const fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["type"]));
+});
+
+test("handles ANY array operator", () => {
+  const query = "SELECT name FROM users WHERE ANY tag IN tags SATISFIES tag = 'vip' END";
+  const fields = extractWhereFields(query);
+  assert.ok(fields.includes("tags"));
+});
+
+test("handles EVERY array operator", () => {
+  const query = "SELECT name FROM users WHERE EVERY score IN scores SATISFIES score > 50 END";
+  const fields = extractWhereFields(query);
+  assert.ok(fields.includes("scores"));
+});
+
+test("handles ANY with additional conditions", () => {
+  const query = "SELECT name FROM users WHERE status = 'active' AND ANY tag IN tags SATISFIES tag = 'premium' END";
+  const fields = extractWhereFields(query);
+  assert.ok(fields.includes("status"));
+  assert.ok(fields.includes("tags"));
+});
+
+test("handles EVERY with additional conditions", () => {
+  const query = "SELECT name FROM users WHERE type = 'user' AND EVERY item IN items SATISFIES item.quantity > 0 END";
+  const fields = extractWhereFields(query);
+  assert.ok(fields.includes("type"));
+  assert.ok(fields.includes("items"));
+});
+
+test("handles ANY with backtick-quoted array field", () => {
+  const query = "SELECT name FROM users WHERE ANY t IN `user_tags` SATISFIES t = 'admin' END";
+  const fields = extractWhereFields(query);
+  assert.ok(fields.includes("user_tags"));
+});
+
+test("handles multiple ANY clauses", () => {
+  const query = "SELECT name FROM users WHERE ANY t IN tags SATISFIES t = 'vip' END AND ANY r IN roles SATISFIES r = 'admin' END";
+  const fields = extractWhereFields(query);
+  assert.ok(fields.includes("tags"));
+  assert.ok(fields.includes("roles"));
+});
+
+test("handles ANY and EVERY together", () => {
+  const query = "SELECT name FROM users WHERE ANY t IN tags SATISFIES t = 'active' END AND EVERY s IN scores SATISFIES s >= 0 END";
+  const fields = extractWhereFields(query);
+  assert.ok(fields.includes("tags"));
+  assert.ok(fields.includes("scores"));
+});
+
+test("handles complex ANY with deleted pattern", () => {
+  const query = `SELECT name, email FROM users 
+    WHERE (deleted = false OR deleted IS MISSING) 
+    AND status = 'active' 
+    AND ANY tag IN tags SATISFIES tag = 'premium' END`;
+  const fields = extractWhereFields(query);
+  assert.ok(fields.includes("deleted"));
+  assert.ok(fields.includes("status"));
+  assert.ok(fields.includes("tags"));
+});
+
+// ============================================
+// Tests for extractSelectFields
+// ============================================
+console.log("\n--- extractSelectFields tests ---");
+
+test("extracts simple field", () => {
+  const query = "SELECT name FROM users";
+  const fields = extractSelectFields(query);
+  assert.ok(arraysEqual(fields, ["name"]));
+});
+
+test("extracts multiple fields", () => {
+  const query = "SELECT name, email, status FROM users";
+  const fields = extractSelectFields(query);
+  assert.ok(arraysEqual(fields, ["name", "email", "status"]));
+});
+
+test("returns null for SELECT *", () => {
+  const query = "SELECT * FROM users";
+  const fields = extractSelectFields(query);
+  assert.strictEqual(fields, null);
+});
+
+test("returns null for SELECT collection.*", () => {
+  const query = "SELECT users.* FROM users";
+  const fields = extractSelectFields(query);
+  assert.strictEqual(fields, null);
+});
+
+test("returns null for SELECT (bucket).* pattern", () => {
+  const query = "SELECT (`users`).*, META(`users`).id AS id FROM users";
+  const fields = extractSelectFields(query);
+  assert.strictEqual(fields, null);
+});
+
+test("extracts backtick-quoted fields", () => {
+  const query = "SELECT `first_name`, `last_name` FROM users";
+  const fields = extractSelectFields(query);
+  assert.ok(arraysEqual(fields, ["first_name", "last_name"]));
+});
+
+test("handles AS alias", () => {
+  const query = "SELECT first_name AS fname, last_name AS lname FROM users";
+  const fields = extractSelectFields(query);
+  assert.ok(arraysEqual(fields, ["first_name", "last_name"]));
+});
+
+test("skips META().id", () => {
+  const query = "SELECT name, META(users).id AS id FROM users";
+  const fields = extractSelectFields(query);
+  assert.ok(arraysEqual(fields, ["name"]));
+});
+
+test("extracts field from aggregate function", () => {
+  const query = "SELECT COUNT(status) FROM users";
+  const fields = extractSelectFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+
+test("handles collection.field syntax", () => {
+  const query = "SELECT users.name, users.email FROM users";
+  const fields = extractSelectFields(query);
+  assert.ok(arraysEqual(fields, ["name", "email"]));
+});
+
+test("returns null when no SELECT clause found", () => {
+  const query = "INVALID QUERY";
+  const fields = extractSelectFields(query);
+  assert.strictEqual(fields, null);
+});
+
+test("handles multiple aggregate functions", () => {
+  const query = "SELECT COUNT(status), SUM(amount), AVG(score) FROM users";
+  const fields = extractSelectFields(query);
+  assert.ok(fields.includes("status"));
+  assert.ok(fields.includes("amount"));
+  assert.ok(fields.includes("score"));
+});
+
+test("handles nested function calls", () => {
+  const query = "SELECT LOWER(TRIM(name)) AS clean_name FROM users";
+  const fields = extractSelectFields(query);
+  // Should extract 'name' from nested functions - currently extracts last match
+  assert.ok(fields.length >= 0); // At minimum should not crash
+});
+
+test("handles query with JOIN", () => {
+  const query = "SELECT users.name, orders.total FROM users JOIN orders ON users.id = orders.user_id";
+  const fields = extractSelectFields(query);
+  assert.ok(fields.includes("name"));
+  assert.ok(fields.includes("total"));
+});
+
+test("handles DISTINCT keyword", () => {
+  const query = "SELECT DISTINCT status, type FROM users";
+  const fields = extractSelectFields(query);
+  assert.ok(fields.includes("status"));
+  assert.ok(fields.includes("type"));
+});
+
+test("handles query generated by search function pattern", () => {
+  // Pattern: SELECT columns FROM `collection` WHERE conditions ORDER BY ... LIMIT ... OFFSET ...
+  const query = `SELECT first_name, last_name, email, META(\`users\`).id AS id FROM \`users\` WHERE type = 'user' AND status = 'active' ORDER BY created_at LIMIT 100 OFFSET 0`;
+  const fields = extractSelectFields(query);
+  assert.ok(fields.includes("first_name"));
+  assert.ok(fields.includes("last_name"));
+  assert.ok(fields.includes("email"));
+  assert.ok(!fields.includes("id")); // META().id should be skipped
+});
+
+test("handles backtick collection prefix", () => {
+  const query = "SELECT `users`.`first_name`, `users`.`last_name` FROM `users`";
+  const fields = extractSelectFields(query);
+  assert.ok(fields.includes("first_name"));
+  assert.ok(fields.includes("last_name"));
+});
+
+// ============================================
+// Tests for extractGroupByFields
+// ============================================
+console.log("\n--- extractGroupByFields tests ---");
+
+test("extracts simple GROUP BY field", () => {
+  const query = "SELECT status, COUNT(*) FROM users GROUP BY status";
+  const fields = extractGroupByFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+
+test("extracts multiple GROUP BY fields", () => {
+  const query = "SELECT status, type, COUNT(*) FROM users GROUP BY status, type";
+  const fields = extractGroupByFields(query);
+  assert.ok(arraysEqual(fields, ["status", "type"]));
+});
+
+test("extracts GROUP BY with backtick-quoted fields", () => {
+  const query = "SELECT `status`, COUNT(*) FROM users GROUP BY `status`";
+  const fields = extractGroupByFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+
+test("extracts GROUP BY with collection prefix", () => {
+  const query = "SELECT status, COUNT(*) FROM users GROUP BY users.status";
+  const fields = extractGroupByFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+
+test("extracts GROUP BY with backtick collection prefix", () => {
+  const query = "SELECT status, COUNT(*) FROM users GROUP BY `users`.`status`";
+  const fields = extractGroupByFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+
+test("returns empty array when no GROUP BY clause", () => {
+  const query = "SELECT name FROM users WHERE status = 'active'";
+  const fields = extractGroupByFields(query);
+  assert.ok(arraysEqual(fields, []));
+});
+
+test("stops at HAVING", () => {
+  const query = "SELECT status, COUNT(*) as cnt FROM users GROUP BY status HAVING COUNT(*) > 5";
+  const fields = extractGroupByFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+
+test("stops at ORDER BY", () => {
+  const query = "SELECT status, COUNT(*) FROM users GROUP BY status ORDER BY status";
+  const fields = extractGroupByFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+
+test("stops at LIMIT", () => {
+  const query = "SELECT status, COUNT(*) FROM users GROUP BY status LIMIT 10";
+  const fields = extractGroupByFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+
+test("handles GROUP BY with HAVING and ORDER BY", () => {
+  const query = "SELECT status, COUNT(*) FROM users GROUP BY status HAVING COUNT(*) > 5 ORDER BY status";
+  const fields = extractGroupByFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+
+// ============================================
+// Tests for extractOrderByFields
+// ============================================
+console.log("\n--- extractOrderByFields tests ---");
+
+test("extracts simple ORDER BY field", () => {
+  const query = "SELECT name FROM users ORDER BY created_at";
+  const fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["created_at"]));
+});
+
+test("extracts ORDER BY field with ASC", () => {
+  const query = "SELECT name FROM users ORDER BY created_at ASC";
+  const fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["created_at"]));
+});
+
+test("extracts ORDER BY field with DESC", () => {
+  const query = "SELECT name FROM users ORDER BY created_at DESC";
+  const fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["created_at"]));
+});
+
+test("extracts multiple ORDER BY fields", () => {
+  const query = "SELECT name FROM users ORDER BY last_name ASC, first_name ASC";
+  const fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["last_name", "first_name"]));
+});
+
+test("extracts ORDER BY with backtick-quoted fields", () => {
+  const query = "SELECT name FROM users ORDER BY `created_at` DESC";
+  const fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["created_at"]));
+});
+
+test("extracts ORDER BY with collection prefix", () => {
+  const query = "SELECT name FROM users ORDER BY users.created_at DESC";
+  const fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["created_at"]));
+});
+
+test("extracts ORDER BY with backtick collection prefix", () => {
+  const query = "SELECT name FROM users ORDER BY `users`.`created_at` DESC";
+  const fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["created_at"]));
+});
+
+test("returns empty array when no ORDER BY clause", () => {
+  const query = "SELECT name FROM users WHERE status = 'active'";
+  const fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, []));
+});
+
+test("stops at LIMIT", () => {
+  const query = "SELECT name FROM users ORDER BY created_at DESC LIMIT 10";
+  const fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["created_at"]));
+});
+
+test("stops at OFFSET", () => {
+  const query = "SELECT name FROM users ORDER BY created_at DESC OFFSET 20";
+  const fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["created_at"]));
+});
+
+test("handles ORDER BY with LIMIT and OFFSET", () => {
+  const query = "SELECT name FROM users ORDER BY created_at DESC LIMIT 10 OFFSET 20";
+  const fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["created_at"]));
+});
+
+test("handles mixed ASC and DESC", () => {
+  const query = "SELECT name FROM users ORDER BY last_name ASC, created_at DESC";
+  const fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["last_name", "created_at"]));
+});
+
+// ============================================
+// Tests for buildCoveringIndex
+// ============================================
+console.log("\n--- buildCoveringIndex tests ---");
+
+const defaultOptions = {
+  bucket: "saturn",
+  scope: "test-scope",
+  collection: "users",
+};
+
+test("builds basic covering index", () => {
+  const query = "SELECT name, email FROM users WHERE status = 'active'";
+  const result = buildCoveringIndex(query, defaultOptions);
+
+  assert.ok(result !== null);
+  assert.ok(result.startsWith("CREATE INDEX"));
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`name`"));
+  assert.ok(result.includes("`email`"));
+  assert.ok(result.includes("`saturn`.`test-scope`.`users`"));
+});
+
+test("deleted field comes first", () => {
+  const query = "SELECT name FROM users WHERE status = 'active'";
+  const result = buildCoveringIndex(query, defaultOptions);
+
+  const deletedIndex = result.indexOf("`deleted` INCLUDE MISSING");
+  const statusIndex = result.indexOf("`status`");
+  assert.ok(deletedIndex < statusIndex);
+});
+
+test("WHERE fields come before SELECT fields", () => {
+  const query = "SELECT email FROM users WHERE status = 'active'";
+  const result = buildCoveringIndex(query, defaultOptions);
+
+  const statusIndex = result.indexOf("`status`");
+  const emailIndex = result.indexOf("`email`");
+  assert.ok(statusIndex < emailIndex);
+});
+
+test("deduplicates fields in WHERE and SELECT", () => {
+  const query = "SELECT status, name FROM users WHERE status = 'active'";
+  const result = buildCoveringIndex(query, defaultOptions);
+
+  // status should only appear once
+  const firstStatus = result.indexOf("`status`");
+  const lastStatus = result.lastIndexOf("`status`");
+  assert.strictEqual(firstStatus, lastStatus);
+});
+
+test("excludes deleted from WHERE fields (added separately)", () => {
+  const query = "SELECT name FROM users WHERE (deleted = false OR deleted IS MISSING) AND status = 'active'";
+  const result = buildCoveringIndex(query, defaultOptions);
+
+  // deleted should only appear once (as INCLUDE MISSING)
+  const matches = result.match(/`deleted`/g);
+  assert.strictEqual(matches.length, 1);
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+});
+
+test("returns null for SELECT * query", () => {
+  const query = "SELECT * FROM users WHERE status = 'active'";
+  const result = buildCoveringIndex(query, defaultOptions);
+  assert.strictEqual(result, null);
+});
+
+test("returns null when missing bucket option", () => {
+  const query = "SELECT name FROM users WHERE status = 'active'";
+  const result = buildCoveringIndex(query, { scope: "test", collection: "users" });
+  assert.strictEqual(result, null);
+});
+
+test("returns null when missing scope option", () => {
+  const query = "SELECT name FROM users WHERE status = 'active'";
+  const result = buildCoveringIndex(query, { bucket: "test", collection: "users" });
+  assert.strictEqual(result, null);
+});
+
+test("returns null when missing collection option", () => {
+  const query = "SELECT name FROM users WHERE status = 'active'";
+  const result = buildCoveringIndex(query, { bucket: "test", scope: "scope" });
+  assert.strictEqual(result, null);
+});
+
+test("generates unique index name from query hash", () => {
+  const query1 = "SELECT name FROM users WHERE status = 'active'";
+  const query2 = "SELECT email FROM users WHERE type = 'admin'";
+
+  const result1 = buildCoveringIndex(query1, defaultOptions);
+  const result2 = buildCoveringIndex(query2, defaultOptions);
+
+  // Extract index names
+  const name1 = result1.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
+  const name2 = result2.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
+
+  assert.notStrictEqual(name1, name2);
+});
+
+test("handles complex query with multiple conditions", () => {
+  const query = `
+    SELECT first_name, last_name, email, status 
+    FROM users 
+    WHERE (deleted = false OR deleted IS MISSING) 
+      AND status = 'active' 
+      AND created_at > '2024-01-01'
+    ORDER BY created_at
+    LIMIT 100
+  `;
+  const result = buildCoveringIndex(query, defaultOptions);
+
+  assert.ok(result !== null);
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`created_at`"));
+  assert.ok(result.includes("`first_name`"));
+  assert.ok(result.includes("`last_name`"));
+  assert.ok(result.includes("`email`"));
+});
+
+test("returns null when only deleted field in query", () => {
+  const query = "SELECT deleted FROM users WHERE deleted = false";
+  const result = buildCoveringIndex(query, defaultOptions);
+  // Should return null because after filtering out 'deleted', there are no fields left
+  assert.strictEqual(result, null);
+});
+
+test("handles query with type field (legacy pattern)", () => {
+  const query = "SELECT name, email FROM bucket WHERE type = 'user' AND status = 'active'";
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  assert.ok(result !== null);
+  assert.ok(result.includes("`type`"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`name`"));
+  assert.ok(result.includes("`email`"));
+});
+
+test("handles realistic search query pattern", () => {
+  const query = `SELECT first_name, last_name, email, status, META(\`users\`).id AS id 
+    FROM \`users\` 
+    WHERE (deleted = false OR deleted IS MISSING) AND status = 'active' 
+    ORDER BY created_at DESC 
+    LIMIT 50 OFFSET 0`;
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  assert.ok(result !== null);
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`first_name`"));
+  assert.ok(result.includes("`last_name`"));
+  assert.ok(result.includes("`email`"));
+});
+
+test("handles query with BETWEEN in WHERE", () => {
+  const query = "SELECT name FROM users WHERE age BETWEEN 18 AND 65";
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  assert.ok(result !== null);
+  assert.ok(result.includes("`age`"));
+  assert.ok(result.includes("`name`"));
+});
+
+test("handles query with multiple OR conditions", () => {
+  const query = "SELECT name FROM users WHERE status = 'active' OR status = 'pending' OR status = 'review'";
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  assert.ok(result !== null);
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`name`"));
+});
+
+test("consistent index name for same query", () => {
+  const query = "SELECT name FROM users WHERE status = 'active'";
+  const result1 = buildCoveringIndex(query, defaultOptions);
+  const result2 = buildCoveringIndex(query, defaultOptions);
+  
+  assert.strictEqual(result1, result2);
+});
+
+test("same index name for different queries with same fields", () => {
+  // Two different queries that would be covered by the same index
+  const query1 = "SELECT name, email FROM users WHERE status = 'active'";
+  const query2 = "SELECT email, name FROM users WHERE status = 'pending'";
+  
+  const result1 = buildCoveringIndex(query1, defaultOptions);
+  const result2 = buildCoveringIndex(query2, defaultOptions);
+  
+  // Extract index names
+  const name1 = result1.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
+  const name2 = result2.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
+  
+  // Should have the same index name since they have the same fields
+  assert.strictEqual(name1, name2);
+});
+
+test("different index name for queries with different fields", () => {
+  const query1 = "SELECT name FROM users WHERE status = 'active'";
+  const query2 = "SELECT email FROM users WHERE type = 'admin'";
+  
+  const result1 = buildCoveringIndex(query1, defaultOptions);
+  const result2 = buildCoveringIndex(query2, defaultOptions);
+  
+  // Extract index names
+  const name1 = result1.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
+  const name2 = result2.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
+  
+  // Should have different index names since they have different fields
+  assert.notStrictEqual(name1, name2);
+});
+
+test("index includes all fields needed for covering", () => {
+  const query = `SELECT 
+    first_name, 
+    middle_name, 
+    last_name, 
+    status, 
+    constituency, 
+    division, 
+    description 
+  FROM subject 
+  WHERE (deleted = false OR deleted IS MISSING) 
+    AND created_at > '2024-01-01'`;
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  // Verify structure matches the working example pattern
+  assert.ok(result.startsWith("CREATE INDEX `adv_covered_"));
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+  assert.ok(result.includes("`created_at`"));
+  assert.ok(result.includes("`first_name`"));
+  assert.ok(result.includes("`middle_name`"));
+  assert.ok(result.includes("`last_name`"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`constituency`"));
+  assert.ok(result.includes("`division`"));
+  assert.ok(result.includes("`description`"));
+});
+
+test("handles query with ANY array operator", () => {
+  const query = `SELECT name, email FROM users 
+    WHERE (deleted = false OR deleted IS MISSING) 
+    AND ANY tag IN tags SATISFIES tag = 'premium' END`;
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  assert.ok(result !== null);
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+  assert.ok(result.includes("`tags`"));
+  assert.ok(result.includes("`name`"));
+  assert.ok(result.includes("`email`"));
+});
+
+test("handles query with EVERY array operator", () => {
+  const query = `SELECT name FROM users 
+    WHERE status = 'active' 
+    AND EVERY score IN scores SATISFIES score > 0 END`;
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  assert.ok(result !== null);
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`scores`"));
+  assert.ok(result.includes("`name`"));
+});
+
+test("handles complex query with multiple ANY/EVERY", () => {
+  const query = `SELECT name, email, status FROM users 
+    WHERE (deleted = false OR deleted IS MISSING) 
+    AND type = 'user'
+    AND ANY tag IN tags SATISFIES tag = 'active' END 
+    AND EVERY perm IN permissions SATISFIES perm.level >= 1 END`;
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  assert.ok(result !== null);
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+  assert.ok(result.includes("`type`"));
+  assert.ok(result.includes("`tags`"));
+  assert.ok(result.includes("`permissions`"));
+  assert.ok(result.includes("`name`"));
+  assert.ok(result.includes("`email`"));
+  assert.ok(result.includes("`status`"));
+});
+
+test("includes ORDER BY fields in index", () => {
+  const query = "SELECT name, email FROM users WHERE status = 'active' ORDER BY created_at DESC";
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  assert.ok(result !== null);
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`created_at`"));
+  assert.ok(result.includes("`name`"));
+  assert.ok(result.includes("`email`"));
+});
+
+test("ORDER BY fields come after WHERE fields", () => {
+  const query = "SELECT email FROM users WHERE status = 'active' ORDER BY created_at";
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  const statusIndex = result.indexOf("`status`");
+  const createdAtIndex = result.indexOf("`created_at`");
+  const emailIndex = result.indexOf("`email`");
+  
+  // WHERE field (status) should come before ORDER BY field (created_at)
+  assert.ok(statusIndex < createdAtIndex);
+  // ORDER BY field (created_at) should come before SELECT field (email)
+  assert.ok(createdAtIndex < emailIndex);
+});
+
+test("deduplicates ORDER BY field if already in WHERE", () => {
+  const query = "SELECT name FROM users WHERE status = 'active' AND created_at > '2024-01-01' ORDER BY created_at DESC";
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  // created_at should only appear once
+  const firstCreatedAt = result.indexOf("`created_at`");
+  const lastCreatedAt = result.lastIndexOf("`created_at`");
+  assert.strictEqual(firstCreatedAt, lastCreatedAt);
+});
+
+test("deduplicates ORDER BY field if already in SELECT", () => {
+  const query = "SELECT name, created_at FROM users WHERE status = 'active' ORDER BY created_at DESC";
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  // created_at should only appear once (in ORDER BY position, before SELECT fields)
+  const matches = result.match(/`created_at`/g);
+  assert.strictEqual(matches.length, 1);
+});
+
+test("handles multiple ORDER BY fields", () => {
+  const query = "SELECT email FROM users WHERE status = 'active' ORDER BY last_name ASC, first_name ASC";
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  assert.ok(result.includes("`last_name`"));
+  assert.ok(result.includes("`first_name`"));
+  
+  // ORDER BY fields should come before SELECT fields
+  const lastNameIndex = result.indexOf("`last_name`");
+  const firstNameIndex = result.indexOf("`first_name`");
+  const emailIndex = result.indexOf("`email`");
+  
+  assert.ok(lastNameIndex < emailIndex);
+  assert.ok(firstNameIndex < emailIndex);
+});
+
+test("handles realistic query with ORDER BY", () => {
+  const query = `SELECT first_name, last_name, email, status 
+    FROM users 
+    WHERE (deleted = false OR deleted IS MISSING) AND status = 'active' 
+    ORDER BY created_at DESC 
+    LIMIT 50 OFFSET 0`;
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  assert.ok(result !== null);
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`created_at`"));
+  assert.ok(result.includes("`first_name`"));
+  assert.ok(result.includes("`last_name`"));
+  assert.ok(result.includes("`email`"));
+  
+  // Verify order: status (WHERE) -> created_at (ORDER BY) -> SELECT fields
+  const statusIndex = result.indexOf("`status`");
+  const createdAtIndex = result.indexOf("`created_at`");
+  const firstNameIndex = result.indexOf("`first_name`");
+  
+  assert.ok(statusIndex < createdAtIndex);
+  assert.ok(createdAtIndex < firstNameIndex);
+});
+
+test("includes GROUP BY fields in index", () => {
+  const query = "SELECT status, COUNT(name) as cnt FROM users WHERE type = 'user' GROUP BY status";
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  assert.ok(result !== null);
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+  assert.ok(result.includes("`type`"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`name`"));
+});
+
+test("GROUP BY fields come after WHERE fields", () => {
+  const query = "SELECT COUNT(name) FROM users WHERE type = 'user' GROUP BY status";
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  const typeIndex = result.indexOf("`type`");
+  const statusIndex = result.indexOf("`status`");
+  
+  // WHERE field (type) should come before GROUP BY field (status)
+  assert.ok(typeIndex < statusIndex);
+});
+
+test("GROUP BY fields come before ORDER BY fields", () => {
+  const query = "SELECT COUNT(name) FROM users WHERE type = 'user' GROUP BY status ORDER BY status";
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  const typeIndex = result.indexOf("`type`");
+  const statusIndex = result.indexOf("`status`");
+  
+  // status is in both GROUP BY and ORDER BY, should only appear once
+  const matches = result.match(/`status`/g);
+  assert.strictEqual(matches.length, 1);
+  
+  // WHERE field (type) should come before GROUP BY field (status)
+  assert.ok(typeIndex < statusIndex);
+});
+
+test("deduplicates GROUP BY field if already in WHERE", () => {
+  const query = "SELECT COUNT(name) FROM users WHERE status = 'active' GROUP BY status";
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  // status should only appear once
+  const matches = result.match(/`status`/g);
+  assert.strictEqual(matches.length, 1);
+});
+
+test("handles multiple GROUP BY fields", () => {
+  const query = "SELECT status, type, COUNT(name) FROM users WHERE category = 'A' GROUP BY status, type";
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  assert.ok(result.includes("`category`"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`type`"));
+  assert.ok(result.includes("`name`"));
+});
+
+test("handles GROUP BY with HAVING and ORDER BY", () => {
+  const query = `SELECT status, COUNT(name) as cnt 
+    FROM users 
+    WHERE type = 'user' 
+    GROUP BY status 
+    HAVING COUNT(name) > 5 
+    ORDER BY cnt DESC`;
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  assert.ok(result !== null);
+  assert.ok(result.includes("`type`"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`name`"));
+});
+
+test("handles realistic GROUP BY query", () => {
+  const query = `SELECT status, COUNT(first_name) as user_count 
+    FROM users 
+    WHERE (deleted = false OR deleted IS MISSING) AND type = 'user' 
+    GROUP BY status 
+    ORDER BY user_count DESC 
+    LIMIT 10`;
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  assert.ok(result !== null);
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+  assert.ok(result.includes("`type`"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`first_name`"));
+  
+  // Verify order: type (WHERE) -> status (GROUP BY) -> first_name (SELECT)
+  const typeIndex = result.indexOf("`type`");
+  const statusIndex = result.indexOf("`status`");
+  const firstNameIndex = result.indexOf("`first_name`");
+  
+  assert.ok(typeIndex < statusIndex);
+  assert.ok(statusIndex < firstNameIndex);
+});
+
+test("field order: WHERE -> GROUP BY -> ORDER BY -> SELECT", () => {
+  const query = `SELECT email 
+    FROM users 
+    WHERE type = 'user' 
+    GROUP BY status 
+    ORDER BY created_at`;
+  const result = buildCoveringIndex(query, defaultOptions);
+  
+  const typeIndex = result.indexOf("`type`");
+  const statusIndex = result.indexOf("`status`");
+  const createdAtIndex = result.indexOf("`created_at`");
+  const emailIndex = result.indexOf("`email`");
+  
+  // Verify correct order
+  assert.ok(typeIndex < statusIndex);      // WHERE before GROUP BY
+  assert.ok(statusIndex < createdAtIndex); // GROUP BY before ORDER BY
+  assert.ok(createdAtIndex < emailIndex);  // ORDER BY before SELECT
+});
+
+// ============================================
+// Summary
+// ============================================
+console.log("\n========================================");
+console.log(`Tests: ${passed + failed} | Passed: ${passed} | Failed: ${failed}`);
+console.log("========================================\n");
+
+process.exit(failed > 0 ? 1 : 0);