spice-couchbase 2.0.63 → 2.0.65

package/build/utility.js

@@ -1,220 +1,203 @@
 "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);
+  var fields = new Set();
 
+  // Find the WHERE clause
+  var whereMatch = query.match(/\bWHERE\b([^]+?)(?:\bORDER\b|\bLIMIT\b|\bOFFSET\b|\bGROUP\b|\bHAVING\b|$)/i);
   if (!whereMatch) {
     return [];
   }
+  var whereClause = whereMatch[1];
 
-  var whereClause = whereMatch[1]; // Pattern to match field names in comparisons
+  // 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
-
+    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)
-
+  }
 
+  // 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
-
+  }
 
+  // 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
-
+  }
 
+  // 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 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
+    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);
-
+  var selectMatch = query.match(/\bSELECT\b([^]+?)\bFROM\b/i);
   if (!selectMatch) {
     return null;
   }
+  var selectClause = selectMatch[1].trim();
 
-  var selectClause = selectMatch[1].trim(); // Check for SELECT * patterns
-
+  // 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();
 
-  var fields = new Set(); // Split by comma, handling nested parentheses
-
+  // 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
+    var trimmedPart = part.trim();
 
+    // Skip if it's a * pattern
     if (trimmedPart === "*" || trimmedPart.endsWith(".*")) {
       return null;
-    } // Handle AS alias - get the source field
-
+    }
 
+    // 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
+    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)
-
+    }
 
+    // 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`
-
+    }
 
+    // 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);
+  var fields = [];
 
+  // Find the GROUP BY clause
+  var groupByMatch = query.match(/\bGROUP\s+BY\b([^]+?)(?:\bHAVING\b|\bORDER\b|\bLIMIT\b|\bOFFSET\b|$)/i);
   if (!groupByMatch) {
     return [];
   }
+  var groupByClause = groupByMatch[1];
 
-  var groupByClause = groupByMatch[1]; // Split by comma and extract field names
-
+  // 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 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
-
+      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) {
   return extractOrderByIndexFields(query).map(field => field.name);
 }
+
 /**
  * Extracts ORDER BY fields with sort direction for index key generation
  * @param {string} query - The N1QL query
  * @returns {{name: string, direction: string}[]} - Array of fields with normalized direction
  */
-
-
 function extractOrderByIndexFields(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);
+  var fields = [];
 
+  // Find the ORDER BY clause
+  var orderByMatch = query.match(/\bORDER\s+BY\b([^]+?)(?:\bLIMIT\b|\bOFFSET\b|$)/i);
   if (!orderByMatch) {
     return [];
   }
+  var orderByClause = orderByMatch[1];
 
-  var orderByClause = orderByMatch[1]; // Split by comma and extract field names
-
+  // Split by comma and extract field names
   var parts = orderByClause.split(",");
-
   for (var part of parts) {
-    var trimmedPart = part.trim(); // Remove ASC/DESC suffix while preserving DESC for index key generation.
+    var trimmedPart = part.trim();
 
+    // Remove ASC/DESC suffix while preserving DESC for index key generation.
     var directionMatch = trimmedPart.match(/\s+(ASC|DESC)\s*$/i);
     var direction = directionMatch && directionMatch[1].toUpperCase() === "DESC" ? "DESC" : "";
-    var withoutDirection = trimmedPart.replace(/\s+(ASC|DESC)\s*$/i, "").trim(); // Handle collection.field or `collection`.`field` syntax
+    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
-
+      var fieldName = fieldMatch[1];
+      // Skip if it's a keyword or id
       if (!["id", "asc", "desc"].includes(fieldName.toLowerCase())) {
         fields.push({
           name: fieldName,
@@ -223,41 +206,33 @@ function extractOrderByIndexFields(query) {
       }
     }
   }
-
   return fields;
 }
-
 function buildOrderDirectionMap(orderByIndexFields) {
   var directionMap = new Map();
-
-  for (var {
-    name,
-    direction
-  } of orderByIndexFields) {
+  for (var _ref2 of orderByIndexFields) {
+    var name = _ref2.name;
+    var direction = _ref2.direction;
     if (direction === "DESC") {
       directionMap.set(name, direction);
     }
   }
-
   return directionMap;
 }
-
 function formatIndexField(field, orderDirectionMap) {
   var direction = orderDirectionMap.get(field);
   return "`".concat(field, "`").concat(direction ? " ".concat(direction) : "");
 }
+
 /**
  * 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++;
@@ -272,13 +247,12 @@ function splitSelectClause(clause) {
       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
@@ -288,93 +262,93 @@ function splitSelectClause(clause) {
  * @param {string} options.collection - The collection name
  * @returns {string|null} - The CREATE INDEX statement, or null if cannot build
  */
-
-
 function buildCoveringIndex(query, options) {
-  var _ref, _buildCoveringIndexDe;
+  var _buildCoveringIndexDe, _buildCoveringIndexDe2;
+  return (_buildCoveringIndexDe = (_buildCoveringIndexDe2 = buildCoveringIndexDefinition(query, options)) === null || _buildCoveringIndexDe2 === void 0 ? void 0 : _buildCoveringIndexDe2.statement) !== null && _buildCoveringIndexDe !== void 0 ? _buildCoveringIndexDe : null;
+}
 
-  return (_ref = (_buildCoveringIndexDe = buildCoveringIndexDefinition(query, options)) === null || _buildCoveringIndexDe === void 0 ? void 0 : _buildCoveringIndexDe.statement) !== null && _ref !== void 0 ? _ref : null;
-} // Keep the access keys separate from projection-only keys so an older, wider
+// Keep the access keys separate from projection-only keys so an older, wider
 // index can satisfy the same request without depending on its generated name.
-
-
 function buildCoveringIndexDefinition(query, options) {
-  var {
-    bucket,
-    scope = "_default",
-    collection = "_default"
-  } = options;
-
+  var bucket = options.bucket,
+    _options$scope = options.scope,
+    scope = _options$scope === void 0 ? "_default" : _options$scope,
+    _options$collection = options.collection,
+    collection = _options$collection === void 0 ? "_default" : _options$collection;
   if (!bucket) {
     return null;
-  } // Extract fields from SELECT clause
-
+  }
 
+  // Extract fields from SELECT clause
   var selectFields = extractSelectFields(query);
-
   if (selectFields === null) {
     // Full-document projections cannot be covered by the extracted fields.
     // Skip them instead of creating a non-covering fallback index.
     return null;
-  } // Extract fields from WHERE clause
-
+  }
 
