@qwe8652591/abap-recursive-query 1.1.0

package/dist/cli/query-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-object.d.ts","sourceRoot":"","sources":["../../src/cli/query-object.ts"],"names":[],"mappings":""}

package/dist/cli/query-object.js

@@ -0,0 +1,486 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+// ⚠️ 重要：必须在所有其他导入之前加载环境变量
+const dotenv = __importStar(require("dotenv"));
+const path_1 = require("path");
+const envPath = (0, path_1.join)(__dirname, '../../.env');
+dotenv.config({ path: envPath });
+// 加载环境变量后再导入其他模块（这些模块会读取 process.env）
+const uuid_1 = require("uuid");
+const common_1 = require("../common");
+const producer_1 = require("../producer");
+const consumer_1 = require("../consumer");
+/**
+ * 命令行参数解析
+ */
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let queryType = '';
+    let queryName = '';
+    let maxDepth = 1;
+    let downloadIncludes = true;
+    let enableCircularCheck = true;
+    let concurrentLimit = 10;
+    let requestInterval = 100;
+    let downloadPath = './downloads';
+    let excludeNames = [];
+    let excludePatterns = [];
+    let jobId = undefined;
+    let organizeByProgram = true;
+    // 解析命令行参数
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '--type':
+            case '-t':
+                queryType = args[++i];
+                break;
+            case '--name':
+            case '-n':
+                queryName = args[++i];
+                break;
+            case '--exclude-name':
+            case '-e':
+                excludeNames.push(args[++i]);
+                break;
+            case '--exclude-pattern':
+            case '-x':
+                excludePatterns.push(args[++i]);
+                break;
+            case '--max-depth':
+            case '-d':
+                const depthValue = parseInt(args[++i]);
+                maxDepth = isNaN(depthValue) ? 1 : depthValue;
+                break;
+            case '--download-includes':
+            case '-i':
+                downloadIncludes = true;
+                break;
+            case '--no-circular-check':
+                enableCircularCheck = false;
+                break;
+            case '--concurrent-limit':
+            case '-c':
+                const concurrentValue = parseInt(args[++i]);
+                concurrentLimit = isNaN(concurrentValue) ? 10 : concurrentValue;
+                break;
+            case '--request-interval':
+                const intervalValue = parseInt(args[++i]);
+                requestInterval = isNaN(intervalValue) ? 100 : intervalValue;
+                break;
+            case '--download-path':
+            case '-p':
+                downloadPath = args[++i] || './downloads';
+                break;
+            case '--organize-by-program':
+            case '-o':
+                organizeByProgram = args[++i]?.toLowerCase() !== 'false';
+                break;
+            case '--job-id':
+            case '-j':
+                jobId = args[++i];
+                break;
+            case '--help':
+            case '-h':
+                showHelp();
+                process.exit(0);
+                break;
+            default:
+                if (!arg.startsWith('-') && !queryType) {
+                    queryType = arg;
+                }
+                else if (!arg.startsWith('-') && !queryName) {
+                    queryName = arg;
+                }
+                break;
+        }
+    }
+    if (!queryType || !queryName) {
+        console.error('错误：查询类型和查询名称都是必需的参数');
+        showHelp();
+        process.exit(1);
+    }
+    return {
+        queryType,
+        queryName,
+        maxDepth,
+        downloadIncludes,
+        enableCircularCheck,
+        concurrentLimit,
+        requestInterval,
+        downloadPath,
+        excludeNames,
+        excludePatterns,
+        jobId,
+        organizeByProgram
+    };
+}
+/**
+ * 显示帮助信息
+ */
+function showHelp() {
+    console.error(`
+SAP对象递归查询工具
+
+用法：
+  npm run query -- --type <查询类型> --name <查询名称> [选项]
+  npm run query -- -t <查询类型> -n <查询名称> [选项]
+  npm run query -- <查询类型> <查询名称> [选项]
+
+基本参数：
+  --type, -t        查询类型（必需）如：PROG, CLAS, FUGR, FUNC
+  --name, -n        查询名称（必需）
+  --help, -h        显示帮助信息
+
+递归配置：
+  --max-depth, -d              最大递归深度（默认：3）
+  --download-includes, -i      下载包含文件
+  --no-circular-check          禁用循环引用检测
+  --concurrent-limit, -c       并发请求限制（默认：10）
+  --request-interval           请求间隔时间（毫秒，默认：100）
+  --download-path, -p          下载路径（默认：./downloads）
+  --organize-by-program, -o    是否按程序分目录（默认：true）
+                               true: downloads/PROGRAM_NAME/...
+                               false: downloads/...
+  --job-id, -j                 指定 Job ID（可选，不指定则自动生成）
+
+过滤配置（在默认规则基础上添加）：
+  --exclude-name, -e        排除特定对象名称（精确匹配，可多次使用）
+  --exclude-pattern, -x     排除对象名称模式（支持通配符 * 和 ?，可多次使用）
+
+注：系统默认会过滤 SAP*、RS*、CL_GUI_*、CL_ABAP_* 等标准对象
+
+示例：
+  # 基本查询
+  npm run query -- --type PROG --name Z_MY_PROGRAM
+  npm run query -- -t CLAS -n ZCL_MY_CLASS
+  npm run query -- FUGR Z_MY_FUNCTION_GROUP
+
+  # 带深度和下载配置
+  npm run query -- -t CLAS -n ZCL_MY_CLASS -d 5 -i
+
+  # 不按程序分目录（所有文件在同一目录下）
+  npm run query -- -t PROG -n Z_MY_PROGRAM -o false
+
+  # 指定自定义 Job ID
+  npm run query -- -t PROG -n SAPLMEGUI -j my-custom-job-id
+
+  # 添加自定义过滤规则
+  npm run query -- -t PROG -n Z_MY_PROGRAM -e Z_OLD_PROGRAM -x "*_TEST"
+  npm run query -- -t CLAS -n ZCL_MY_CLASS -e Z_LEGACY -e Z_OBSOLETE -x "*_TMP" -x "TEMP_*"
+
+  # 完整示例
+  npm run query -- --type PROG --name Z_MY_PROGRAM \\
+                   --max-depth 4 \\
+                   --download-includes \\
+                   --exclude-name Z_OLD_PROGRAM \\
+                   --exclude-pattern "*_TEST" \\
+                   --exclude-pattern "*_TMP"
+
+环境变量配置：
+  需要在.env文件中配置以下变量：
+  - SAP_URL: SAP系统URL
+  - SAP_USERNAME: 用户名
+  - SAP_PASSWORD: 密码
+  - SAP_CLIENT: 客户端
+`);
+}
+/**
+ * 格式化输出结果（递归查询）
+ */
+function formatRecursiveOutput(result) {
+    if (!result.success) {
+        console.error('递归查询失败：', result.error);
+        process.exit(1);
+    }
+    try {
+        const data = result.data;
+        console.error('\n=== 递归查询结果 ===\n');
+        console.error(`✅ 查询成功: ${result.message}`);
+        console.error(`📊 统计信息:`);
+        console.error(`   - 总对象数: ${data.statistics.totalObjects}`);
+        console.error(`   - 总类数: ${data.statistics.totalClasses}`);
+        console.error(`   - 总函数数: ${data.statistics.totalFunctions}`);
+        console.error(`   - 总包含文件数: ${data.statistics.totalIncludes}`);
+        console.error(`   - 最大深度: ${data.statistics.maxDepthReached}`);
+        console.error(`   - 循环引用: ${data.statistics.circularReferences}`);
+        if (data.downloaded_files && data.downloaded_files.length > 0) {
+            // 分离成功和失败的文件
+            const successFiles = data.downloaded_files.filter((file) => file.success);
+            const failedFiles = data.downloaded_files.filter((file) => !file.success);
+            console.error(`💾 下载文件: ${data.downloaded_files.length}个 (成功: ${successFiles.length}, 失败: ${failedFiles.length})`);
+            // 成功的文件：超过20个只显示统计，否则显示详情
+            if (successFiles.length > 0) {
+                if (successFiles.length > 20) {
+                    console.error(`   ✅ 成功下载: ${successFiles.length}个文件 (列表省略)`);
+                }
+                else {
+                    console.error(`   ✅ 成功下载 (${successFiles.length}个):`);
+                    successFiles.forEach((file, index) => {
+                        console.error(`      ${index + 1}. ${file.objectType}/${file.objectName}.abap`);
+                    });
+                }
+            }
+            // 失败的文件：始终显示详情
+            if (failedFiles.length > 0) {
+                console.error(`   ❌ 下载失败 (${failedFiles.length}个):`);
+                failedFiles.forEach((file, index) => {
+                    const errorInfo = file.error ? ` - 错误: ${file.error}` : '';
+                    console.error(`      ${index + 1}. ${file.objectType}/${file.objectName}.abap${errorInfo}`);
+                });
+            }
+        }
+        // 只在对象数量较少或需要详细信息时输出对象列表
+        if (data.all_objects.length <= 20) {
+            console.error(`🔍 发现的对象 (${data.all_objects.length}个):`);
+            data.all_objects.forEach((obj, index) => {
+                const objectKey = obj.object_key;
+                const objectData = obj.object_data;
+                console.error(`   ${index + 1}. ${objectKey}`);
+                // 显示关键信息
+                if (objectData.FUNCTIONNAME) {
+                    console.error(`      函数: ${objectData.FUNCTIONNAME} - ${objectData.FUNCTIONTITLE || '无标题'}`);
+                }
+                else if (objectData.CLASSNAME) {
+                    console.error(`      类: ${objectData.CLASSNAME} - ${objectData.DESCRIPTION || '无描述'}`);
+                }
+                else if (objectData.TABNAME) {
+                    console.error(`      表: ${objectData.TABNAME}`);
+                }
+            });
+        }
+        else {
+            console.error(`🔍 发现的对象: ${data.all_objects.length}个 (数量较多，省略详细列表)`);
+        }
+        // 显示被过滤的对象
+        if (data.filtered_objects && data.filtered_objects.length > 0) {
+            console.error(`\n🚫 被过滤的对象 (${data.filtered_objects.length}个，未进行递归查询):`);
+            // 统计
+            const exactFiltered = data.filtered_objects.filter((obj) => obj.filterType === 'exact');
+            const patternFiltered = data.filtered_objects.filter((obj) => obj.filterType === 'pattern');
+            console.error(`   📌 精确匹配: ${exactFiltered.length}个`);
+            console.error(`   🔍 模式匹配: ${patternFiltered.length}个`);
+            // 显示详情（最多显示前20个）
+            const displayCount = Math.min(data.filtered_objects.length, 20);
+            if (displayCount < data.filtered_objects.length) {
+                console.error(`   (仅显示前${displayCount}个，共${data.filtered_objects.length}个)`);
+            }
+            data.filtered_objects.slice(0, displayCount).forEach((obj, index) => {
+                const icon = obj.filterType === 'exact' ? '📌' : '🔍';
+                const ruleInfo = obj.filterRule ? ` [规则: ${obj.filterRule}]` : '';
+                console.error(`   ${icon} ${index + 1}. ${obj.objectType}:${obj.objectName}${ruleInfo}`);
+            });
+        }
+        if (data.errors && data.errors.length > 0) {
+            console.error(`\n⚠️  错误 (${data.errors.length}个):`);
+            data.errors.forEach((error, index) => {
+                console.error(`   ${index + 1}. ${error}`);
+            });
+        }
+        console.error(`\n📝 ${data.summary}`);
+    }
+    catch (error) {
+        console.error('格式化输出失败：', error);
+        console.error('原始数据：', JSON.stringify(result, null, 2));
+    }
+}
+/**
+ * 执行递归查询（使用 Redis 队列系统）
+ */
+async function executeRecursiveQuery(objectType, objectName, config, consumerCount = 10, jobId, organizeByProgram = true) {
+    console.error(`[Queue] 开始递归查询 - 类型: ${objectType}, 名称: ${objectName}`);
+    // 1. 创建 RedisQueueManager
+    const queueManager = new common_1.RedisQueueManager();
+    // 2. 创建生产者
+    const producer = new producer_1.RecursiveQueryProducer(queueManager);
+    // 3. 准备消费者
+    const consumers = [];
+    console.error(`[Queue] 启动 ${consumerCount} 个消费者...`);
+    try {
+        // 4. 创建 Job（使用指定的 jobId 或生成新的）
+        const finalJobId = jobId || (0, uuid_1.v4)();
+        if (jobId) {
+            console.error(`[Queue] 使用指定的 Job ID: ${finalJobId}`);
+        }
+        else {
+            console.error(`[Queue] 生成的 Job ID: ${finalJobId}`);
+        }
+        await producer.createJob(finalJobId, objectType, objectName, config);
+        console.error(`[Queue] Job 已创建: ${finalJobId}`);
+        // 5. 启动消费者（立即开始监听队列）
+        console.error(`[Queue] 启动 ${consumerCount} 个消费者（与生产者并行）...`);
+        const consumerPromises = [];
+        for (let i = 0; i < consumerCount; i++) {
+            const consumer = new consumer_1.FileDownloadConsumer(queueManager, config.downloadRootPath, [finalJobId], organizeByProgram);
+            consumers.push(consumer);
+            consumerPromises.push(consumer.start([finalJobId]).catch(err => {
+                console.error(`[Queue] 消费者 ${i + 1} 错误:`, err);
+            }));
+        }
+        // 6. 启动生产者递归查询（虽然会阻塞，但消费者已经在并行工作）
+        console.error(`[Queue] 生产者开始递归查询（消费者已在监听）...`);
+        await producer.generateAllTasks(finalJobId, objectType, objectName, config);
+        console.error(`[Queue] 生产者任务生成完成`);
+        // 7. 等待消费者处理完所有任务
+        console.error(`[Queue] 等待消费者处理剩余任务...`);
+        const job = await producer.waitForCompletion(finalJobId);
+        // 8. 停止所有消费者
+        console.error(`[Queue] 停止消费者...`);
+        for (const consumer of consumers) {
+            await consumer.stop();
+        }
+        await Promise.allSettled(consumerPromises);
+        // 9. 收集结果
+        const downloadedFiles = [];
+        for (const consumer of consumers) {
+            downloadedFiles.push(...consumer.getDownloadedFiles());
+        }
+        // 10. 生成统计信息
+        const statistics = {
+            totalObjects: job.totalTasks,
+            totalTasks: job.totalTasks,
+            completedTasks: job.completedTasks,
+            failedTasks: job.failedTasks,
+            skippedTasks: job.skippedTasks,
+            totalFiles: downloadedFiles.length,
+            successFiles: downloadedFiles.filter(f => f.success).length,
+            failedFiles: downloadedFiles.filter(f => !f.success).length,
+            totalClasses: 0,
+            totalFunctions: 0,
+            totalPrograms: 0,
+            totalIncludes: 0,
+            totalStructures: 0,
+            totalDomains: 0,
+            downloadedIncludes: 0,
+            downloadedStructures: 0,
+            downloadedDomains: 0,
+            maxDepthReached: config.maxRecursionDepth || 1,
+            circularReferences: 0
+        };
+        console.error(`[Queue] 递归查询完成`);
+        console.error(`[Queue] 统计: ${JSON.stringify(statistics, null, 2)}`);
+        // 11. 清理
+        await queueManager.cleanupJob(finalJobId);
+        await queueManager.close();
+        // 12. 返回结果
+        return {
+            success: true,
+            data: {
+                jobId: finalJobId,
+                original_object: null,
+                all_objects: [],
+                downloaded_files: downloadedFiles,
+                filtered_objects: [],
+                statistics,
+                errors: job.errors || [],
+                summary: `Job ${finalJobId} 完成 - 状态: ${job.status}, 完成任务: ${job.completedTasks}/${job.totalTasks}`
+            },
+            message: `递归查询完成 - 处理了 ${job.totalTasks} 个对象`
+        };
+    }
+    finally {
+        // 确保所有消费者都停止
+        for (const consumer of consumers) {
+            await consumer.stop();
+        }
+    }
+}
+/**
+ * 主函数
+ */
+async function main() {
+    console.error('SAP对象查询工具\n');
+    // 检查环境变量
+    const requiredEnvVars = ['SAP_URL', 'SAP_USERNAME', 'SAP_PASSWORD', 'SAP_CLIENT'];
+    const missingEnvVars = requiredEnvVars.filter(varName => !process.env[varName]);
+    if (missingEnvVars.length > 0) {
+        console.error('错误：缺少必需的环境变量：', missingEnvVars.join(', '));
+        console.error('请在.env文件中配置这些变量');
+        process.exit(1);
+    }
+    try {
+        const args = parseArgs();
+        console.error(`正在执行递归查询 ${args.queryType} 对象: ${args.queryName}...`);
+        console.error(`配置: 最大深度=${args.maxDepth}, 并发限制=${args.concurrentLimit}`);
+        if (args.downloadPath) {
+            console.error(`下载路径: ${args.downloadPath}`);
+        }
+        // 显示过滤配置
+        if (args.excludeNames && args.excludeNames.length > 0) {
+            console.error(`自定义过滤（精确匹配）: ${args.excludeNames.join(', ')}`);
+        }
+        if (args.excludePatterns && args.excludePatterns.length > 0) {
+            console.error(`自定义过滤（模式匹配）: ${args.excludePatterns.join(', ')}`);
+        }
+        // 构建过滤配置
+        const recursionFilters = {};
+        if (args.excludeNames && args.excludeNames.length > 0) {
+            recursionFilters.excludeNames = args.excludeNames;
+        }
+        if (args.excludePatterns && args.excludePatterns.length > 0) {
+            recursionFilters.excludeNamePatterns = args.excludePatterns;
+        }
+        // 构建配置
+        const config = {
+            maxRecursionDepth: args.maxDepth,
+            downloadRootPath: args.downloadPath,
+            downloadIncludes: args.downloadIncludes,
+            enableCircularReferenceCheck: args.enableCircularCheck,
+            concurrentRequestLimit: args.concurrentLimit,
+            requestInterval: args.requestInterval,
+            recursionFilters: Object.keys(recursionFilters).length > 0 ? recursionFilters : undefined
+        };
+        console.error(`\n[Queue] 配置: ${JSON.stringify(config, null, 2)}`);
+        // 执行递归查询（使用队列系统）
+        const result = await executeRecursiveQuery(args.queryType.toUpperCase(), args.queryName.toUpperCase(), config, 10, // 默认10个消费者
+        args.jobId, // 传入 jobId（可选）
+        args.organizeByProgram // 是否按程序分目录
+        );
+        formatRecursiveOutput(result);
+    }
+    catch (error) {
+        console.error('执行失败：', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+// 运行主函数
+if (require.main === module) {
+    main().catch(error => {
+        console.error('未捕获的错误：', error);
+        process.exit(1);
+    });
+}

package/dist/common/FilterCache.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 过滤规则缓存
+ * 预编译正则表达式，避免每次检查时重复编译
+ *
+ * 性能优化：
+ * - 预编译所有模式为正则表达式（一次性开销）
+ * - 缓存编译结果，避免重复编译
+ * - 支持通配符：* 匹配任意字符，? 匹配单个字符
+ *
+ * @example
+ * ```typescript
+ * const cache = new FilterCache(['SAP*', 'CL_?_TEST']);
+ * cache.matches('SAPLMEGUI'); // true (匹配 SAP*)
+ * cache.matches('CL_A_TEST'); // true (匹配 CL_?_TEST)
+ * cache.matches('MY_PROG');   // false
+ * ```
+ */
+export declare class FilterCache {
+    private compiledPatterns;
+    private exactMatches;
+    /**
+     * 构造函数
+     * @param exactNames 精确匹配的名称列表
+     * @param patterns 通配符模式列表
+     */
+    constructor(exactNames?: string[], patterns?: string[]);
+    /**
+     * 检查名称是否匹配任何过滤规则
+     * @param objectName 对象名称
+     * @returns true 表示匹配（应该过滤），false 表示不匹配
+     */
+    matches(objectName: string): boolean;
+    /**
+     * 获取匹配的模式（用于调试）
+     * @param objectName 对象名称
+     * @returns 匹配的模式列表
+     */
+    getMatchedPatterns(objectName: string): string[];
+    /**
+     * 将通配符模式转换为正则表达式
+     * @param pattern 通配符模式（支持 * 和 ?）
+     * @returns 正则表达式字符串
+     *
+     * @example
+     * SAP*       -> ^SAP.*$
+     * CL_?_TEST  -> ^CL_.\_TEST$
+     * *_TEMP     -> ^.*_TEMP$
+     */
+    private convertPatternToRegex;
+    /**
+     * 获取统计信息
+     */
+    getStats(): {
+        exactMatchCount: number;
+        patternCount: number;
+    };
+    /**
+     * 清空缓存
+     */
+    clear(): void;
+}
+//# sourceMappingURL=FilterCache.d.ts.map

package/dist/common/FilterCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterCache.d.ts","sourceRoot":"","sources":["../../src/common/FilterCache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,WAAW;IACpB,OAAO,CAAC,gBAAgB,CAGhB;IAER,OAAO,CAAC,YAAY,CAA0B;IAE9C;;;;OAIG;gBACS,UAAU,GAAE,MAAM,EAAO,EAAE,QAAQ,GAAE,MAAM,EAAO;IAgB9D;;;;OAIG;IACH,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAkBpC;;;;OAIG;IACH,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE;IAmBhD;;;;;;;;;OASG;IACH,OAAO,CAAC,qBAAqB;IAa7B;;OAEG;IACH,QAAQ,IAAI;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE;IAO7D;;OAEG;IACH,KAAK,IAAI,IAAI;CAIhB"}

package/dist/common/FilterCache.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterCache = void 0;
+/**
+ * 过滤规则缓存
+ * 预编译正则表达式，避免每次检查时重复编译
+ *
+ * 性能优化：
+ * - 预编译所有模式为正则表达式（一次性开销）
+ * - 缓存编译结果，避免重复编译
+ * - 支持通配符：* 匹配任意字符，? 匹配单个字符
+ *
+ * @example
+ * ```typescript
+ * const cache = new FilterCache(['SAP*', 'CL_?_TEST']);
+ * cache.matches('SAPLMEGUI'); // true (匹配 SAP*)
+ * cache.matches('CL_A_TEST'); // true (匹配 CL_?_TEST)
+ * cache.matches('MY_PROG');   // false
+ * ```
+ */
+class FilterCache {
+    compiledPatterns = [];
+    exactMatches = new Set(); // 精确匹配集合（O(1)查找）
+    /**
+     * 构造函数
+     * @param exactNames 精确匹配的名称列表
+     * @param patterns 通配符模式列表
+     */
+    constructor(exactNames = [], patterns = []) {
+        // 1. 构建精确匹配集合（O(1)查找）
+        exactNames.forEach(name => {
+            this.exactMatches.add(name.toUpperCase());
+        });
+        // 2. 预编译所有模式为正则表达式
+        this.compiledPatterns = patterns.map(pattern => {
+            const regexPattern = this.convertPatternToRegex(pattern);
+            return {
+                pattern,
+                regex: new RegExp(regexPattern, 'i') // 不区分大小写
+            };
+        });
+    }
+    /**
+     * 检查名称是否匹配任何过滤规则
+     * @param objectName 对象名称
+     * @returns true 表示匹配（应该过滤），false 表示不匹配
+     */
+    matches(objectName) {
+        const upperName = objectName.toUpperCase();
+        // 1. 快速路径：精确匹配检查（O(1)）
+        if (this.exactMatches.has(upperName)) {
+            return true;
+        }
+        // 2. 模式匹配检查（使用预编译的正则表达式）
+        for (const { regex } of this.compiledPatterns) {
+            if (regex.test(objectName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * 获取匹配的模式（用于调试）
+     * @param objectName 对象名称
+     * @returns 匹配的模式列表
+     */
+    getMatchedPatterns(objectName) {
+        const matched = [];
+        const upperName = objectName.toUpperCase();
+        // 检查精确匹配
+        if (this.exactMatches.has(upperName)) {
+            matched.push(`[精确匹配] ${upperName}`);
+        }
+        // 检查模式匹配
+        for (const { pattern, regex } of this.compiledPatterns) {
+            if (regex.test(objectName)) {
+                matched.push(`[模式匹配] ${pattern}`);
+            }
+        }
+        return matched;
+    }
+    /**
+     * 将通配符模式转换为正则表达式
+     * @param pattern 通配符模式（支持 * 和 ?）
+     * @returns 正则表达式字符串
+     *
+     * @example
+     * SAP*       -> ^SAP.*$
+     * CL_?_TEST  -> ^CL_.\_TEST$
+     * *_TEMP     -> ^.*_TEMP$
+     */
+    convertPatternToRegex(pattern) {
+        // 1. 转义特殊字符（除了 * 和 ?）
+        let regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+        // 2. 转换通配符
+        regexPattern = regexPattern
+            .replace(/\*/g, '.*') // * -> .* (匹配任意字符)
+            .replace(/\?/g, '.'); // ? -> .  (匹配单个字符)
+        // 3. 添加锚点（确保完全匹配）
+        return `^${regexPattern}$`;
+    }
+    /**
+     * 获取统计信息
+     */
+    getStats() {
+        return {
+            exactMatchCount: this.exactMatches.size,
+            patternCount: this.compiledPatterns.length
+        };
+    }
+    /**
+     * 清空缓存
+     */
+    clear() {
+        this.exactMatches.clear();
+        this.compiledPatterns = [];
+    }
+}
+exports.FilterCache = FilterCache;