spice-couchbase 2.0.44 → 2.0.46

package/src/utility.js

@@ -0,0 +1,368 @@
+"use strict";
+
+const crypto = require("crypto");
+
+/**
+ * Generates a short hash from a string for unique index naming
+ * @param {string} str - The string to hash
+ * @returns {string} - A short hash string
+ */
+function generateHash(str) {
+  return crypto.createHash("md5").update(str).digest("hex").substring(0, 8);
+}
+
+/**
+ * Extracts field names from WHERE clause of a query
+ * @param {string} query - The N1QL query
+ * @returns {string[]} - Array of field names found in WHERE clause
+ */
+function extractWhereFields(query) {
+  const fields = new Set();
+
+  // Find the WHERE clause
+  const whereMatch = query.match(
+    /\bWHERE\b(.+?)(?:\bORDER\b|\bLIMIT\b|\bOFFSET\b|\bGROUP\b|\bHAVING\b|$)/is,
+  );
+  if (!whereMatch) {
+    return [];
+  }
+
+  const whereClause = whereMatch[1];
+
+  // Pattern to match field names in comparisons
+  // Matches: field = value, field > value, field < value, field >= value, field <= value
+  // Also matches: field IN (...), field LIKE ..., field IS NULL, field IS MISSING, field IS NOT NULL
+  // Handles backtick-quoted fields like `field_name`
+  const fieldPattern =
+    /`?(\w+)`?\s*(?:=|!=|<>|>=|<=|>|<|\bIN\b|\bLIKE\b|\bIS\b|\bBETWEEN\b)/gi;
+
+  let match;
+  while ((match = fieldPattern.exec(whereClause)) !== null) {
+    const fieldName = match[1].toLowerCase();
+    // Skip common SQL keywords that might be matched
+    if (
+      !["and", "or", "not", "null", "missing", "true", "false"].includes(
+        fieldName,
+      )
+    ) {
+      fields.add(match[1]); // Keep original case
+    }
+  }
+
+  // Also look for fields in function calls like LOWER(field), UPPER(field)
+  const functionPattern =
+    /(?:LOWER|UPPER|TRIM|LENGTH|SUBSTR)\s*\(\s*`?(\w+)`?/gi;
+  while ((match = functionPattern.exec(whereClause)) !== null) {
+    fields.add(match[1]);
+  }
+
+  // Extract array fields from ANY/EVERY ... IN array_field SATISFIES ... END
+  // Pattern: ANY/EVERY variable IN array_field SATISFIES ... END
+  const anyEveryPattern =
+    /\b(?:ANY|EVERY)\s+\w+\s+IN\s+`?(\w+)`?\s+SATISFIES/gi;
+  while ((match = anyEveryPattern.exec(whereClause)) !== null) {
+    fields.add(match[1]);
+  }
+
+  // Also extract nested property access within SATISFIES: v.property = value
+  // This captures fields accessed through array iteration variables
+  const satisfiesPattern = /SATISFIES\s+(.+?)\s+END/gi;
+  while ((match = satisfiesPattern.exec(whereClause)) !== null) {
+    const satisfiesClause = match[1];
+    // Look for comparisons like: v.property = value, v.field > 10
+    const nestedFieldPattern =
+      /\w+\.`?(\w+)`?\s*(?:=|!=|<>|>=|<=|>|<|\bIN\b|\bLIKE\b|\bIS\b)/gi;
+    let nestedMatch;
+    while ((nestedMatch = nestedFieldPattern.exec(satisfiesClause)) !== null) {
+      // These are nested properties, we might want to track them separately
+      // For now, we'll note them but the array field is what matters for indexing
+    }
+  }
+
+  return Array.from(fields);
+}
+
+/**
+ * Extracts field names from SELECT clause of a query
+ * @param {string} query - The N1QL query
+ * @returns {string[]|null} - Array of field names, or null if SELECT *
+ */
+function extractSelectFields(query) {
+  // Find the SELECT clause (between SELECT and FROM)
+  const selectMatch = query.match(/\bSELECT\b(.+?)\bFROM\b/is);
+  if (!selectMatch) {
+    return null;
+  }
+
+  const selectClause = selectMatch[1].trim();
+
+  // Check for SELECT * patterns
+  if (
+    /^\s*\*\s*$/.test(selectClause) ||
+    /\(\s*\w+\s*\)\s*\.\s*\*/.test(selectClause)
+  ) {
+    return null; // Cannot determine fields for SELECT *
+  }
+
+  const fields = new Set();
+
+  // Split by comma, handling nested parentheses
+  const parts = splitSelectClause(selectClause);
+
+  for (const part of parts) {
+    const trimmedPart = part.trim();
+
+    // Skip if it's a * pattern
+    if (trimmedPart === "*" || trimmedPart.endsWith(".*")) {
+      return null;
+    }
+
+    // Handle AS alias - get the source field
+    const asMatch = trimmedPart.match(/^(.+?)\s+AS\s+\w+$/i);
+    const fieldExpr = asMatch ? asMatch[1].trim() : trimmedPart;
+
+    // Extract field from META().id pattern - skip these
+    if (/META\s*\(/i.test(fieldExpr)) {
+      continue;
+    }
+
+    // Extract field from function calls like COUNT(field), SUM(field)
+    const funcMatch = fieldExpr.match(/^\w+\s*\(\s*`?(\w+)`?\s*\)$/);
+    if (funcMatch && funcMatch[1].toLowerCase() !== "id") {
+      fields.add(funcMatch[1]);
+      continue;
+    }
+
+    // Handle simple field reference: `field` or collection.field or `collection`.`field`
+    const simpleFieldMatch = fieldExpr.match(/(?:`?\w+`?\s*\.\s*)?`?(\w+)`?$/);
+    if (simpleFieldMatch) {
+      const fieldName = simpleFieldMatch[1];
+      if (fieldName.toLowerCase() !== "id") {
+        fields.add(fieldName);
+      }
+    }
+  }
+
+  return Array.from(fields);
+}
+
+/**
+ * Extracts field names from GROUP BY clause of a query
+ * @param {string} query - The N1QL query
+ * @returns {string[]} - Array of field names found in GROUP BY clause
+ */
+function extractGroupByFields(query) {
+  const fields = [];
+
+  // Find the GROUP BY clause
+  const groupByMatch = query.match(
+    /\bGROUP\s+BY\b(.+?)(?:\bHAVING\b|\bORDER\b|\bLIMIT\b|\bOFFSET\b|$)/is,
+  );
+  if (!groupByMatch) {
+    return [];
+  }
+
+  const groupByClause = groupByMatch[1];
+
+  // Split by comma and extract field names
+  const parts = groupByClause.split(",");
+
+  for (const part of parts) {
+    const trimmedPart = part.trim();
+
+    // Handle collection.field or `collection`.`field` syntax
+    const fieldMatch = trimmedPart.match(/(?:`?\w+`?\s*\.\s*)?`?(\w+)`?$/);
+    if (fieldMatch) {
+      const fieldName = fieldMatch[1];
+      // Skip if it's a keyword or id
+      if (!["id"].includes(fieldName.toLowerCase())) {
+        fields.push(fieldName);
+      }
+    }
+  }
+
+  return fields;
+}
+
+/**
+ * Extracts field names from ORDER BY clause of a query
+ * @param {string} query - The N1QL query
+ * @returns {string[]} - Array of field names found in ORDER BY clause
+ */
+function extractOrderByFields(query) {
+  const fields = [];
+
+  // Find the ORDER BY clause
+  const orderByMatch = query.match(
+    /\bORDER\s+BY\b(.+?)(?:\bLIMIT\b|\bOFFSET\b|$)/is,
+  );
+  if (!orderByMatch) {
+    return [];
+  }
+
+  const orderByClause = orderByMatch[1];
+
+  // Split by comma and extract field names
+  const parts = orderByClause.split(",");
+
+  for (const part of parts) {
+    const trimmedPart = part.trim();
+
+    // Remove ASC/DESC suffix
+    const withoutDirection = trimmedPart
+      .replace(/\s+(ASC|DESC)\s*$/i, "")
+      .trim();
+
+    // Handle collection.field or `collection`.`field` syntax
+    const fieldMatch = withoutDirection.match(/(?:`?\w+`?\s*\.\s*)?`?(\w+)`?$/);
+    if (fieldMatch) {
+      const fieldName = fieldMatch[1];
+      // Skip if it's a keyword or id
+      if (!["id", "asc", "desc"].includes(fieldName.toLowerCase())) {
+        fields.push(fieldName);
+      }
+    }
+  }
+
+  return fields;
+}
+
+/**
+ * Splits SELECT clause by commas, respecting parentheses
+ * @param {string} clause - The SELECT clause content
+ * @returns {string[]} - Array of individual select expressions
+ */
+function splitSelectClause(clause) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+
+  for (const char of clause) {
+    if (char === "(") {
+      depth++;
+      current += char;
+    } else if (char === ")") {
+      depth--;
+      current += char;
+    } else if (char === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+
+  if (current.trim()) {
+    parts.push(current);
+  }
+
+  return parts;
+}
+
+/**
+ * Builds a covering index CREATE statement from a query
+ * @param {string} query - The N1QL query to analyze
+ * @param {Object} options - Configuration options
+ * @param {string} options.bucket - The bucket name
+ * @param {string} options.scope - The scope name
+ * @param {string} options.collection - The collection name
+ * @returns {string|null} - The CREATE INDEX statement, or null if cannot build
+ */
+function buildCoveringIndex(query, options) {
+  const { bucket, scope, collection } = options;
+
+  if (!bucket || !scope || !collection) {
+    return null;
+  }
+
+  // Extract fields from SELECT clause
+  const selectFields = extractSelectFields(query);
+  if (selectFields === null) {
+    // SELECT * query - cannot create covering index
+    return null;
+  }
+
+  // Extract fields from WHERE clause
+  const whereFields = extractWhereFields(query);
+
+  // Extract fields from GROUP BY clause
+  const groupByFields = extractGroupByFields(query);
+
+  // Extract fields from ORDER BY clause
+  const orderByFields = extractOrderByFields(query);
+
+  // Remove 'deleted' from whereFields as it will be added first with INCLUDE MISSING
+  const filteredWhereFields = whereFields.filter(
+    (f) => f.toLowerCase() !== "deleted",
+  );
+
+  // Track fields already added to avoid duplicates
+  const addedFields = new Set(filteredWhereFields.map((f) => f.toLowerCase()));
+
+  // Filter GROUP BY fields (remove duplicates from WHERE, remove deleted)
+  const filteredGroupByFields = groupByFields.filter((f) => {
+    const lower = f.toLowerCase();
+    if (addedFields.has(lower) || lower === "deleted") {
+      return false;
+    }
+    addedFields.add(lower);
+    return true;
+  });
+
+  // Filter ORDER BY fields (remove duplicates from WHERE and GROUP BY, remove deleted)
+  const filteredOrderByFields = orderByFields.filter((f) => {
+    const lower = f.toLowerCase();
+    if (addedFields.has(lower) || lower === "deleted") {
+      return false;
+    }
+    addedFields.add(lower);
+    return true;
+  });
+
+  // Filter SELECT fields (remove duplicates from WHERE, GROUP BY, and ORDER BY, remove deleted)
+  const selectFieldsFiltered = selectFields.filter((f) => {
+    const lower = f.toLowerCase();
+    if (addedFields.has(lower) || lower === "deleted") {
+      return false;
+    }
+    addedFields.add(lower);
+    return true;
+  });
+
+  // All fields for the index: WHERE -> GROUP BY -> ORDER BY -> SELECT
+  const allFields = [
+    ...filteredWhereFields,
+    ...filteredGroupByFields,
+    ...filteredOrderByFields,
+    ...selectFieldsFiltered,
+  ];
+
+  if (allFields.length === 0) {
+    // No fields to index besides deleted
+    return null;
+  }
+
+  // Generate unique index name based on query hash
+  const hash = generateHash(query);
+  const indexName = `adv_covered_${hash}`;
+
+  // Build the field list with deleted INCLUDE MISSING first
+  const fieldList = [
+    "`deleted` INCLUDE MISSING",
+    ...allFields.map((f) => `\`${f}\``),
+  ].join(", ");
+
+  // Build the CREATE INDEX statement
+  const indexStatement = `CREATE INDEX \`${indexName}\` ON \`default\`:\`${bucket}\`.\`${scope}\`.\`${collection}\`(${fieldList})`;
+
+  return indexStatement;
+}
+
+module.exports = {
+  buildCoveringIndex,
+  extractWhereFields,
+  extractSelectFields,
+  extractGroupByFields,
+  extractOrderByFields,
+  generateHash,
+};