@yanit/jsondb 0.1.1

package/src/QueryCache.ts

@@ -0,0 +1,208 @@
+/**
+ * 查询结果缓存模块
+ * 缓存相同查询的结果，提升重复查询性能
+ */
+
+import { createHash } from 'crypto';
+
+/**
+ * 缓存条目接口
+ */
+interface CacheEntry {
+  data: unknown;
+  createdAt: number;
+  expiresAt: number;
+  lastAccessed: number;
+}
+
+/**
+ * 查询缓存选项
+ */
+interface QueryCacheOptions {
+  maxSize?: number;
+  ttl?: number;
+}
+
+/**
+ * 查询缓存类
+ */
+export class QueryCache {
+  maxSize: number;
+  ttl: number;
+  cache: Map<string, CacheEntry>;
+  hits: number;
+  misses: number;
+
+  constructor(options: QueryCacheOptions = {}) {
+    this.maxSize = options.maxSize || 1000;
+    this.ttl = options.ttl || 60000;
+    this.cache = new Map();
+    this.hits = 0;
+    this.misses = 0;
+  }
+
+  /**
+   * 生成查询缓存键
+   */
+  generateKey(collection: string, query: Record<string, unknown>, options: Record<string, unknown> = {}): string {
+    const keyData = JSON.stringify({
+      collection,
+      query,
+      options: {
+        sort: options.sort,
+        limit: options.limit,
+        skip: options.skip,
+        projection: options.projection
+      }
+    });
+
+    return createHash('sha256').update(keyData).digest('hex');
+  }
+
+  /**
+   * 获取缓存
+   */
+  get(key: string): unknown | null {
+    const entry = this.cache.get(key);
+
+    if (!entry) {
+      this.misses++;
+      return null;
+    }
+
+    // 检查是否过期
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      this.misses++;
+      return null;
+    }
+
+    // 更新访问时间（LRU）
+    entry.lastAccessed = Date.now();
+    this.hits++;
+
+    return entry.data;
+  }
+
+  /**
+   * 设置缓存
+   */
+  set(key: string, data: unknown, ttl?: number): void {
+    // 如果缓存已满，删除最久未使用的条目
+    if (this.cache.size >= this.maxSize) {
+      this._evictOldest();
+    }
+
+    this.cache.set(key, {
+      data,
+      createdAt: Date.now(),
+      expiresAt: Date.now() + (ttl || this.ttl),
+      lastAccessed: Date.now()
+    });
+  }
+
+  /**
+   * 删除缓存
+   */
+  delete(key: string): void {
+    this.cache.delete(key);
+  }
+
+  /**
+   * 清空缓存
+   */
+  clear(): void {
+    this.cache.clear();
+    this.hits = 0;
+    this.misses = 0;
+  }
+
+  /**
+   * 删除与集合相关的所有缓存
+   */
+  invalidateCollection(collection: string): void {
+    for (const [key] of this.cache.entries()) {
+      if (key.includes(collection)) {
+        this.cache.delete(key);
+      }
+    }
+  }
+
+  /**
+   * 删除最久未使用的条目（LRU）
+   */
+  private _evictOldest(): void {
+    let oldestKey: string | null = null;
+    let oldestTime = Infinity;
+
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.lastAccessed < oldestTime) {
+        oldestTime = entry.lastAccessed;
+        oldestKey = key;
+      }
+    }
+
+    if (oldestKey) {
+      this.cache.delete(oldestKey);
+    }
+  }
+
+  /**
+   * 获取缓存统计
+   */
+  getStats(): {
+    size: number;
+    maxSize: number;
+    hits: number;
+    misses: number;
+    hitRate: string;
+    ttl: number;
+  } {
+    const total = this.hits + this.misses;
+    return {
+      size: this.cache.size,
+      maxSize: this.maxSize,
+      hits: this.hits,
+      misses: this.misses,
+      hitRate: total > 0 ? ((this.hits / total) * 100).toFixed(2) + '%' : '0%',
+      ttl: this.ttl
+    };
+  }
+}
+
+/**
+ * 全局查询缓存实例
+ */
+export const globalQueryCache = new QueryCache({
+  maxSize: 500,
+  ttl: 30000 // 30 秒
+});
+
+/**
+ * 缓存查询装饰器
+ */
+export function cacheQuery(
+  queryFn: (this: unknown, collection: { name: string }, query: Record<string, unknown>, queryOptions: Record<string, unknown>) => Promise<unknown>,
+  options: { cache?: QueryCache; ttl?: number } = {}
+) {
+  const cache = options.cache || globalQueryCache;
+  const ttl = options.ttl;
+
+  return async function(this: unknown, collection: { name: string }, query: Record<string, unknown>, queryOptions: Record<string, unknown>) {
+    const key = cache.generateKey(collection.name, query, queryOptions);
+
+    // 尝试从缓存获取
+    const cached = cache.get(key);
+    if (cached !== null) {
+      return cached;
+    }
+
+    // 执行查询
+    const result = await queryFn.call(this, collection, query, queryOptions);
+
+    // 存入缓存
+    cache.set(key, result, ttl);
+
+    return result;
+  };
+}

