spice-couchbase 2.0.44 → 2.0.46

package/build/utility.js

@@ -0,0 +1,352 @@
+"use strict";
+
+var 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) {
+  var fields = new Set(); // Find the WHERE clause
+
+  var whereMatch = query.match(/\bWHERE\b([\s\S]+?)(?:\bORDER\b|\bLIMIT\b|\bOFFSET\b|\bGROUP\b|\bHAVING\b|$)/i);
+
+  if (!whereMatch) {
+    return [];
+  }
+
+  var 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`
+
+  var fieldPattern = /`?(\w+)`?\s*(?:=|!=|<>|>=|<=|>|<|\bIN\b|\bLIKE\b|\bIS\b|\bBETWEEN\b)/gi;
+  var match;
+
+  while ((match = fieldPattern.exec(whereClause)) !== null) {
+    var 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)
+
+
+  var 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
+
+
+  var 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
+
+
+  var satisfiesPattern = /SATISFIES\s+(.+?)\s+END/gi;
+
+  while ((match = satisfiesPattern.exec(whereClause)) !== null) {
+    var satisfiesClause = match[1]; // Look for comparisons like: v.property = value, v.field > 10
+
+    var nestedFieldPattern = /\w+\.`?(\w+)`?\s*(?:=|!=|<>|>=|<=|>|<|\bIN\b|\bLIKE\b|\bIS\b)/gi;
+    var nestedMatch = void 0;
+
+    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)
+  var selectMatch = query.match(/\bSELECT\b([\s\S]+?)\bFROM\b/i);
+
+  if (!selectMatch) {
+    return null;
+  }
+
+  var 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 *
+  }
+
+  var fields = new Set(); // Split by comma, handling nested parentheses
+
+  var parts = splitSelectClause(selectClause);
+
+  for (var part of parts) {
+    var trimmedPart = part.trim(); // Skip if it's a * pattern
+
+    if (trimmedPart === "*" || trimmedPart.endsWith(".*")) {
+      return null;
+    } // Handle AS alias - get the source field
+
+
+    var asMatch = trimmedPart.match(/^(.+?)\s+AS\s+\w+$/i);
+    var 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)
+
+
+    var 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`
+
+
+    var simpleFieldMatch = fieldExpr.match(/(?:`?\w+`?\s*\.\s*)?`?(\w+)`?$/);
+
+    if (simpleFieldMatch) {
+      var 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) {
+  var fields = []; // Find the GROUP BY clause
+
+  var groupByMatch = query.match(/\bGROUP[\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]+BY\b([\s\S]+?)(?:\bHAVING\b|\bORDER\b|\bLIMIT\b|\bOFFSET\b|$)/i);
+
+  if (!groupByMatch) {
+    return [];
+  }
+
+  var groupByClause = groupByMatch[1]; // Split by comma and extract field names
+
+  var parts = groupByClause.split(",");
+
+  for (var part of parts) {
+    var trimmedPart = part.trim(); // Handle collection.field or `collection`.`field` syntax
+
+    var fieldMatch = trimmedPart.match(/(?:`?\w+`?\s*\.\s*)?`?(\w+)`?$/);
+
+    if (fieldMatch) {
+      var 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) {
+  var fields = []; // Find the ORDER BY clause
+
+  var orderByMatch = query.match(/\bORDER[\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]+BY\b([\s\S]+?)(?:\bLIMIT\b|\bOFFSET\b|$)/i);
+
+  if (!orderByMatch) {
+    return [];
+  }
+
+  var orderByClause = orderByMatch[1]; // Split by comma and extract field names
+
+  var parts = orderByClause.split(",");
+
+  for (var part of parts) {
+    var trimmedPart = part.trim(); // Remove ASC/DESC suffix
+
+    var withoutDirection = trimmedPart.replace(/\s+(ASC|DESC)\s*$/i, "").trim(); // Handle collection.field or `collection`.`field` syntax
+
+    var fieldMatch = withoutDirection.match(/(?:`?\w+`?\s*\.\s*)?`?(\w+)`?$/);
+
+    if (fieldMatch) {
+      var 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) {
+  var parts = [];
+  var current = "";
+  var depth = 0;
+
+  for (var 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) {
+  var {
+    bucket,
+    scope,
+    collection
+  } = options;
+
+  if (!bucket || !scope || !collection) {
+    return null;
+  } // Extract fields from SELECT clause
+
+
+  var selectFields = extractSelectFields(query);
+
+  if (selectFields === null) {
+    // SELECT * query - cannot create covering index
+    return null;
+  } // Extract fields from WHERE clause
+
+
+  var whereFields = extractWhereFields(query); // Extract fields from GROUP BY clause
+
+  var groupByFields = extractGroupByFields(query); // Extract fields from ORDER BY clause
+
+  var orderByFields = extractOrderByFields(query); // Remove 'deleted' from whereFields as it will be added first with INCLUDE MISSING
+
+  var filteredWhereFields = whereFields.filter(f => f.toLowerCase() !== "deleted"); // Track fields already added to avoid duplicates
+
+  var addedFields = new Set(filteredWhereFields.map(f => f.toLowerCase())); // Filter GROUP BY fields (remove duplicates from WHERE, remove deleted)
+
+  var filteredGroupByFields = groupByFields.filter(f => {
+    var 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)
+
+  var filteredOrderByFields = orderByFields.filter(f => {
+    var 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)
+
+  var selectFieldsFiltered = selectFields.filter(f => {
+    var 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
+
+  var 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
+
+
+  var hash = generateHash(query);
+  var indexName = "adv_covered_".concat(hash); // Build the field list with deleted INCLUDE MISSING first
+
+  var fieldList = ["`deleted` INCLUDE MISSING", ...allFields.map(f => "`".concat(f, "`"))].join(", "); // Build the CREATE INDEX statement
+
+  var indexStatement = "CREATE INDEX `".concat(indexName, "` ON `default`:`").concat(bucket, "`.`").concat(scope, "`.`").concat(collection, "`(").concat(fieldList, ")"); // Debug logs
+
+  console.log("[DEBUG buildCoveringIndex] Original query:", query);
+  console.log("[DEBUG buildCoveringIndex] WHERE fields:", filteredWhereFields);
+  console.log("[DEBUG buildCoveringIndex] GROUP BY fields:", filteredGroupByFields);
+  console.log("[DEBUG buildCoveringIndex] ORDER BY fields:", filteredOrderByFields);
+  console.log("[DEBUG buildCoveringIndex] SELECT fields:", selectFieldsFiltered);
+  console.log("[DEBUG buildCoveringIndex] Index statement:", indexStatement);
+  return indexStatement;
+}
+
+module.exports = {
+  buildCoveringIndex,
+  extractWhereFields,
+  extractSelectFields,
+  extractGroupByFields,
+  extractOrderByFields,
+  generateHash
+};