spice-couchbase 2.0.45 → 2.0.46

package/build/index.js

@@ -757,40 +757,96 @@ module.exports = class Database {
       return response.rows;
     })();
   }
+  /**
+   * Recursively checks if the query plan contains a Fetch operator
+   * @param {Object} plan - The EXPLAIN query plan
+   * @returns {boolean} - True if Fetch operator is found
+   */
+
+
+  hasFetchOperator(plan) {
+    if (!plan || typeof plan !== "object") {
+      return false;
+    } // Check if this node is a Fetch operator
+
+
+    if (plan["#operator"] === "Fetch") {
+      return true;
+    } // Recursively check all child properties
+
+
+    for (var key of Object.keys(plan)) {
+      var value = plan[key];
+
+      if (Array.isArray(value)) {
+        for (var item of value) {
+          if (this.hasFetchOperator(item)) {
+            return true;
+          }
+        }
+      } else if (typeof value === "object" && value !== null) {
+        if (this.hasFetchOperator(value)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
 
   optimize(query, exec_scope) {
+    var _this18 = this;
+
     return _asyncToGenerator(function* () {
       try {
-        var _$last, _$first, _$first$advice, _$first$advice$advise, _$first$advice$advise2;
+        var _explainResponse$rows;
 
-        var options = {
-          adhoc: true
-        };
-        var advise_query = "ADVISE ".concat(query);
-        var response = yield exec_scope.query(advise_query, options);
-        var best_index = (_$last = _.last(((_$first = _.first((response === null || response === void 0 ? void 0 : response.rows) || [])) === null || _$first === void 0 ? void 0 : (_$first$advice = _$first.advice) === null || _$first$advice === void 0 ? void 0 : (_$first$advice$advise = _$first$advice.adviseinfo) === null || _$first$advice$advise === void 0 ? void 0 : (_$first$advice$advise2 = _$first$advice$advise.recommended_indexes) === null || _$first$advice$advise2 === void 0 ? void 0 : _$first$advice$advise2.indexes) || [])) === null || _$last === void 0 ? void 0 : _$last.index_statement;
+        var {
+          buildCoveringIndex
+        } = require("./utility"); // 1. Run EXPLAIN to get the query plan
+
+
+        var explainQuery = "EXPLAIN ".concat(query);
+        var explainResponse = yield exec_scope.query(explainQuery); // 2. Check if query plan contains Fetch operator (not covered)
+
+        var plan = explainResponse === null || explainResponse === void 0 ? void 0 : (_explainResponse$rows = explainResponse.rows) === null || _explainResponse$rows === void 0 ? void 0 : _explainResponse$rows[0];
+
+        if (!_this18.hasFetchOperator(plan)) {
+          // Query is already covered, no need to create index
+          return;
+        } // 3. Build covering index from the query
 
-        if (best_index) {
-          yield exec_scope.query(best_index);
+
+        var indexStatement = buildCoveringIndex(query, {
+          bucket: _this18.bucket,
+          scope: _this18.scope_name,
+          collection: _this18.collection_name
+        }); // 4. Execute the index creation if we got a valid statement
+
+        if (indexStatement) {
+          console.log("Executing index creation:", indexStatement);
+          var response = yield exec_scope.query(indexStatement);
+          console.log("Index creation response:", response);
         }
-      } catch (e) {}
+      } catch (e) {// Silently handle errors (index may already exist, etc.)
+      }
     })();
   }
 
   query(query) {
-    var _this18 = this;
+    var _this19 = this;
 
     var query_scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "cluster";
     return _asyncToGenerator(function* () {
-      var scope = query_scope || _this18.query_scope;
+      var scope = query_scope || _this19.query_scope;
       var sanitizedQuery = query; //sanitization step to be implemented
 
       var exec_scope = null;
 
       if (scope === "cluster") {
-        exec_scope = _this18.cluster;
+        exec_scope = _this19.cluster;
       } else {
-        exec_scope = _this18.scope;
+        exec_scope = _this19.scope;
       } // Start time
 
 
@@ -803,10 +859,10 @@ module.exports = class Database {
       var endTime = process.hrtime.bigint(); // Calculate duration in microseconds
 
       var durationInMilliseconds = (endTime - startTime) / BigInt(1000000); // optimize if response time is greater than 1 second
+      //if (durationInMilliseconds > 2000) {
+
+      _this19.optimize(query, exec_scope); //}
 
-      if (durationInMilliseconds > 2000) {
-        _this18.optimize(query, exec_scope);
-      }
 
       return response;
     })();

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
+};