添加向量库

qianbao
1 parent b9b48f2e
Showing 8 changed files with 581 additions and 206 deletions
pom.xml
src/main/java/com/xly/agent/ErpAiAgent.java
src/main/java/com/xly/milvus/service/MilvusService.java
src/main/java/com/xly/milvus/service/impl/AiGlobalAgentQuestionSqlEmitterServiceImpl.java
src/main/java/com/xly/milvus/service/impl/MilvusServiceImpl.java
src/main/java/com/xly/service/XlyErpService.java
src/main/java/com/xly/thread/AiUserAgentQuestionThread.java
src/main/java/com/xly/util/SqlWhereHelper.java
@@ -105,6 +105,12 @@
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-webflux</artifactId>
 		</dependency>
+		<!-- pom.xml -->
+		<dependency>
+			<groupId>com.github.jsqlparser</groupId>
+			<artifactId>jsqlparser</artifactId>
+			<version>4.9</version>
+		</dependency>
  
 		<!-- Tess4J OCR -->
 		<dependency>
@@ -93,24 +93,18 @@ public interface ErpAiAgent {
  
     @SystemMessage("""
                     你是一个智能查询路由专家。请根据【用户需求】，只返回 true 或 false。
-                    
                     【最高优先级规则 - 必须首先判断】
                     如果用户需求包含以下任一关键词，**直接返回 false**，不再进行其他判断：
-                    - 明细、详情、详细信息、详细内容、具体内容
-                    - 查询...明细、...详情、...记录、...列表、...清单
-                    
+                    - 明细、列表、清单
+                    - ...明细、...列表、...清单
                     重要：只要出现以上关键词，说明用户需要的是明细数据查询，而非统计分析。
-                    
                     【统计类关键词 - 仅在满足最高优先级规则后才判断】
                     只有当用户需求不包含上述明细类关键词时，才检查是否包含以下关键词：
                     统计、求和、汇总、排名、TopN、平均、数量、总额、最高、最低、占比、分组
-                    
                     - 如果包含，返回 true
                     - 否则返回 false
-                    
                     【判断示例】
                     - \"查询中科精工集团的彩盒类产品的报价单明细\" → false（包含\"明细\"）
-                    - \"统计各产品销售额\" → true（包含\"统计\"，且无明细关键词）
                     - \"查询客户张三信息\" → false（无统计关键词，无明细关键词）
                     - \"销售额排名前10的产品\" → true（包含\"排名\"，且无明细关键词）
                     - \"查看销售订单明细\" → false（包含\"明细\"）
@@ -119,90 +113,264 @@ public interface ErpAiAgent {
             【用户需求】
             {{userInput}}
             """)
+//    @SystemMessage("""
+//                你是一个智能查询路由专家，请根据【用户需求】，基于**查询效率最优**原则，自动判断使用关系型数据库(MySQL)还是向量库(Milvus)，只返回 true 或 false。
+//                满足如下规则中任意一条则返回true 否则返回false:
+//                - 查询涉及**排名、TOP N、求和、计数、平均值、最大值、总额、最小值、最高、最低、占比**
+//                - 查询涉及**分组统计(GROUP BY)、排序(ORDER BY)、分页(LIMIT)**
+//                    """)
+//    @UserMessage("""
+//                【用户需求】
+//                {{userInput}}
+//                """)
     Boolean routeQuery(@MemoryId String userId, @V("userInput") String userInput);
  
     /**
      * 生成 Milvus 过滤条件（适配 Milvus v2.3.9）
      */
     @SystemMessage("""
-            MILVUS 标量过滤条件生成规则（严格遵守 - 当前版本 v2.3.9）：
-            
-            【重要输出约束】
-            - 必须返回有效的 Milvus 过滤条件表达式
-            - 禁止返回 true 或 false
-            - 禁止返回空字符串以外的任何非表达式内容
-            - 无条件时只返回空字符串 ""
-            
-            1. 语法规范：
-               - 允许的操作符：==, !=, like
-               - 逻辑组合：&& (AND), || (OR)
-               - 所有字段都是字符串类型，值必须使用单引号包裹
-               - 字符串中的单引号需要转义：'O''Reilly'
-            
-            2. 【重要】Milvus v2.3.9 like 操作符限制：
-               - ✅ 支持：like '关键字%'（前缀匹配，以关键字开头）
-               - ❌ 不支持：like '%关键字%'（包含匹配）
-               - ❌ 不支持：like '%关键字'（后缀匹配）
-            
-            3. 可用字段（只能使用这些字段）：
-               - {{sMilvusFiled}}
-               字段说明：
-               - {{sMilvusFiledDescription}}
-            
-            4. 提取规则：
-               - 只使用上述可用字段，不要创建新字段
-               - 如果用户提到了文档类型（如"报价单"、"订单"等），但可用字段中没有类型字段，则忽略该条件
-               
-               【精确匹配规则】：
-               - 当用户提供明确值时：字段 == '值'
-                 * 例如："客户名称中科精工" → sCustomerName == '中科精工'
-                 * 例如："单据号 INV001" → sBillNo == 'INV001'
-            
-            5. 时间处理规则：
-               - 当前系统时间：{{sDataNow}}（格式：yyyy-MM-dd）
-               - 相对时间转换规则：
-                 * "今天/今日" → 当天 00:00:00 到 23:59:59
-                 * "昨天" → 前一天 00:00:00 到 23:59:59
-                 * "本周" → 本周一 00:00:00 到本周日 23:59:59
-                 * "本月" → 本月1日 00:00:00 到本月最后一天 23:59:59
-                 * "本年" → 本年1月1日 00:00:00 到本年12月31日 23:59:59
-                 * "近X天" → 从 X 天前 00:00:00 到今天 23:59:59
-               - 日期转时间戳：所有日期转换为 Unix 时间戳（秒）
-               - 时间范围格式：字段 >= 起始时间戳 && 字段 <= 结束时间戳
-               - 如果没有明确的时间需求，不要添加任何时间过滤条件
-            
-            6. 示例：
-               ✅ 正确输出：
-               - "客户名称中科精工" → sCustomerName == '中科精工'
-               - "中科精工的报价单明细" → sCustomerName == '中科精工'
-               - "产品以彩盒开头" → sProductStyle like '彩盒%'
-               - "无条件" → ""
-               
-               ❌ 错误输出（禁止）：
-               - "中科精工的报价单明细" → true
-               - "中科精工的报价单明细" → false
-               - "中科精工的报价单明细" → 1
-            
-            7. 输出格式：
-               - 仅返回纯过滤条件，无任何解释、换行、备注
-               - 单条件：sCustomerName == '中科精工'
-               - 多条件：(sCustomerName == '中科精工' && sProductStyle like '彩盒%')
-               - 无条件：直接返回空字符串 ""
+        MILVUS 查询条件生成规则：
+        
+        【最高优先级 - 输出格式铁律】
+        ⚠️ 你的【全部输出】必须是且仅是一个合法的 JSON 对象
+        ⚠️ 禁止输出任何解释、说明、思考过程
+        ⚠️ 禁止输出任何中文文字
+        ⚠️ 只能输出以下 JSON 格式，不能有其他任何内容
+        
+        【输出 JSON 结构】
+        {
+            "sMethodName": true/false,     // 必选，判断用户意图是否匹配当前方法
+            "vectorField": "向量字段名",     // 可选，需要语义匹配时返回
+            "vectorValue": "向量化文本",      // 可选，用于向量检索的文本
+            "filterExpression": "标量过滤表达式"  // 可选，有标量条件时返回
+        }
+        
+        【方法匹配规则 - 重要】
+        sMethodName 的取值逻辑：
+        - 如果用户输入的意图与 {{sMethodName}} 相关，返回 true
+        - 否则返回 false
+        
+        判断标准：用户是否在询问或操作与 {{sMethodName}} 相关的业务数据
+        - 包括但不限于：查询、搜索、推荐、找、查看、明细、列表、详情等
+        - 只要用户想获取或操作这类数据，就应该返回 true
+        
+        示例：
+        - 方法名称：查询报价单
+        - "报价单明细" → true（想查看报价单数据）
+        - "报价单列表" → true（想查看报价单数据）
+        - "报价单" → true（想查看报价单数据）
+        - "查一下报价单" → true（想查询报价单）
+        - "推荐相似报价单" → true（想推荐报价单）
+        - "你好" → false（与报价单无关）
+        - "查询客户信息" → false（与报价单无关）
+        
+        【重要：理解你的数据结构】
+        
+        你有两种类型的字段：
+        
+        1. 标量字段（用于精确过滤）：
+           - {{sMilvusFiled}} 中的字段
+           - 根据提供的字段说明使用
+        
+        2. 向量字段（用于语义搜索）：
+           - 字段名：使用 {{sMilvusFiledXl}} 中提供的向量字段名
+           - 存储格式：管道符分隔的键值对 "字段名:值|字段名:值|..."
+           - 包含的业务数据：{{sMilvusFiledDescriptionXl}}
+           - 示例："sCustomerName:上海小羚羊|sProductName:2028宣传海报|dProductQty:1000|sType:报价丢单原因"
+        
+        【向量搜索规则】
+        
+        使用向量搜索的条件：用户明确表达语义匹配意图
+        - 关键词：找相似、推荐、匹配、类似、相关、类似的、相似的、推荐一下
+        - 使用向量搜索时：
+          1. 从用户问题中提取关键业务实体
+          2. 格式化为："字段名:值|字段名:值"（管道符分隔）
+          3. 示例：
+             - 用户："找丢单原因类似价格太高的记录" → "sReason:价格太高|sType:报价丢单原因"
+             - 用户："推荐和上海小羚羊类似的客户" → "sCustomerName:上海小羚羊"
+             - 用户："找类似2028宣传海报的产品" → "sProductName:2028宣传海报"
+        
+        【标量过滤规则 - 极其重要】
+        
+        可用标量字段（根据 {{sMilvusFiled}} 动态提供）：
+        - 使用提供的字段名
+        - 【字符串字段】：统一使用 like 操作符（前缀匹配）
+        - 【数字字段】：使用 >、<、>=、<=、== 操作符
+        - 【时间字段】：使用时间戳范围
+        
+        【操作符使用规则】
+        
+        1. 字符串字段（统一使用 like）：
+           - 语法：字段名 like '关键词%'
+           - 说明：只支持前缀匹配，不支持 '%keyword%' 或 '%keyword'
+           - 示例：
+             - 用户："上海小羚羊" → sCustomerName like '上海小羚羊%'
+             - 用户："客户名称包含上海" → sCustomerName like '上海%'
+             - 用户："姓张的销售人员" → sSalesManName like '张%'
+             - 用户："产品名称以2028开头" → sProductName like '2028%'
+             - 用户："张三" → sSalesManName like '张三%'
+        
+        2. 数字字段：
+           - 精确匹配：字段名 == 值
+           - 范围匹配：字段名 >= 值 && 字段名 <= 值
+           - 大于：字段名 > 值
+           - 小于：字段名 < 值
+           - 示例：
+             - 用户："数量1000" → dProductQty == 1000
+             - 用户："数量大于1000" → dProductQty > 1000
+             - 用户："数量在500到1000之间" → dProductQty >= 500 && dProductQty <= 1000
+        
+        3. 时间字段：
+           - 使用时间戳范围：tCreateDate >= 开始时间戳 && tCreateDate <= 结束时间戳
+           - 时间戳为 Unix 秒
+        
+        4. 组合条件：
+           - 使用 && (AND) 连接多个条件
+           - 使用 || (OR) 连接或条件
+           - 复杂条件用括号分组
+        
+        【核心约束 - 必须遵守】
+        1. 只有当用户【明确指定】具体条件时，才生成 filterExpression
+        2. 禁止为模糊查询添加默认过滤条件（如时间范围）
+        3. 禁止自动添加任何默认条件
+        4. 当前时间戳：{{sDataNow}}（Unix秒）
+        5. 字符串字段禁止使用 ==，必须使用 like
+        6. like 只支持前缀匹配，不支持 '%keyword%' 或 '%keyword' 格式
+        
+        【查询意图判断】
+        
+        类型A - 纯标量查询（只返回 filterExpression）：
+        - 用户明确指定了标量字段的具体条件
+        - 不包含语义匹配词
+        - 示例1："上海小羚羊" → {"sMethodName": true, "filterExpression": "sCustomerName like '上海小羚羊%'"}
+        - 示例2："客户名称包含上海" → {"sMethodName": true, "filterExpression": "sCustomerName like '上海%'"}
+        - 示例3："张三" → {"sMethodName": true, "filterExpression": "sSalesManName like '张三%'"}
+        - 示例4："数量大于1000" → {"sMethodName": true, "filterExpression": "dProductQty > 1000"}
+        - 示例5："今天创建的报价单" → {"sMethodName": true, "filterExpression": "tCreateDate >= 开始时间戳 && tCreateDate <= 结束时间戳"}
+        
+        类型B - 纯向量搜索（只返回 vectorField 和 vectorValue）：
+        - 用户只有语义意图，无具体标量条件
+        - 示例："找一些类似的报价单" → {"sMethodName": true, "vectorField": "向量字段名", "vectorValue": "sType:报价丢单原因"}
+        
+        类型C - 混合查询（同时返回 vectorField、vectorValue 和 filterExpression）：
+        - 用户既有具体条件，又需要语义匹配
+        - 示例："找丢单原因类似价格太高的上海小羚羊报价单" → 
+          {"sMethodName": true, "vectorField": "向量字段名", "vectorValue": "sReason:价格太高|sType:报价丢单原因", "filterExpression": "sCustomerName like '上海小羚羊%'"}
+        
+        类型D - 意图不匹配（只返回 sMethodName: false）：
+        - 用户输入与 {{sMethodName}} 完全无关
+        - 示例："你好" → {"sMethodName": false}
+        - 示例："查询客户信息"（如果方法名是"查询报价单"） → {"sMethodName": false}
+        
+        类型E - 意图匹配但无具体条件（只返回 sMethodName: true）：
+        - 用户想查询该类数据，但没有指定任何条件
+        - 示例："报价单明细" → {"sMethodName": true}
+        - 示例："报价单列表" → {"sMethodName": true}
+        - 示例："报价单" → {"sMethodName": true}
+        
+        【时间处理规则】
+        
+        当用户明确提到时间时，基于当前时间 {{sDataNow}} 计算：
+        - "今天"：当天 00:00:00 到 23:59:59
+        - "昨天"：前一天 00:00:00 到 23:59:59
+        - "本周"：本周一 00:00:00 到本周日 23:59:59
+        - "本月"：本月1日 00:00:00 到本月最后一天 23:59:59
+        - "上个月"：上个月1日 00:00:00 到上个月最后一天 23:59:59
+        - "近X天"：X天前 00:00:00 到今天 23:59:59
+        
+        时间范围表达式格式：tCreateDate >= 开始时间戳 && tCreateDate <= 结束时间戳
+        
+        【重要约束汇总】
+        1. 只输出 JSON，不要有任何其他内容
+        2. 只使用提供的标量字段
+        3. 【关键】字符串字段必须使用 like，禁止使用 ==
+        4. 时间范围必须使用 Unix 时间戳（秒）
+        5. 向量字段名使用 {{sMilvusFiledXl}} 中提供的字段名
+        6. vectorValue 必须保持管道符分隔格式："字段名:值|字段名:值"
+        7. 禁止为模糊查询添加默认条件
+        8. sMethodName 只要用户意图与当前方法相关就返回 true
+        9. like 只支持前缀匹配，格式：字段名 like '值%'
+        
+        【输出示例】
+        方法名称：查询报价单
+        
+        示例1：模糊查询 - "报价单明细"
+        输出：{"sMethodName": true}
+        
+        示例2：字符串模糊匹配 - "上海小羚羊"
+        输出：{"sMethodName": true, "filterExpression": "sCustomerName like '上海小羚羊%'"}
+        
+        示例3：字符串模糊匹配 - "客户名称包含上海"
+        输出：{"sMethodName": true, "filterExpression": "sCustomerName like '上海%'"}
+        
+        示例4：字符串模糊匹配 - "张三"
+        输出：{"sMethodName": true, "filterExpression": "sSalesManName like '张三%'"}
+        
+        示例5：数字范围 - "数量大于1000"
+        输出：{"sMethodName": true, "filterExpression": "dProductQty > 1000"}
+        
+        示例6：时间范围 - "今天创建的报价单"
+        输出：{"sMethodName": true, "filterExpression": "tCreateDate >= 1774754400 && tCreateDate <= 1774840799"}
+        
+        示例7：组合条件 - "上海小羚羊且数量大于1000"
+        输出：{"sMethodName": true, "filterExpression": "sCustomerName like '上海小羚羊%' && dProductQty > 1000"}
+        
+        示例8：纯向量 - "找一些类似的报价单"
+        输出：{"sMethodName": true, "vectorField": "content_embedding", "vectorValue": "sType:报价丢单原因"}
+        
+        示例9：混合查询 - "找丢单原因类似价格太高的上海小羚羊报价单"
+        输出：{"sMethodName": true, "vectorField": "content_embedding", "vectorValue": "sReason:价格太高|sType:报价丢单原因", "filterExpression": "sCustomerName like '上海小羚羊%'"}
+        
+        示例10：意图不匹配 - "你好"
+        输出：{"sMethodName": false}
+        
+        【标量字段列表】
+        {{sMilvusFiled}}
+        
+        【标量字段说明】
+        {{sMilvusFiledDescription}}
+        
+        【向量字段列表】
+        {{sMilvusFiledXl}}
+        
+        【向量字段说明】
+        {{sMilvusFiledDescriptionXl}}
+        
+        【方法名称】
+        {{sMethodName}}
+        
         """)
-        @UserMessage("""
-        【用户查询】
-            - {{userInput}}
+            @UserMessage("""
+        【用户输入】
+        {{userInput}}
+        
         【当前时间】
-            - {{sDataNow}}
-        【可用字段】
-            - {{sMilvusFiled}}
-        【字段说明】
-            - {{sMilvusFiledDescription}}
-    """)
+        {{sDataNow}}
+        
+        【标量字段】
+        {{sMilvusFiled}}
+        
+        【标量字段说明】
+        {{sMilvusFiledDescription}}
+        
+        【向量字段】
+        {{sMilvusFiledXl}}
+        
+        【向量字段说明】
+        {{sMilvusFiledDescriptionXl}}
+        
+        【方法名称】
+        {{sMethodName}}
+        
+        请根据以上规则，输出 JSON 格式结果。
+""")
     String getMilvusFilter(@MemoryId String userId,
                            @V("userInput") String userInput,
                            @V("sMilvusFiled") String sMilvusFiled,
                            @V("sMilvusFiledDescription") String sMilvusFiledDescription,
-                           @V("sDataNow") String sDataNow);
-
+                           @V("sMilvusFiledXl") String sMilvusFiledXl,
+                           @V("sMilvusFiledDescriptionXl") String sMilvusFiledDescriptionXl,
+                           @V("sDataNow") long sDataNow,
+                           @V("sMethodName") String sMethodName
+    );
 }