-  var whereFields = extractWhereFields(query); // Extract fields from GROUP BY clause
+  // Extract fields from WHERE clause
+  var whereFields = extractWhereFields(query);
 
-  var groupByFields = extractGroupByFields(query); // Extract fields from ORDER BY clause, preserving DESC sort direction
+  // Extract fields from GROUP BY clause
+  var groupByFields = extractGroupByFields(query);
 
+  // Extract fields from ORDER BY clause, preserving DESC sort direction
   var orderByIndexFields = extractOrderByIndexFields(query);
   var orderDirectionMap = buildOrderDirectionMap(orderByIndexFields);
-  var orderByFields = orderByIndexFields.map(field => field.name); // Remove 'deleted' from whereFields as it will be added first with INCLUDE MISSING
+  var orderByFields = orderByIndexFields.map(field => field.name);
 
-  var filteredWhereFields = whereFields.filter(f => f !== "deleted"); // Track fields already added to avoid duplicates
+  // Remove 'deleted' from whereFields as it will be added first with INCLUDE MISSING
+  var filteredWhereFields = whereFields.filter(f => f !== "deleted");
 
-  var addedFields = new Set(filteredWhereFields); // Filter GROUP BY fields (remove duplicates from WHERE, remove deleted)
+  // Track fields already added to avoid duplicates
+  var addedFields = new Set(filteredWhereFields);
 
+  // Filter GROUP BY fields (remove duplicates from WHERE, remove deleted)
   var filteredGroupByFields = groupByFields.filter(f => {
     if (addedFields.has(f) || f === "deleted") {
       return false;
     }
-
     addedFields.add(f);
     return true;
-  }); // Filter ORDER BY fields (remove duplicates from WHERE and GROUP BY, remove deleted)
+  });
 
+  // Filter ORDER BY fields (remove duplicates from WHERE and GROUP BY, remove deleted)
   var filteredOrderByFields = orderByFields.filter(f => {
     if (addedFields.has(f) || f === "deleted") {
       return false;
     }
-
     addedFields.add(f);
     return true;
-  }); // Filter SELECT fields (remove duplicates from WHERE, GROUP BY, and ORDER BY, remove deleted)
+  });
 
+  // Filter SELECT fields (remove duplicates from WHERE, GROUP BY, and ORDER BY, remove deleted)
   var selectFieldsFiltered = selectFields.filter(f => {
     if (addedFields.has(f) || f === "deleted") {
       return false;
     }
-
     addedFields.add(f);
     return true;
-  }).sort(); // Projection order has no effect on coverage. Keep access-key order intact.
+  }).sort();
 
+  // Projection order has no effect on coverage. Keep access-key order intact.
   var allFields = [...filteredWhereFields, ...filteredGroupByFields, ...filteredOrderByFields, ...selectFieldsFiltered];
-
   if (allFields.length === 0) {
     // No fields to index besides deleted
     return null;
-  } // Build the field list with deleted INCLUDE MISSING first
+  }
 