package/src/SQLExecutor.ts

@@ -0,0 +1,391 @@
+/**
+ * SQL 执行器模块
+ * 将解析后的 SQL 语句转换为 JSONDB Collection API 调用
+ */
+
+import type { Collection } from './Collection.js';
+import type {
+  SQLStatement,
+  SelectStatement,
+  InsertStatement,
+  UpdateStatement,
+  DeleteStatement,
+  WhereClause
+} from './SQLParser.js';
+import { parseSQL } from './SQLParser.js';
+import { matchQuery } from './Operators.js';
+
+/**
+ * SQL 执行结果
+ */
+export interface SQLExecutionResult {
+  success: boolean;
+  data?: unknown[];
+  affectedRows?: number;
+  insertId?: string;
+  error?: string;
+}
+
+/**
+ * SQL 执行器类
+ */
+export class SQLExecutor {
+  private collection: Collection;
+
+  constructor(collection: Collection) {
+    this.collection = collection;
+  }
+
+  /**
+   * 执行 SQL 语句
+   */
+  async execute(statement: SQLStatement): Promise<SQLExecutionResult> {
+    try {
+      switch (statement.type) {
+        case 'SELECT':
+          return await this.executeSelect(statement);
+        case 'INSERT':
+          return await this.executeInsert(statement);
+        case 'UPDATE':
+          return await this.executeUpdate(statement);
+        case 'DELETE':
+          return await this.executeDelete(statement);
+        default:
+          return { 
+            success: false, 
+            error: `不支持的 SQL 语句类型：${(statement as SQLStatement).type}` 
+          };
+      }
+    } catch (error) {
+      return { 
+        success: false, 
+        error: `SQL 执行错误：${(error as Error).message}` 
+      };
+    }
+  }
+
+  /**
+   * 执行 SELECT 语句
+   */
+  private async executeSelect(statement: SelectStatement): Promise<SQLExecutionResult> {
+    // 构建查询
+    let cursor = this.collection.find({});
+
+    // 应用 WHERE 子句
+    if (statement.where) {
+      const query = this.whereToQuery(statement.where);
+      cursor = this.collection.find(query);
+    }
+
+    // 应用 ORDER BY
+    if (statement.orderBy && statement.orderBy.length > 0) {
+      const sortSpec: Record<string, number> = {};
+      for (const { column, direction } of statement.orderBy) {
+        sortSpec[column] = direction === 'DESC' ? -1 : 1;
+      }
+      cursor = cursor.sort(sortSpec);
+    }
+
+    // 应用 LIMIT
+    if (statement.limit !== undefined) {
+      cursor = cursor.limit(statement.limit);
+    }
+
+    // 应用 OFFSET
+    if (statement.offset !== undefined) {
+      cursor = cursor.skip(statement.offset);
+    }
+
+    // 执行查询
+    let results = await cursor.toArray();
+
+    // 应用投影（列选择）
+    if (statement.columns && statement.columns.length > 0 && !statement.columns.includes('*')) {
+      const projection: Record<string, number> = {};
+      for (const col of statement.columns) {
+        projection[col] = 1;
+      }
+      results = results.map(doc => {
+        const projected: Record<string, unknown> = {};
+        for (const col of statement.columns) {
+          if (doc[col] !== undefined) {
+            projected[col] = doc[col];
+          }
+        }
+        return projected;
+      });
+    }
+
+    // 应用 DISTINCT
+    if (statement.distinct) {
+      const seen = new Set<string>();
+      results = results.filter(doc => {
+        const key = JSON.stringify(doc);
+        if (seen.has(key)) {
+          return false;
+        }
+        seen.add(key);
+        return true;
+      });
+    }
+
+    // 应用 GROUP BY (简化版)
+    if (statement.groupBy && statement.groupBy.length > 0) {
+      results = this.applyGroupBy(results, statement.groupBy);
+    }
+
+    return {
+      success: true,
+      data: results
+    };
+  }
+
+  /**
+   * 执行 INSERT 语句
+   */
+  private async executeInsert(statement: InsertStatement): Promise<SQLExecutionResult> {
+    const docs: Record<string, unknown>[] = [];
+
+    for (const row of statement.values) {
+      const doc: Record<string, unknown> = {};
+      for (let i = 0; i < statement.columns.length; i++) {
+        doc[statement.columns[i]] = row[i];
+      }
+      docs.push(doc);
+    }
+
+    if (docs.length === 1) {
+      const inserted = await this.collection.insertOne(docs[0]);
+      return {
+        success: true,
+        data: [inserted],
+        affectedRows: 1,
+        insertId: inserted._id as string
+      };
+    } else {
+      const result = await this.collection.insertMany(docs);
+      return {
+        success: true,
+        data: docs,
+        affectedRows: result.insertedCount,
+        insertId: result.insertedIds[0]
+      };
+    }
+  }
+
+  /**
+   * 执行 UPDATE 语句
+   */
+  private async executeUpdate(statement: UpdateStatement): Promise<SQLExecutionResult> {
+    // 构建 $set 对象
+    const $set: Record<string, unknown> = {};
+    for (const { column, value } of statement.set) {
+      $set[column] = value;
+    }
+
+    // 构建查询
+    let query: Record<string, unknown> = {};
+    if (statement.where) {
+      query = this.whereToQuery(statement.where);
+    }
+
+    const result = await this.collection.updateMany(query, { $set });
+
+    return {
+      success: true,
+      affectedRows: result.modifiedCount
+    };
+  }
+
+  /**
+   * 执行 DELETE 语句
+   */
+  private async executeDelete(statement: DeleteStatement): Promise<SQLExecutionResult> {
+    // 构建查询
+    let query: Record<string, unknown> = {};
+    if (statement.where) {
+      query = this.whereToQuery(statement.where);
+    }
+
+    const result = await this.collection.deleteMany(query);
+
+    return {
+      success: true,
+      affectedRows: result.deletedCount
+    };
+  }
+
+  /**
+   * 将 WHERE 子句转换为 MongoDB 风格查询
+   */
+  private whereToQuery(where: WhereClause): Record<string, unknown> {
+    switch (where.type) {
+      case 'condition':
+        return this.conditionToQuery(where.column, where.operator, where.value);
+
+      case 'and':
+        if (where.conditions.length === 0) return {};
+        if (where.conditions.length === 1) {
+          return this.whereToQuery(where.conditions[0]);
+        }
+        return {
+          $and: where.conditions.map(c => this.whereToQuery(c))
+        };
+
+      case 'or':
+        if (where.conditions.length === 0) return {};
+        if (where.conditions.length === 1) {
+          return this.whereToQuery(where.conditions[0]);
+        }
+        return {
+          $or: where.conditions.map(c => this.whereToQuery(c))
+        };
+
+      case 'not':
+        const condition = this.whereToQuery(where.condition);
+        return { $nor: [condition] };
+
+      default:
+        return {};
+    }
+  }
+
+  /**
+   * 将单个条件转换为查询对象
+   */
+  private conditionToQuery(column: string, operator: string, value: unknown): Record<string, unknown> {
+    const query: Record<string, unknown> = {};
+
+    switch (operator.toUpperCase()) {
+      case '=':
+        query[column] = value;
+        break;
+
+      case '!=':
+      case '<>':
+        query[column] = { $ne: value };
+        break;
+
+      case '<':
+        query[column] = { $lt: value };
+        break;
+
+      case '<=':
+        query[column] = { $lte: value };
+        break;
+
+      case '>':
+        query[column] = { $gt: value };
+        break;
+
+      case '>=':
+        query[column] = { $gte: value };
+        break;
+
+      case 'LIKE':
+        // 转换 SQL LIKE 到正则表达式
+        if (typeof value === 'string') {
+          let regex = value
+            .replace(/[.+?^${}()|[\]\\]/g, '\\$&') // 转义特殊字符
+            .replace(/%/g, '.*') // % 匹配任意字符
+            .replace(/_/g, '.'); // _ 匹配单个字符
+          query[column] = { $regex: new RegExp(`^${regex}$`, 'i') };
+        }
+        break;
+
+      case 'IN':
+        if (Array.isArray(value)) {
+          query[column] = { $in: value };
+        }
+        break;
+
+      case 'NOT IN':
+        if (Array.isArray(value)) {
+          query[column] = { $nin: value };
+        }
+        break;
+
+      case 'IS':
+        if (value === null) {
+          query[column] = { $exists: false };
+        } else if (value === true) {
+          query[column] = { $exists: true };
+        }
+        break;
+
+      case 'IS NOT':
+        if (value === null) {
+          query[column] = { $exists: true };
+        }
+        break;
+
+      case 'BETWEEN':
+        // 假设 value 是 [min, max] 数组
+        if (Array.isArray(value) && value.length === 2) {
+          query[column] = {
+            $gte: value[0],
+            $lte: value[1]
+          };
+        }
+        break;
+
+      default:
+        query[column] = { [`$${operator.toLowerCase()}`]: value };
+    }
+
+    return query;
+  }
+
+  /**
+   * 应用 GROUP BY (简化实现)
+   */
+  private applyGroupBy(
+    docs: Array<Record<string, unknown>>, 
+    groupBy: string[]
+  ): Array<Record<string, unknown>> {
+    const groups = new Map<string, Array<Record<string, unknown>>>();
+
+    for (const doc of docs) {
+      const key = groupBy.map(col => JSON.stringify(doc[col])).join('|');
+      if (!groups.has(key)) {
+        groups.set(key, []);
+      }
+      groups.get(key)!.push(doc);
+    }
+
+    return Array.from(groups.entries()).map(([key, groupDocs]) => {
+      const result: Record<string, unknown> = {};
+      
+      // 添加分组字段
+      const keyParts = key.split('|');
+      groupBy.forEach((col, i) => {
+        result[col] = JSON.parse(keyParts[i]);
+      });
+
+      // 添加聚合字段（简化：只添加计数）
+      result._count = groupDocs.length;
+
+      return result;
+    });
+  }
+}
+
+/**
+ * 在 Collection 上执行 SQL
+ */
+export async function executeSQL(
+  collection: Collection,
+  sql: string
+): Promise<SQLExecutionResult> {
+  const parseResult = parseSQL(sql);
+
+  if (!parseResult.success || !parseResult.statement) {
+    return {
+      success: false,
+      error: parseResult.error || 'SQL 解析失败'
+    };
+  }
+
+  const executor = new SQLExecutor(collection);
+  return await executor.execute(parseResult.statement);
+}