@@ -36,7 +36,7 @@ public interface MilvusService {
      * @return long
      * @Description 批量插入数据
      **/
-    long addDataToCollection(String collectionName, String sVectorfiled, String sVectorjson, List<Map<String, Object>> data);
+    long addDataToCollection(String collectionName, String sVectorfiled, String sVectorjson, List<Map<String, Object>> data,String sceneName);
  
     /***
      * @Author 钱豹
@@ -45,7 +45,7 @@ public interface MilvusService {
      * @return
      * @Description 向量库查询
      **/
-    List<Map<String, Object>> getDataToCollection(String collectionName, String milvusFilter,String searchText,Integer size,List<String> fields);
+    List<Map<String, Object>> getDataToCollection(String collectionName, String milvusFilter,String searchText,Integer size,List<String> fields,String vectorValue,String sceneName);
  
     /***
      * @Author 钱豹
@@ -54,7 +54,7 @@ public interface MilvusService {
      * @return java.util.Map<java.lang.String,java.lang.Object>
      * @Description 获取配置
      **/
-    Map<String,Object> getMilvusFiled(String sVectorfiled,String sVectorfiledAll,String sVectorfiledShow);
+    Map<String,Object> getMilvusFiled(String sVectorfiled,String sVectorfiledAll,String sVectorfiledShow,String sVectorjson);
  
-    boolean isValidMilvusFilter(String milvusFilter);
+    boolean isStringFilterValid(String filter,String collectionName);
 }
 \ No newline at end of file