+  // Build the field list with deleted INCLUDE MISSING first
+  var keys = ["`deleted` INCLUDE MISSING", ...allFields.map(f => formatIndexField(f, orderDirectionMap))];
 
-  var keys = ["`deleted` INCLUDE MISSING", ...allFields.map(f => formatIndexField(f, orderDirectionMap))]; // Hash the actual ordered definition, not query syntax. In particular, an
+  // Hash the actual ordered definition, not query syntax. In particular, an
   // explicit ORDER BY ... ASC must not rename an otherwise identical index.
-
   var indexKey = JSON.stringify([bucket, scope, collection, keys]);
   var hash = generateHash(indexKey);
-  var indexName = "adv_covered_".concat(hash); // Build the CREATE INDEX statement
+  var indexName = "adv_covered_".concat(hash);
 
+  // Build the CREATE INDEX statement
   var quote = identifier => "`".concat(identifier.replace(/`/g, "``"), "`");
-
   var indexStatement = "CREATE INDEX `".concat(indexName, "` ON `default`:").concat(quote(bucket), ".").concat(quote(scope), ".").concat(quote(collection), "(").concat(keys.join(", "), ")");
   return {
     name: indexName,
@@ -385,56 +359,50 @@ function buildCoveringIndexDefinition(query, options) {
     scope,
     collection
   };
-} // Only compare simple scalar keys. Do not treat expressions, array indexes,
-// partial indexes, or case-distinct document fields as equivalent.
-
+}
 
+// Only compare simple scalar keys. Do not treat expressions, array indexes,
+// partial indexes, or case-distinct document fields as equivalent.
 function normalizeIndexKey(key) {
   if (typeof key !== "string") return null;
-  var match = key.trim().match(/^(\(*[\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]*(?:`(?:[\0-_a-\uFFFF]|``)+`|[A-Z_a-z][0-9A-Z_a-z]*)[\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]*\)*)([\s\S]*?)$/);
+  var match = key.trim().match(/^(\(*\s*(?:`(?:[^`]|``)+`|[A-Za-z_]\w*)\s*\)*)([^]*?)$/);
   if (!match) return null;
   var expression = match[1].trim();
-
   while (expression.startsWith("(") && expression.endsWith(")")) {
     expression = expression.slice(1, -1).trim();
   }
-
   var identifier = expression.match(/^(?:`((?:[^`]|``)+)`|([A-Za-z_]\w*))$/);
   if (!identifier) return null;
   var attributes = match[2].trim().toUpperCase();
-
   if (!/^(?:(?:ASC|DESC)(?:\s+INCLUDE\s+MISSING)?|INCLUDE\s+MISSING(?:\s+(?:ASC|DESC))?)?$/.test(attributes)) {
     return null;
   }
-
   return {
     field: identifier[1] !== undefined ? identifier[1].replace(/``/g, "`") : identifier[2],
     direction: /\bDESC\b/.test(attributes) ? "DESC" : "ASC",
     includeMissing: /\bINCLUDE\s+MISSING\b/.test(attributes)
   };
-} // Call with indexes from the candidate's exact bucket/scope/collection. State
+}
+
+// Call with indexes from the candidate's exact bucket/scope/collection. State
 // is deliberately not filtered: a matching deferred/building index is already
 // committed work, even though EXPLAIN cannot use it yet.
-
-
 function indexSatisfiesCoveringDefinition(index, candidate) {
   if (index.is_primary || index.condition || index.using !== "gsi" || !Array.isArray(index.index_key)) {
     return false;
   }
-
   var existingKeys = index.index_key.map(normalizeIndexKey);
   var requiredKeys = candidate.keys.map(normalizeIndexKey);
   if (existingKeys.some(key => !key) || requiredKeys.some(key => !key)) return false;
-
   for (var i = 0; i < candidate.accessKeyCount; i++) {
     var existing = existingKeys[i];
     var required = requiredKeys[i];
     if (!existing || existing.field !== required.field || existing.direction !== required.direction || existing.includeMissing !== required.includeMissing) return false;
   }
-
   var existingFields = new Set(existingKeys.map(key => key.field));
   return requiredKeys.slice(candidate.accessKeyCount).every(key => existingFields.has(key.field));
 }
+
 /**
  * Normalizes an exemption list into a Set of lower-case resource names.
  * Accepts an array, a Set, or a comma-separated string (the env var form).
@@ -442,26 +410,22 @@ function indexSatisfiesCoveringDefinition(index, candidate) {
  * @param {string|string[]|Set<string>} value
  * @returns {Set<string>}
  */
-
-
 function parseResourceList(value) {
   var names = new Set();
   var items = [];
-
   if (Array.isArray(value) || value instanceof Set) {
     items = [...value];
   } else if (typeof value === "string") {
     items = value.split(",");
   }
-
   for (var item of items) {
     if (typeof item !== "string") continue;
     var name = item.trim().replace(/^`+|`+$/g, "").trim().toLowerCase();
     if (name) names.add(name);
   }
-
   return names;
 }
+
 /**
  * Extracts the resource names a statement touches, lower-cased:
  * - the last path segment of every FROM / JOIN keyspace, unquoted, so
@@ -472,34 +436,100 @@ function parseResourceList(value) {
  * @param {string} query
  * @returns {Set<string>}
  */
-
-
 function extractStatementResources(query) {
   var names = new Set();
   if (typeof query !== "string") return names;
   var identifier = "(?:`(?:[^`]|``)+`|[A-Za-z_][\\w$-]*)";
   var keyspacePattern = new RegExp("\\b(?:FROM|JOIN)\\s+(".concat(identifier, "(?:\\s*[.:]\\s*").concat(identifier, ")*)"), "gi");
   var segmentPattern = new RegExp(identifier, "g");
-
   for (var match of query.matchAll(keyspacePattern)) {
     var segments = match[1].match(segmentPattern) || [];
     var last = (segments[segments.length - 1] || "").trim();
     var name = last.startsWith("`") ? last.slice(1, -1).replace(/``/g, "`") : last;
     if (name) names.add(name.toLowerCase());
   }
-
   var typePattern = /(?:`type`|\btype)\s*=\s*'((?:[^']|'')*)'/gi;
-
   for (var _match of query.matchAll(typePattern)) {
     var _name = _match[1].replace(/''/g, "'").trim();
-
     if (_name) names.add(_name.toLowerCase());
   }
-
   return names;
 }
 