@@ -8,6 +8,7 @@ import com.google.gson.JsonObject;
 import com.xly.milvus.service.AiGlobalAgentQuestionSqlEmitterService;
 import com.xly.milvus.service.VectorizationService;
 import com.xly.milvus.util.MapToJsonConverter;
+import com.xly.service.DynamicExeDbService;
 import io.milvus.v2.client.MilvusClientV2;
 import io.milvus.v2.common.ConsistencyLevel;
 import io.milvus.v2.common.DataType;
@@ -37,11 +38,15 @@ public class AiGlobalAgentQuestionSqlEmitterServiceImpl implements AiGlobalAgent
  
     private final MilvusClientV2 milvusClient;
     private final VectorizationService vectorizationService;
+    private final DynamicExeDbService dynamicExeDbService;
+    private final String sProName ="Sp_Ai_AiGlobalAgentQuestionThread";
+
  
     // 或者从配置文件读取
     @Value("${milvus.vector.dimension:384}")
     private int VECTOR_DIM;
  
+
     // 缓存已加载的集合
     private final Set<String> loadedCollections = new ConcurrentHashSet<>();
  
@@ -78,6 +83,11 @@ public class AiGlobalAgentQuestionSqlEmitterServiceImpl implements AiGlobalAgent
                 .build();
  
         InsertResp insertResp = milvusClient.insert(insertReq);
+        if(insertResp.getInsertCnt()>0){
+            //调用数据库插入数据库
+            Map<String, Object> searMap = dynamicExeDbService.getDoProMap(sProName, data);
+            dynamicExeDbService.getCallPro(searMap, sProName);
+        }
         System.out.println("成功插入 " + insertResp.getInsertCnt() + " 条数据");
         System.out.println("   - 数据预览:");
     }
@@ -121,7 +131,7 @@ public class AiGlobalAgentQuestionSqlEmitterServiceImpl implements AiGlobalAgent
                 .annsField("vector")  // 向量字段名
                 .topK(10)  // 返回最相似的10条
                 .metricType(IndexParam.MetricType.IP)  // 内积相似度
-                .outputFields(Arrays.asList("sQuestion", "sSqlContent", "data_id","db_name", "create_time","metadata"))
+                .outputFields(Arrays.asList("sQuestion", "sSqlContent", "data_id","cachType", "create_time","metadata"))
                 .searchParams(searchParams)
                 .build();
         // 5. 执行搜索
@@ -16,6 +16,10 @@ import com.xly.milvus.util.MapToJsonConverter;
 import com.xly.milvus.util.MilvusTimeUtil;
 import com.xly.service.DynamicExeDbService;
 import com.xly.tts.bean.TTSResponseDTO;
+import io.milvus.client.MilvusServiceClient;
+import io.milvus.grpc.QueryResults;
+import io.milvus.param.R;
+import io.milvus.param.dml.QueryParam;
 import io.milvus.v2.client.MilvusClientV2;
 import io.milvus.v2.common.ConsistencyLevel;
 import io.milvus.v2.common.DataType;
@@ -23,9 +27,11 @@ import io.milvus.v2.common.IndexParam;
 import io.milvus.v2.service.collection.request.*;
 import io.milvus.v2.service.vector.request.DeleteReq;
 import io.milvus.v2.service.vector.request.InsertReq;
+import io.milvus.v2.service.vector.request.QueryReq;
 import io.milvus.v2.service.vector.request.SearchReq;
 import io.milvus.v2.service.vector.request.data.FloatVec;
 import io.milvus.v2.service.vector.response.InsertResp;
+import io.milvus.v2.service.vector.response.QueryResp;
 import io.milvus.v2.service.vector.response.SearchResp;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -94,10 +100,17 @@ public class MilvusServiceImpl implements MilvusService {
                     .message("向量化内容JSON")
                     .build();
         }
+        if(ObjectUtil.isEmpty(reqMap.get("sceneName"))){
+            return TTSResponseDTO.builder()
+                    .code(-1)
+                    .message("未传入场景名称")
+                    .build();
+        }
  
         String sInputTabelName = reqMap.get("sInputTabelName").toString();
         String sVectorfiled = reqMap.get("sVectorfiled").toString();
         String sVectorjson = reqMap.get("sVectorjson").toString();
+        String sceneName = reqMap.get("sceneName").toString();
         //创建集合
         createCollectionIfNotExists(sInputTabelName, sVectorfiled, sVectorjson,true);
         String tUpdateDate = DateUtil.now();