+// Names the application's index manager owns. A statement whose plan already
+// scans one of these is being served by a deliberate index, so the slow-query
+// path leaves it alone. `ix_base` is the per-collection fallback and does not
+// count: a statement that only finds the fallback is exactly what to report.
+var MANAGED_INDEX_NAME = /^ix_(sort|eq|agg|core|obs)_[0-9a-f]{6}_[0-9a-f]{4}$/;
+
+// Replaces the primary index on every collection: usable by any statement
+// because the leading key includes MISSING, and ordered for the default list
+// sort (`created_at DESC`).
+var BASE_INDEX = Object.freeze({
+  name: "ix_base",
+  keys: Object.freeze([Object.freeze({
+    expr: "`created_at`",
+    desc: true,
+    include_missing: true
+  }), Object.freeze({
+    expr: "`deleted`"
+  })])
+});
+
+/**
+ * The statement with its literals replaced by `?`, so one query shape is
+ * examined once however many values it runs with. IN lists collapse to `[?]`.
+ * @param {string} query
+ * @returns {string}
+ */
+function statementShape(query) {
+  return String(query !== null && query !== void 0 ? query : "").replace(/'(?:[^'\\]|\\.|'')*'/g, "?").replace(/"(?:[^"\\]|\\.)*"/g, "?").replace(/\b\d+(?:\.\d+)?\b/g, "?").replace(/\[\s*\?(?:\s*,\s*\?)*\s*\]/g, "[?]").replace(/\s+/g, " ").trim();
+}
+
+/**
+ * Names of the indexes an EXPLAIN plan scans.
+ * @param {object} plan
+ * @returns {string[]}
+ */
+function planIndexNames(plan) {
+  var names = new Set();
+  var visit = node => {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+    if (/Scan/.test(String(node["#operator"] || "")) && typeof node.index === "string") {
+      names.add(node.index);
+    }
+    Object.values(node).forEach(visit);
+  };
+  visit(plan);
+  return [...names];
+}
+function usesManagedIndex(plan) {
+  return planIndexNames(plan).some(name => MANAGED_INDEX_NAME.test(name));
+}
+
+/**
+ * Renders one index key. Accepts a ready string or `{ expr, desc, include_missing }`.
+ * @param {string|{expr: string, desc?: boolean, include_missing?: boolean}} key
+ * @returns {string}
+ */
+function renderIndexKey(key) {
+  if (typeof key === "string") return key;
+  if (!key || typeof key.expr !== "string" || !key.expr.trim()) {
+    throw new TypeError("An index key needs an expression");
+  }
+  return "".concat(key.expr).concat(key.desc ? " DESC" : "").concat(key.include_missing ? " INCLUDE MISSING" : "");
+}
 module.exports = {
+  MANAGED_INDEX_NAME,
+  BASE_INDEX,
+  statementShape,
+  planIndexNames,
+  usesManagedIndex,
+  renderIndexKey,
   buildCoveringIndex,
   buildCoveringIndexDefinition,
   indexSatisfiesCoveringDefinition,