@@ -106,7 +119,7 @@ public class MilvusServiceImpl implements MilvusService {
         List<Map<String,Object>> data = getAddData(sInputTabelName,tUpdateDate, tUpdateDateUp);
         if(ObjectUtil.isNotEmpty(data)){
             //插入数据
-            long num= addDataToCollection(sInputTabelName, sVectorfiled,  sVectorjson,data);
+            long num= addDataToCollection(sInputTabelName, sVectorfiled,  sVectorjson,data,sceneName);
         }
         addAiMilvusVectorRecord(sInputTabelName,tUpdateDate, tUpdateDateUp);
         return TTSResponseDTO.builder()
@@ -202,7 +215,7 @@ public class MilvusServiceImpl implements MilvusService {
      * @Description 新增数据集合
      **/
     @Override
-    public long addDataToCollection(String collectionName, String sVectorfiled, String sVectorjson,List<Map<String,Object>> data){
+    public long addDataToCollection(String collectionName, String sVectorfiled, String sVectorjson,List<Map<String,Object>> data,String sceneName){
  
         // 1. 参数校验（防止空参数导致崩溃）
         if (ObjectUtil.isEmpty(collectionName) || CollUtil.isEmpty(data)) {
@@ -210,7 +223,7 @@ public class MilvusServiceImpl implements MilvusService {
         }
  
         // 1. 转换为Milvus格式
-        List<JsonObject> rows =  convertToMilvusRow(data,  sVectorfiled, sVectorjson);
+        List<JsonObject> rows =  convertToMilvusRow(data,  sVectorfiled, sVectorjson,sceneName);
         if (CollUtil.isEmpty(rows)) {
             return 0l; // 无数据直接返回
         }
@@ -264,7 +277,7 @@ public class MilvusServiceImpl implements MilvusService {
      * @Description 返回组装动态内容
      **/
     @Override
-    public Map<String,Object> getMilvusFiled(String sVectorfiled,String sVectorfiledAll,String sVectorfiledShow){
+    public Map<String,Object> getMilvusFiled(String sVectorfiled,String sVectorfiledAll,String sVectorfiledShow,String sVectorjson){
         List<String> sFileds = new ArrayList<>();
         List<String> filedsShow = new ArrayList<>();
         List<String> sFiledDescriptions = new ArrayList<>();
@@ -299,17 +312,32 @@ public class MilvusServiceImpl implements MilvusService {
             String formattedDesc =String.format("%s: %s", sName, sDescriptions);
             sFiledDescriptionsAll.add(formattedDesc);
         }
+        List<String> sFiledsXl = new ArrayList<>();
+        List<String> sFiledDescriptionsXl = new ArrayList<>();
+        String[] sVectorjsonArray = sVectorjson.split(",");
+        for(String sVectorjsonOne : sVectorjsonArray){
+            String[] sVectorfiledOneArray = sVectorjsonOne.split(":");
+            String sDescriptions = sVectorfiledOneArray[0];
+            String sName = sVectorfiledOneArray[1];
+            sFiledsXl.add(sName);
+            // 处理描述中可能包含的换行，保持缩进一致
+            String formattedDesc =String.format("%s: %s", sName, sDescriptions);
+            sFiledDescriptionsXl.add(formattedDesc);
+        }
+
         Map<String,Object> rMap = new HashMap<>();
         rMap.put("sMilvusFiled", String.join(",", sFileds));
         rMap.put("sMilvusFiledDescription", String.join(",", sFiledDescriptions));
         rMap.put("sMilvusFiledDescriptionAll", String.join(",", sFiledDescriptionsAll));
+        rMap.put("sMilvusFiledXl", String.join(",", sFiledsXl));
+        rMap.put("sMilvusFiledDescriptionXl", String.join(",", sFiledDescriptionsXl));
         rMap.put("filedsShow", filedsShow);
         rMap.put("title", titleList);
         return rMap;
     }
  
     @Override
-    public List<Map<String, Object>> getDataToCollection(String collectionName, String milvusFilter,String searchText,Integer size,List<String> fields){
+    public List<Map<String, Object>> getDataToCollection(String collectionName, String milvusFilter,String searchText,Integer size,List<String> fields,String vectorValue,String sceneName){
         log.info("开始相似度查询: collection={}, searchText={}", collectionName, searchText);
         // 2. 设置范围搜索参数
         Map<String, Object> searchParams = new HashMap<>();
@@ -317,10 +345,24 @@ public class MilvusServiceImpl implements MilvusService {
         // 对于 IP 度量，相似度范围在 [minScore, maxScore]
         searchParams.put("radius", 0.9);      // 最小相似度
         searchParams.put("range_filter", 1); // 最大相似度
-        // 1. 确保集合已加载
-//        ensureCollectionLoaded(collectionName);
+        if(ObjectUtil.isEmpty(fields)){
+            fields = new ArrayList<>();
+        }
+        fields.add("sSlaveId");
+        fields.add("metadata");
+        // 1. 构建查询（通用）
+        SearchReq.SearchReqBuilder builder = SearchReq.builder()
+                .collectionName(collectionName)
+                .topK(size)
+                .metricType(IndexParam.MetricType.IP)
+                .outputFields(fields)
+//                .filterType(FilterType.POST_FILTER)
+                .searchParams(searchParams);
+        if(ObjectUtil.isEmpty(vectorValue)){
+            vectorValue = sceneName;
+        }
         // 1. 向量化搜索文本
-        List<Float> vectorList = vectorizationService.textToVector(searchText);
+        List<Float> vectorList = vectorizationService.textToVector(vectorValue);
         if (vectorList == null || vectorList.isEmpty()) {
             throw new RuntimeException("向量化失败");
         }
@@ -329,25 +371,27 @@ public class MilvusServiceImpl implements MilvusService {
         for (int i = 0; i < vectorList.size(); i++) {
             floatArray[i] = vectorList.get(i);
         }
-        if(ObjectUtil.isEmpty(fields)){
-            fields = new ArrayList<>();
-        }
-        fields.add("sSlaveId");
-        fields.add("metadata");
         // 3. 创建 Milvus FloatVec 对象
         FloatVec floatVec = new FloatVec(floatArray);
+        builder.data(Collections.singletonList(floatVec))
+                .annsField("vector");  // 向量字段名
+
+        if(ObjectUtil.isNotEmpty(milvusFilter)){
+            builder.filter(milvusFilter);
+        }
         // 4. 构建搜索请求
-        SearchReq searchReq = SearchReq.builder()
-                .collectionName(collectionName)
-                .data(Collections.singletonList(floatVec))
-                .annsField("vector")  // 向量字段名
-                .topK(size)  // 返回最相似的10条
-                .metricType(IndexParam.MetricType.IP)  // 内积相似度
-                .outputFields(fields)
+//        SearchReq searchReq = SearchReq.builder()
+//                .collectionName(collectionName)
+//                .data(Collections.singletonList(floatVec))
+//                .annsField("vector")  // 向量字段名
+//                .topK(size)  // 返回最相似的10条
+//                .metricType(IndexParam.MetricType.IP)  // 内积相似度
+//                .outputFields(fields)
 //                .searchParams(searchParams)
-                .filter(milvusFilter)
-                .build();
+//                .filter(milvusFilter)
+//                .build();
         // 5. 执行搜索
+        SearchReq searchReq = builder.build();
         SearchResp searchResp = milvusClient.search(searchReq);
  
         // 6. 处理结果
@@ -357,45 +401,26 @@ public class MilvusServiceImpl implements MilvusService {
  
     /**
      * 判断 Milvus 过滤条件是否有效（支持 TEXT_MATCH 全文检索）
-     * @param milvusFilter 过滤条件字符串
      * @return true: 有效条件, false: 无效条件
      */
-    public boolean isValidMilvusFilter(String milvusFilter) {
-        // 1. 空值判断
-        if (milvusFilter == null || milvusFilter.trim().isEmpty()) {
-            return false;
-        }
-
-        String filter = milvusFilter.trim();
-
-        // 2. 基本格式检查：不能是纯布尔值
-        if ("true".equalsIgnoreCase(filter) || "false".equalsIgnoreCase(filter)) {
-            return false;
-        }
-
-        // 3. 【修改】检查是否包含有效的操作符（增加 TEXT_MATCH 支持）
-        boolean hasValidOperator = filter.matches(".*[=!<>]=?.*")
-                || filter.contains(" like ")
-                || filter.toUpperCase().contains("TEXT_MATCH");
-
-        if (!hasValidOperator) {
-            return false;
-        }
-
-        // 4. 对于复合条件，递归检查
-        if (filter.contains("&&") || filter.contains("||")) {
-            // 分割复合条件（简单处理，生产环境需要更完善的解析）
-            String[] conditions = splitConditions(filter);
-            for (String condition : conditions) {
-                if (!isValidCondition(condition)) {
-                    return false;
-                }
-            }
+    /**
+     * 判断字符串 Filter 是否有效
+     * @param filter 过滤表达式，如 "name == '张三'"
+     * @return true=有效，false=无效
+     */
+    public boolean isStringFilterValid(String filter,String collectionName) {
+        try {
+            // 使用 limit 为 0 只验证语法，不实际返回数据
+            QueryReq queryReq = QueryReq.builder()
+                    .collectionName(collectionName)
+                    .filter(filter)  // 设置过滤条件
+                    .limit(0)        // limit 0 只校验语法
+                    .build();
+            QueryResp response = milvusClient.query(queryReq);
             return true;
+        } catch (Exception e) {
+            return false;
         }
-
-        // 5. 检查单个条件
-        return isValidCondition(filter);
     }
  
     /**
@@ -583,14 +608,14 @@ public class MilvusServiceImpl implements MilvusService {
     /**
      * 从实体对象构建Milvus插入数据
      */
-    public List<JsonObject> convertToMilvusRow(List<Map<String,Object>> data, String sVectorfiled,String sVectorjson) {
+    public List<JsonObject> convertToMilvusRow(List<Map<String,Object>> data, String sVectorfiled,String sVectorjson,String sceneName) {
         List<JsonObject> rows = new ArrayList<>();
         if (CollUtil.isEmpty(data)) {
             return rows;
         }
         // 批量遍历，逐个转换
         for (Map<String, Object> map : data) {
-            JsonObject jsonObject = convertToMilvusRowOne(map, sVectorfiled, sVectorjson);
+            JsonObject jsonObject = convertToMilvusRowOne(map, sVectorfiled, sVectorjson,sceneName);
             rows.add(jsonObject);
         }
         return rows;
@@ -603,12 +628,12 @@ public class MilvusServiceImpl implements MilvusService {
      * @return com.google.gson.JsonObject
      * @Description 单个转换
      **/
-    public JsonObject convertToMilvusRowOne(Map<String,Object> data, String sVectorfiled,String sVectorjson) {
+    public JsonObject convertToMilvusRowOne(Map<String,Object> data, String sVectorfiled,String sVectorjson,String sceneName) {
  
         // ====================== 修复 1：使用真实的向量化文本 ======================
         // 从 sVectorjson 或 data 中获取要向量化的字段值
         StringBuffer vectorText = new StringBuffer();
-        getVectorText(data, vectorText, sVectorjson);
+        getVectorText(data, vectorText, sVectorjson,sceneName);
         // 向量化
         List<Float> vector = vectorizationService.textToVector(vectorText.toString());
         if (vector == null || vector.isEmpty()) {
@@ -650,7 +675,7 @@ public class MilvusServiceImpl implements MilvusService {
         return row;
     }
  
-    private void getVectorText(Map<String,Object> data, StringBuffer vectorText,String sVectorjson){
+    private void getVectorText(Map<String,Object> data, StringBuffer vectorText,String sVectorjson,String sceneName){
         // 动态字段
         String[] sVectorjsonArray = sVectorjson.split(";");
         for (String sVectorjsonOne : sVectorjsonArray) {
@@ -666,8 +691,9 @@ public class MilvusServiceImpl implements MilvusService {
             }else{
                 sText = value.toString();
             }
-            vectorText.append(" ").append(fieldArr[0]).append(sText);
+            vectorText.append(" | ").append(fieldArr[0]).append(":").append(sText);
         }
+        vectorText.append(" ").append(sceneName);
     }
  
  
 package com.xly.service;
  
 import cn.hutool.core.collection.ListUtil;
-import cn.hutool.core.date.DatePattern;
 import cn.hutool.core.date.DateUtil;
-import cn.hutool.core.util.IdUtil;
+import cn.hutool.core.util.BooleanUtil;
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONUtil;
 import com.alibaba.fastjson2.JSON;
 import com.alibaba.fastjson2.JSONObject;
 import com.xly.agent.ChatiAgent;
@@ -405,25 +405,48 @@ public class XlyErpService {
             String sInputTabelName = session.getCurrentTool().getSInputTabelName();
             String sVectorfiledAll = session.getCurrentTool().getSVectorfiledAll();
             String sVectorfiledShow = session.getCurrentTool().getSVectorfiledShow();
-            Map<String,Object> rMap = milvusService.getMilvusFiled(sVectorfiled,sVectorfiledAll,sVectorfiledShow);
+            String sVectorjson = session.getCurrentTool().getSVectorjson();
+            String sceneName = session.getCurrentTool().getSceneName();
+            String sMethodName = session.getCurrentTool().getSMethodName();
+            Map<String,Object> rMap = milvusService.getMilvusFiled(sVectorfiled,sVectorfiledAll,sVectorfiledShow,sVectorjson);
             String sMilvusFiled =  rMap.get("sMilvusFiled").toString();
+            String sMilvusFiledXl =  rMap.get("sMilvusFiledXl").toString();
             String sMilvusFiledDescription = rMap.get("sMilvusFiledDescription").toString();
+            String sMilvusFiledDescriptionXl = rMap.get("sMilvusFiledDescriptionXl").toString();
             String sMilvusFiledDescriptionAll = rMap.get("sMilvusFiledDescriptionAll").toString();
             List<String> filedsShow = (List<String>) rMap.get("filedsShow");
             List<Map<String, String>> title  = (List<Map<String, String>>) rMap.get("title");
             String milvusFilter = StrUtil.EMPTY;
+            String vectorValue = StrUtil.EMPTY;
+            Boolean bMethodName = false;
             if(!bCach){
-                milvusFilter = aiAgent.getMilvusFilter(session.getUserId(),userInput, sMilvusFiled, sMilvusFiledDescription,DateUtil.now());
-                log.info("查询向量库条件{}",milvusFilter);
-                milvusFilter = milvusService.isValidMilvusFilter(milvusFilter)?milvusFilter : null;
-                log.info("实际查询向量库条件{}",milvusFilter);
+                long sDateNow = System.currentTimeMillis() / 1000;
+                String milvusFilterOld = aiAgent.getMilvusFilter(session.getUserId(),userInput, sMilvusFiled, sMilvusFiledDescription,sMilvusFiledXl, sMilvusFiledDescriptionXl,sDateNow,sMethodName);
+                log.info("查询向量库条件{}",milvusFilterOld);
+                if(ObjectUtil.isNotEmpty(milvusFilterOld) && JSONUtil.isTypeJSON(milvusFilterOld)){
+                    Map<String,Object> filterMap = JSONUtil.parseObj(milvusFilterOld);
+                    if(ObjectUtil.isNotEmpty(filterMap.get("filterExpression"))){
+                        milvusFilterOld = filterMap.get("filterExpression").toString();
+                    }
+                    if(ObjectUtil.isNotEmpty(filterMap.get("vectorValue"))){
+                        vectorValue = filterMap.get("vectorValue").toString();
+                    }
+                    if(ObjectUtil.isNotEmpty(filterMap.get("sMethodName"))){
+                        bMethodName = BooleanUtil.toBoolean(filterMap.get("sMethodName").toString());
+                    }
+                }
+                Boolean milvusFilterCheck = milvusService.isStringFilterValid(milvusFilterOld,sInputTabelName);
+                milvusFilter = milvusFilterCheck?milvusFilterOld : null;
+                if(!bMethodName && ObjectUtil.isEmpty(vectorValue) && ObjectUtil.isEmpty(milvusFilter)){
+                    return resultExplain;
+                }
             }
             Integer pageSize = 100;
             if(ObjectUtil.isEmpty(milvusFilter)){
                 pageSize = 10;
             }
 //            待条件全查  不带 10条
-            List<Map<String,Object>> data = milvusService.getDataToCollection(sInputTabelName, milvusFilter,userInput,pageSize,filedsShow);
+            List<Map<String,Object>> data = milvusService.getDataToCollection(sInputTabelName, milvusFilter,userInput,pageSize,filedsShow, vectorValue,sceneName);
             //存储到历史问题库（带where条件了就不存）并且没有记录过缓存
             if(!bCach && ObjectUtil.isEmpty(milvusFilter)){
                 //执行操作记录表
@@ -436,13 +459,7 @@ public class XlyErpService {
                 }
             }
             //采用表格形式显示明细、...详情、...记录、...列表、...清单
-            if(ObjectUtil.isEmpty(milvusFilter)
-                    || userInput.contains("明细")
-                    ||  userInput.contains("详情")
-                    ||  userInput.contains("记录")
-                    ||  userInput.contains("列表")
-                    ||  userInput.contains("清单")
-            ){
+            if( retrunMarkdownType(userInput) ){
                 resultExplain = buildMarkdownTableWithStream(data, title);
             }else{
                 resultExplain = aiAgent.explainMilvusResult(session.getUserId(),userInput,sMilvusFiledDescriptionAll,JSONObject.toJSONString(data));
@@ -453,6 +470,21 @@ public class XlyErpService {
         }
         return resultExplain;
     }
+
+    /***
+     * @Author 钱豹
+     * @Date 19:48 2026/3/28
+     * @Param [userInput]
+     * @return java.lang.Boolean
+     * @Description 是否返回Markdown类型
+     **/
+    private Boolean retrunMarkdownType(String userInput){
+        return   userInput.contains("明细")
+//                ||  userInput.contains("详情")
+//                    ||  userInput.contains("记录")
+                ||  userInput.contains("列表")
+                ||  userInput.contains("清单");
+    }
     /***
      * @Author 钱豹
      * @Date 13:19 2026/3/25
@@ -640,38 +672,47 @@ public class XlyErpService {
         if(Integer.valueOf(iErroCount)>0){
             doAiSqlErrorHistoryThread(session, cleanSql, StrUtil.EMPTY, StrUtil.EMPTY,input);
         }
-        //插入常用操作
+        //插入常用操作  不包含where 条件
         if(doAddSql){
             //执行操作记录表
             doAiUserAgentQuestion(session,input,cleanSql,"MYSQL",chatMessage);
         }
-        String sText = aiAgent.explainSqlResult(
-                userId,
-                userInput,
-                cleanSql,
-                tableStruct,
-                resultJson
-        );
-        return sText;
+        //采用表格形式显示明细、...详情、...记录、...列表、...清单
+        String resultExplain = StrUtil.EMPTY;
+        if(retrunMarkdownType(userInput) ){
+            List<Map<String, String>> titles = getMarkdownTableTitleWithSql(sqlResult);
+            resultExplain = buildMarkdownTableWithStream(sqlResult, titles);
+        }else {
+            resultExplain = aiAgent.explainSqlResult(
+                    userId,
+                    userInput,
+                    cleanSql,
+                    tableStruct,
+                    resultJson);
+        }
+        return resultExplain;
     }
  
     /***
      * @Author 钱豹
-     * @Date 17:04 2026/3/19
-     * @Param [session]
-     * @return java.lang.String
-     * @Description 获取动态SQL（历史中查询）
+     * @Date 19:55 2026/3/28
+     * @Param [sqlResult]
+     * @return java.util.List<java.util.Map<java.lang.String,java.lang.String>>
+     * @Description 动态SQL 返回Markdown 形式抬头
      **/
-    private Map<String,Object> getDynamicTableCach(UserSceneSession session,String input){
-        try{
-            String searchText = session.getCurrentScene().getSId()+"_"+session.getCurrentTool().getSId()+input;
-            //根据问题查询向量库
-            Map<String,Object> serMap = aiGlobalAgentQuestionSqlEmitterService.queryAiGlobalAgentQuestionSqlEmitter(searchText, "ai_global_agent_question_sql");
-            return serMap;
-        }catch (Exception e){
-            log.error("取是否走缓存异常");
+    private  List<Map<String, String>> getMarkdownTableTitleWithSql(List<Map<String, Object>> sqlResult){
+        if(ObjectUtil.isEmpty(sqlResult)){
+            return new ArrayList<>();
         }
-        return null;
+        Map<String, Object> one = sqlResult.get(0);
+        List<Map<String, String>> titleData = new ArrayList<>();
+        one.forEach((k,v)->{
+            Map<String, String> title = new HashMap<>();
+            title.put("sTitle",k);
+            title.put("sName",k);
+            titleData.add(title);
+        });
+        return titleData;
     }
  
     /***
@@ -681,22 +722,14 @@ public class XlyErpService {
      * @return java.lang.String
      * @Description 获取动态SQL（历史中查询）
      **/
-    private String getDynamicTableNl2Sql(UserSceneSession session,String input){
-//        String sReidKey = SqlValidateUtil.getsKey( session.getCurrentScene().getSId(), session.getCurrentTool().getSId(), input);
-//        Object sSql = redisService.get(sReidKey);
-//        if(ObjectUtil.isNotEmpty(sSql)){
-//            return sSql.toString();
-//        }
+    private Map<String,Object> getDynamicTableCach(UserSceneSession session,String input){
         try{
             String searchText = session.getCurrentScene().getSId()+"_"+session.getCurrentTool().getSId()+input;
-            //SqlValidateUtil.getsKey( session.getCurrentScene().getSId(), session.getCurrentTool().getSId(), SqlValidateUtil.getsQuestion(session.getSUserQuestionList()));
             //根据问题查询向量库
             Map<String,Object> serMap = aiGlobalAgentQuestionSqlEmitterService.queryAiGlobalAgentQuestionSqlEmitter(searchText, "ai_global_agent_question_sql");
-            if(ObjectUtil.isNotEmpty(serMap)){
-                return serMap.get("sSqlContent").toString();
-            }
+            return serMap;
         }catch (Exception e){
-
+            log.error("取是否走缓存异常");
         }
         return null;
     }
@@ -9,8 +9,8 @@ import com.xly.entity.UserSceneSession;
 import com.xly.milvus.service.AiGlobalAgentQuestionSqlEmitterService;
 import com.xly.service.DynamicExeDbService;
 import com.xly.service.RedisService;
-import com.xly.util.MD5Util;
 import com.xly.util.SqlValidateUtil;
+import com.xly.util.SqlWhereHelper;
 import dev.langchain4j.data.message.ChatMessage;
 import dev.langchain4j.data.message.ChatMessageType;
 import java.util.HashMap;
@@ -54,17 +54,15 @@ public class AiUserAgentQuestionThread implements Runnable {
         }
         String sKey = sSceneId+"_"+sMethodId +"_"+sQuestion;
 //                SqlValidateUtil.getsKey( sSceneId, sMethodId, SqlValidateUtil.getsQuestion(session.getSUserQuestionList()));
-        //存入向量库
-        aiGlobalAgentQuestionSqlEmitterService.addAiGlobalAgentQuestionSqlEmitter(sKey,data,sQuestion,sSqlContent,cachType,"ai_global_agent_question_sql");
-        //调用数据库插入数据库
+        //存入向量库 不包含where 条件
+        if(!SqlWhereHelper.hasWhereCondition(sSqlContent)){
+            aiGlobalAgentQuestionSqlEmitterService.addAiGlobalAgentQuestionSqlEmitter(sKey,data,sQuestion,sSqlContent,cachType,"ai_global_agent_question_sql");
+        }
+       //调用数据库插入数据库
         Map<String, Object> searMap = dynamicExeDbService.getDoProMap(sProName, data);
         dynamicExeDbService.getCallPro(searMap, sProName);
     }
  
-
-
-
-
     //获取组ID
     private String getQuestionGroupNo(){
         String sQuestionGroupNo = userMessage.stream()
+package com.xly.util;
+
+import cn.hutool.core.util.StrUtil;
+import lombok.extern.slf4j.Slf4j;
+import net.sf.jsqlparser.JSQLParserException;
+import net.sf.jsqlparser.parser.CCJSqlParserUtil;
+import net.sf.jsqlparser.statement.Statement;
+import net.sf.jsqlparser.statement.delete.Delete;
+import net.sf.jsqlparser.statement.select.Select;
+import net.sf.jsqlparser.statement.update.Update;
+
+@Slf4j
+public class SqlWhereHelper {
+
+    /**
+     * 判断 SQL 是否包含 WHERE 条件（使用 JSqlParser）
+     */
+    public static boolean hasWhereCondition(String sql) {
+        if (StrUtil.isBlank(sql)) {
+            return false;
+        }
+        try {
+            Statement statement = CCJSqlParserUtil.parse(sql);
+            if (statement instanceof Select) {
+                Select select = (Select) statement;
+                return select.getPlainSelect() != null && select.getPlainSelect().getWhere() != null;
+            }
+            if (statement instanceof Update) {
+                Update update = (Update) statement;
+                return update.getWhere() != null;
+            }
+            if (statement instanceof Delete) {
+                Delete delete = (Delete) statement;
+                return delete.getWhere() != null;
+            }
+        } catch (JSQLParserException e) {
+            log.warn("SQL 解析失败，回退到简单匹配: {}", sql, e);
+            return hasWhereConditionSimple(sql);
+        }
+        return false;
+    }
+
+    /**
+     * 简单判断是否有 WHERE
+     */
+    public static boolean hasWhereConditionSimple(String sql) {
+        if (StrUtil.isBlank(sql)) return false;
+        String s = sql.toUpperCase();
+        int whereIdx = s.indexOf("WHERE");
+        if (whereIdx == -1) return false;
+
+        String before = s.substring(0, whereIdx).trim();
+        if (!before.matches(".*\\b(SELECT|UPDATE|DELETE)\\b.*")) return false;
+
+        String after = s.substring(whereIdx + 5).trim();
+        return !after.isEmpty() && !after.matches("^(GROUP BY|ORDER BY|LIMIT).*");
+    }
+
+    // ===================== 你要的新方法 =====================
+    /**
+     * 判断：
+     * 1. 有 WHERE
+     * 2. 条件中 不包含 = > < >= <= IN EXISTS
+     * → 满足返回 true
+     */
+    public static boolean hasWhereButNoCompareOperators(String sql) {
+        if (!hasWhereCondition(sql)) {
+            return false;
+        }
+
+        String upper = sql.toUpperCase();
+
+        // 禁止出现的条件符号/关键字
+        boolean hasEq = upper.contains("=");
+        boolean hasGt = upper.contains(">");
+        boolean hasLt = upper.contains("<");
+        boolean hasIn = upper.contains(" IN ");
+        boolean hasExists = upper.contains(" EXISTS ");
+
+        // 只要有任何一个，就返回 false
+        if (hasEq || hasGt || hasLt || hasIn || hasExists) {
+            return false;
+        }
+
+        // 有 WHERE 且 无等值/区间/大小/IN/EXISTS → 返回 true
+        return true;
+    }
+
+    // ===================== 你原来的方法不动 =====================
+    public static int getWhereInsertPosition(String sql) {
+        if (hasWhereCondition(sql)) {
+            return -1;
+        }
+        String upperSql = sql.toUpperCase();
+        int fromIndex = upperSql.indexOf("FROM");
+        if (fromIndex == -1) return sql.length();
+
+        int tableEndIndex = findTableEnd(sql, fromIndex + 4);
+        int groupIndex = upperSql.indexOf("GROUP BY", tableEndIndex);
+        int orderIndex = upperSql.indexOf("ORDER BY", tableEndIndex);
+        int limitIndex = upperSql.indexOf("LIMIT", tableEndIndex);
+
+        int nextKeyword = sql.length();
+        if (groupIndex != -1) nextKeyword = Math.min(nextKeyword, groupIndex);
+        if (orderIndex != -1) nextKeyword = Math.min(nextKeyword, orderIndex);
+        if (limitIndex != -1) nextKeyword = Math.min(nextKeyword, limitIndex);
+        return nextKeyword;
+    }
+
+    private static int findTableEnd(String sql, int startIndex) {
+        if (startIndex >= sql.length()) return sql.length();
+        String afterFrom = sql.substring(startIndex);
+        int endIndex = startIndex;
+        for (int i = 0; i < afterFrom.length(); i++) {
+            char c = afterFrom.charAt(i);
+            if (Character.isWhitespace(c) || c == ',' || c == '(' || c == ')') {
+                endIndex = startIndex + i;
+                break;
+            }
+            endIndex = startIndex + i + 1;
+        }
+        return endIndex;
+    }
+
+    public static String addWhereCondition(String sql, String condition) {
+        if (StrUtil.isBlank(sql) || StrUtil.isBlank(condition)) return sql;
+        if (hasWhereCondition(sql)) {
+            return sql + " AND " + condition;
+        } else {
+            int insertPos = getWhereInsertPosition(sql);
+            return sql.substring(0, insertPos) + " WHERE " + condition + sql.substring(insertPos);
+        }
+    }
+}
 \ No newline at end of file