|
|
@@ -0,0 +1,2471 @@
|
|
|
+using System.ComponentModel;
|
|
|
+using System.Text.RegularExpressions;
|
|
|
+
|
|
|
+namespace OASystem.Infrastructure.Tools
|
|
|
+{
|
|
|
+ /// <summary>
|
|
|
+ /// 增强版高级搜索助手（支持智能拆分组合词）
|
|
|
+ /// 支持组合查询：多词条/单词条 + 单字 混合搜索
|
|
|
+ /// 提供智能搜索条件构建、相关性分析、分阶段搜索等功能
|
|
|
+ /// </summary>
|
|
|
+ public class AdvancedSearchHelper
|
|
|
+ {
|
|
|
+ #region 公共方法 - 主要搜索功能
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 构建增强搜索条件（支持组合查询和智能拆分）
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="searchTerm">搜索关键词</param>
|
|
|
+ /// <param name="searchFields">搜索字段列表</param>
|
|
|
+ /// <param name="prefix">参数前缀，用于避免参数名冲突</param>
|
|
|
+ /// <param name="searchMode">搜索模式，默认为自动检测</param>
|
|
|
+ /// <param name="combinationMode">组合模式，默认智能混合</param>
|
|
|
+ /// <param name="config">搜索配置选项</param>
|
|
|
+ /// <returns>构建的SQL条件和参数</returns>
|
|
|
+ /// <example>
|
|
|
+ /// <code>
|
|
|
+ /// var fields = new List<string> { "Name", "Description" };
|
|
|
+ /// var config = new SearchConfig {
|
|
|
+ /// EnableSmartSplitting = true, // 启用智能拆分
|
|
|
+ /// RequireAllWordsForSplit = false
|
|
|
+ /// };
|
|
|
+ /// var (condition, parameters) = AdvancedSearchHelper.BuildEnhancedSearchCondition(
|
|
|
+ /// "重庆科学",
|
|
|
+ /// fields,
|
|
|
+ /// "search_",
|
|
|
+ /// SearchMode.AutoDetect,
|
|
|
+ /// CombinationMode.SmartMix,
|
|
|
+ /// config
|
|
|
+ /// );
|
|
|
+ /// </code>
|
|
|
+ /// </example>
|
|
|
+ public static (string Condition, List<SugarParameter> Parameters) BuildEnhancedSearchCondition(
|
|
|
+ string searchTerm,
|
|
|
+ List<string> searchFields,
|
|
|
+ string prefix = "",
|
|
|
+ SearchMode searchMode = SearchMode.AutoDetect,
|
|
|
+ CombinationMode combinationMode = CombinationMode.SmartMix,
|
|
|
+ SearchConfig config = null)
|
|
|
+ {
|
|
|
+ // 参数验证
|
|
|
+ if (searchFields == null || !searchFields.Any())
|
|
|
+ throw new ArgumentException("搜索字段列表不能为空", nameof(searchFields));
|
|
|
+
|
|
|
+ if (string.IsNullOrWhiteSpace(searchTerm))
|
|
|
+ return (string.Empty, new List<SugarParameter>());
|
|
|
+
|
|
|
+ searchTerm = searchTerm.Trim();
|
|
|
+ config ??= new SearchConfig();
|
|
|
+
|
|
|
+ // 检查搜索词长度
|
|
|
+ if (searchTerm.Length > config.MaxSearchTermLength)
|
|
|
+ searchTerm = searchTerm.Substring(0, config.MaxSearchTermLength);
|
|
|
+
|
|
|
+ // 分析搜索词结构
|
|
|
+ var structure = AnalyzeSearchStructure(searchTerm);
|
|
|
+
|
|
|
+ // 根据组合模式构建条件
|
|
|
+ return combinationMode switch
|
|
|
+ {
|
|
|
+ CombinationMode.SmartMix => BuildSmartMixCondition(structure, searchFields, prefix, searchMode, config),
|
|
|
+ CombinationMode.WordsAndChars => BuildWordsAndCharsCondition(structure, searchFields, prefix, config),
|
|
|
+ CombinationMode.WordsOnly => BuildWordsOnlyCondition(structure, searchFields, prefix, config),
|
|
|
+ CombinationMode.CharsOnly => BuildCharsOnlyCondition(structure, searchFields, prefix, config),
|
|
|
+ _ => BuildSmartMixCondition(structure, searchFields, prefix, searchMode, config)
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 构建带相关性信息的搜索条件
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="searchTerm">搜索关键词</param>
|
|
|
+ /// <param name="searchFields">搜索字段列表</param>
|
|
|
+ /// <param name="prefix">参数前缀</param>
|
|
|
+ /// <param name="searchMode">搜索模式</param>
|
|
|
+ /// <param name="config">搜索配置</param>
|
|
|
+ /// <returns>包含条件、参数和相关性的完整结果</returns>
|
|
|
+ public static (string Condition, List<SugarParameter> Parameters, RelevanceInfo Relevance)
|
|
|
+ BuildRelevanceSearchCondition(
|
|
|
+ string searchTerm,
|
|
|
+ List<string> searchFields,
|
|
|
+ string prefix = "",
|
|
|
+ SearchMode searchMode = SearchMode.AutoDetect,
|
|
|
+ SearchConfig config = null)
|
|
|
+ {
|
|
|
+ config ??= new SearchConfig();
|
|
|
+
|
|
|
+ var structure = AnalyzeSearchStructure(searchTerm);
|
|
|
+ var (condition, parameters) = BuildEnhancedSearchCondition(
|
|
|
+ searchTerm, searchFields, prefix, searchMode, CombinationMode.SmartMix, config);
|
|
|
+
|
|
|
+ var relevance = new RelevanceInfo
|
|
|
+ {
|
|
|
+ SearchStructure = structure,
|
|
|
+ ExpectedMatches = CalculateExpectedMatches(structure, searchFields.Count),
|
|
|
+ BoostFields = GetBoostFields(structure, searchFields),
|
|
|
+ ScoringRules = GetScoringRules(structure, config),
|
|
|
+ MatchStrategy = GetMatchStrategy(structure, config),
|
|
|
+ GeneratedAt = DateTime.Now
|
|
|
+ };
|
|
|
+
|
|
|
+ return (condition, parameters, relevance);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 构建分阶段搜索条件（用于分阶段匹配和降级搜索）
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="searchTerm">搜索关键词</param>
|
|
|
+ /// <param name="searchFields">搜索字段列表</param>
|
|
|
+ /// <param name="prefix">参数前缀</param>
|
|
|
+ /// <param name="config">搜索配置</param>
|
|
|
+ /// <returns>按优先级排序的搜索阶段列表</returns>
|
|
|
+ public static List<SearchStage> BuildStagedSearchConditions(
|
|
|
+ string searchTerm,
|
|
|
+ List<string> searchFields,
|
|
|
+ string prefix = "",
|
|
|
+ SearchConfig config = null)
|
|
|
+ {
|
|
|
+ config ??= new SearchConfig();
|
|
|
+ var structure = AnalyzeSearchStructure(searchTerm);
|
|
|
+ var stages = new List<SearchStage>();
|
|
|
+
|
|
|
+ // 阶段1：精确匹配（完全相等）
|
|
|
+ if (structure.Words.Any() && config.EnableExactMatch)
|
|
|
+ {
|
|
|
+ foreach (var word in structure.Words.Where(w => w.Length >= config.MinExactMatchLength))
|
|
|
+ {
|
|
|
+ var (condition, parameters) = BuildExactCondition(word, searchFields, $"{prefix}exact_{stages.Count}");
|
|
|
+ if (!string.IsNullOrEmpty(condition))
|
|
|
+ {
|
|
|
+ stages.Add(new SearchStage
|
|
|
+ {
|
|
|
+ Stage = 1,
|
|
|
+ Name = $"精确匹配: {word}",
|
|
|
+ Condition = condition,
|
|
|
+ Parameters = parameters,
|
|
|
+ Priority = 100,
|
|
|
+ Description = $"完全匹配词语'{word}'",
|
|
|
+ FallbackToNext = false
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // 阶段2：开头匹配
|
|
|
+ if (structure.Words.Any() && config.EnablePrefixMatch)
|
|
|
+ {
|
|
|
+ foreach (var word in structure.Words)
|
|
|
+ {
|
|
|
+ var (condition, parameters) = BuildPrefixCondition(word, searchFields, $"{prefix}prefix_{stages.Count}");
|
|
|
+ if (!string.IsNullOrEmpty(condition))
|
|
|
+ {
|
|
|
+ stages.Add(new SearchStage
|
|
|
+ {
|
|
|
+ Stage = 2,
|
|
|
+ Name = $"开头匹配: {word}",
|
|
|
+ Condition = condition,
|
|
|
+ Parameters = parameters,
|
|
|
+ Priority = 80,
|
|
|
+ Description = $"以'{word}'开头",
|
|
|
+ FallbackToNext = true
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // 阶段3：词语模糊匹配
|
|
|
+ if (structure.Words.Any() && config.EnableFuzzySearch)
|
|
|
+ {
|
|
|
+ var wordsText = string.Join(" ", structure.Words);
|
|
|
+ var (condition, parameters) = BuildMultiWordCondition(
|
|
|
+ wordsText, searchFields, $"{prefix}fuzzy_{stages.Count}",
|
|
|
+ config.RequireAllWords);
|
|
|
+
|
|
|
+ if (!string.IsNullOrEmpty(condition))
|
|
|
+ {
|
|
|
+ stages.Add(new SearchStage
|
|
|
+ {
|
|
|
+ Stage = 3,
|
|
|
+ Name = "词语模糊匹配",
|
|
|
+ Condition = condition,
|
|
|
+ Parameters = parameters,
|
|
|
+ Priority = 60,
|
|
|
+ Description = $"包含词语: {wordsText}",
|
|
|
+ FallbackToNext = true
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // 阶段4：单字匹配
|
|
|
+ if (structure.SingleChars.Any() && config.EnableCharSearch)
|
|
|
+ {
|
|
|
+ var charsText = string.Join("", structure.SingleChars);
|
|
|
+ var (condition, parameters) = BuildSingleCharCondition(
|
|
|
+ charsText, searchFields, $"{prefix}chars_{stages.Count}",
|
|
|
+ config.RequireAllChars);
|
|
|
+
|
|
|
+ if (!string.IsNullOrEmpty(condition))
|
|
|
+ {
|
|
|
+ stages.Add(new SearchStage
|
|
|
+ {
|
|
|
+ Stage = 4,
|
|
|
+ Name = "单字匹配",
|
|
|
+ Condition = condition,
|
|
|
+ Parameters = parameters,
|
|
|
+ Priority = 40,
|
|
|
+ Description = $"包含单字: {charsText}",
|
|
|
+ FallbackToNext = true
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // 阶段5：智能拆分匹配（新增阶段）
|
|
|
+ if (config.EnableSmartSplitting && structure.Words.Any(w => w.Length >= config.MinSplitLength))
|
|
|
+ {
|
|
|
+ var longWords = structure.Words.Where(w => w.Length >= config.MinSplitLength).ToList();
|
|
|
+ foreach (var longWord in longWords)
|
|
|
+ {
|
|
|
+ if (IsSplittableCombinationWord(longWord))
|
|
|
+ {
|
|
|
+ var (condition, parameters) = BuildSmartSplitConditionForWord(
|
|
|
+ longWord, searchFields, $"{prefix}split_{stages.Count}", config);
|
|
|
+
|
|
|
+ if (!string.IsNullOrEmpty(condition))
|
|
|
+ {
|
|
|
+ stages.Add(new SearchStage
|
|
|
+ {
|
|
|
+ Stage = 5,
|
|
|
+ Name = $"智能拆分: {longWord}",
|
|
|
+ Condition = condition,
|
|
|
+ Parameters = parameters,
|
|
|
+ Priority = 50, // 优先级在词语模糊匹配和单字匹配之间
|
|
|
+ Description = $"智能拆分'{longWord}'为子词或单字",
|
|
|
+ FallbackToNext = true
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // 阶段6：宽松混合匹配
|
|
|
+ if (stages.Any(s => s.Stage >= 3 && s.Stage <= 5))
|
|
|
+ {
|
|
|
+ var mixedConditions = stages
|
|
|
+ .Where(s => s.Stage >= 3 && s.Stage <= 5)
|
|
|
+ .Select(s => s.Condition)
|
|
|
+ .ToList();
|
|
|
+
|
|
|
+ var mixedParameters = stages
|
|
|
+ .Where(s => s.Stage >= 3 && s.Stage <= 5)
|
|
|
+ .SelectMany(s => s.Parameters)
|
|
|
+ .ToList();
|
|
|
+
|
|
|
+ if (mixedConditions.Any())
|
|
|
+ {
|
|
|
+ stages.Add(new SearchStage
|
|
|
+ {
|
|
|
+ Stage = 6,
|
|
|
+ Name = "宽松混合匹配",
|
|
|
+ Condition = $"({string.Join(" OR ", mixedConditions)})",
|
|
|
+ Parameters = mixedParameters,
|
|
|
+ Priority = 20,
|
|
|
+ Description = "词语或单字的任意匹配",
|
|
|
+ FallbackToNext = false
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return stages.OrderByDescending(s => s.Priority).ToList();
|
|
|
+ }
|
|
|
+
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region 核心构建方法
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 智能混合构建条件（支持智能拆分组合词）
|
|
|
+ /// </summary>
|
|
|
+ private static (string, List<SugarParameter>) BuildSmartMixCondition(
|
|
|
+ SearchStructure structure,
|
|
|
+ List<string> searchFields,
|
|
|
+ string prefix,
|
|
|
+ SearchMode searchMode,
|
|
|
+ SearchConfig config)
|
|
|
+ {
|
|
|
+ var parameters = new List<SugarParameter>();
|
|
|
+ var conditions = new List<string>();
|
|
|
+
|
|
|
+ // 分析结构复杂度
|
|
|
+ var complexity = CalculateComplexityScore(structure);
|
|
|
+
|
|
|
+ // 检查是否有需要智能拆分的组合词
|
|
|
+ var longWords = structure.Words.Where(w => w.Length >= config.MinSplitLength).ToList();
|
|
|
+ var shouldSplitLongWords = longWords.Any() && config.EnableSmartSplitting;
|
|
|
+
|
|
|
+ if (shouldSplitLongWords && longWords.Any(w => IsSplittableCombinationWord(w)))
|
|
|
+ {
|
|
|
+ // 使用智能拆分策略处理组合词
|
|
|
+ return BuildSmartSplitCondition(structure, searchFields, prefix, config, longWords);
|
|
|
+ }
|
|
|
+
|
|
|
+ // 智能分析混合类型的特点
|
|
|
+ var hasLongWords = structure.Words.Any(w => w.Length >= 2);
|
|
|
+ var hasManyChars = structure.SingleChars.Count >= 3;
|
|
|
+ var isCharDominant = structure.SingleChars.Count > structure.Words.Count;
|
|
|
+ var hasMixedTypes = structure.HasWords && structure.HasSingleChars;
|
|
|
+
|
|
|
+ // 根据混合特点选择更精细的策略
|
|
|
+ string strategy;
|
|
|
+ if (hasMixedTypes)
|
|
|
+ {
|
|
|
+ if (isCharDominant && hasManyChars)
|
|
|
+ {
|
|
|
+ strategy = "char_optimized"; // 单字主导，优化单字搜索
|
|
|
+ }
|
|
|
+ else if (hasLongWords && !hasManyChars)
|
|
|
+ {
|
|
|
+ strategy = "word_focused"; // 词语为主，单字为辅
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ strategy = complexity >= 6 ? "strict_mixed" :
|
|
|
+ complexity >= 3 ? "balanced_mixed" : "loose_mixed";
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ strategy = complexity >= 7 ? "strict" :
|
|
|
+ complexity >= 4 ? "balanced" : "loose";
|
|
|
+ }
|
|
|
+
|
|
|
+ // 处理词语部分
|
|
|
+ if (structure.HasWords)
|
|
|
+ {
|
|
|
+ if (structure.Words.Count == 1)
|
|
|
+ {
|
|
|
+ // 单个词语
|
|
|
+ var (wordCondition, wordParams) = BuildSingleWordCondition(
|
|
|
+ structure.Words[0], searchFields, $"{prefix}word", config);
|
|
|
+ if (!string.IsNullOrEmpty(wordCondition))
|
|
|
+ {
|
|
|
+ conditions.Add(wordCondition);
|
|
|
+ parameters.AddRange(wordParams);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // 多个词语
|
|
|
+ var wordsText = string.Join(" ", structure.Words);
|
|
|
+
|
|
|
+ // 根据策略动态调整词语匹配要求
|
|
|
+ bool requireAllWords;
|
|
|
+ if (strategy == "char_optimized" && isCharDominant)
|
|
|
+ {
|
|
|
+ // 单字主导时，放宽词语要求
|
|
|
+ requireAllWords = false;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ requireAllWords = strategy.Contains("strict") || config.RequireAllWords;
|
|
|
+ }
|
|
|
+
|
|
|
+ var (wordsCondition, wordsParams) = BuildMultiWordCondition(
|
|
|
+ wordsText, searchFields, $"{prefix}words", requireAllWords);
|
|
|
+
|
|
|
+ if (!string.IsNullOrEmpty(wordsCondition))
|
|
|
+ {
|
|
|
+ conditions.Add(wordsCondition);
|
|
|
+ parameters.AddRange(wordsParams);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // 处理单字部分 - 优化策略
|
|
|
+ if (structure.HasSingleChars)
|
|
|
+ {
|
|
|
+ var charsText = string.Join("", structure.SingleChars);
|
|
|
+
|
|
|
+ // 根据策略动态调整单字匹配要求
|
|
|
+ bool requireAllChars;
|
|
|
+ string charStrategy;
|
|
|
+
|
|
|
+ if (strategy == "char_optimized")
|
|
|
+ {
|
|
|
+ // 单字优化策略：多个单字时放宽要求
|
|
|
+ requireAllChars = structure.SingleChars.Count <= 3; // 3个及以下单字要求全部匹配
|
|
|
+ charStrategy = "optimized";
|
|
|
+ }
|
|
|
+ else if (strategy.Contains("loose"))
|
|
|
+ {
|
|
|
+ requireAllChars = false;
|
|
|
+ charStrategy = "loose";
|
|
|
+ }
|
|
|
+ else if (strategy.Contains("strict"))
|
|
|
+ {
|
|
|
+ requireAllChars = true;
|
|
|
+ charStrategy = "strict";
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ requireAllChars = strategy.Contains("balanced") && structure.SingleChars.Count <= 2;
|
|
|
+ charStrategy = "balanced";
|
|
|
+ }
|
|
|
+
|
|
|
+ var (charsCondition, charsParams) = BuildEnhancedCharCondition(
|
|
|
+ charsText, searchFields, $"{prefix}chars",
|
|
|
+ requireAllChars, charStrategy);
|
|
|
+
|
|
|
+ if (!string.IsNullOrEmpty(charsCondition))
|
|
|
+ {
|
|
|
+ conditions.Add(charsCondition);
|
|
|
+ parameters.AddRange(charsParams);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // 构建最终条件
|
|
|
+ if (!conditions.Any())
|
|
|
+ return (string.Empty, parameters);
|
|
|
+
|
|
|
+ string finalCondition = BuildMixedConditionByStrategy(
|
|
|
+ conditions, structure, strategy);
|
|
|
+
|
|
|
+ return (finalCondition, parameters);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 构建智能拆分条件（针对长词如"重庆科学"）
|
|
|
+ /// </summary>
|
|
|
+ private static (string, List<SugarParameter>) BuildSmartSplitCondition(
|
|
|
+ SearchStructure structure,
|
|
|
+ List<string> searchFields,
|
|
|
+ string prefix,
|
|
|
+ SearchConfig config,
|
|
|
+ List<string> longWords)
|
|
|
+ {
|
|
|
+ var parameters = new List<SugarParameter>();
|
|
|
+ var conditions = new List<string>();
|
|
|
+
|
|
|
+ // 处理所有长词（需要拆分的词）
|
|
|
+ foreach (var longWord in longWords)
|
|
|
+ {
|
|
|
+ if (IsSplittableCombinationWord(longWord))
|
|
|
+ {
|
|
|
+ // 为每个长词构建多层次条件
|
|
|
+ var (wordConditions, wordParams) = BuildMultiLevelConditionForWord(
|
|
|
+ longWord, searchFields, $"{prefix}word_{longWord.GetHashCode()}", config);
|
|
|
+
|
|
|
+ conditions.AddRange(wordConditions);
|
|
|
+ parameters.AddRange(wordParams);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // 普通长词，直接搜索
|
|
|
+ var (wordCondition, wordParams) = BuildSingleWordCondition(
|
|
|
+ longWord, searchFields, $"{prefix}long_{parameters.Count}", config);
|
|
|
+
|
|
|
+ if (!string.IsNullOrEmpty(wordCondition))
|
|
|
+ {
|
|
|
+ conditions.Add(wordCondition);
|
|
|
+ parameters.AddRange(wordParams);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // 处理剩余的非长词
|
|
|
+ var normalWords = structure.Words.Where(w => w.Length < config.MinSplitLength).ToList();
|
|
|
+ if (normalWords.Any())
|
|
|
+ {
|
|
|
+ var wordsText = string.Join(" ", normalWords);
|
|
|
+ var (normalCondition, normalParams) = BuildMultiWordCondition(
|
|
|
+ wordsText, searchFields, $"{prefix}normal", config.RequireAllWords);
|
|
|
+
|
|
|
+ if (!string.IsNullOrEmpty(normalCondition))
|
|
|
+ {
|
|
|
+ conditions.Add(normalCondition);
|
|
|
+ parameters.AddRange(normalParams);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // 处理原有的单字
|
|
|
+ if (structure.SingleChars.Any())
|
|
|
+ {
|
|
|
+ var charsText = string.Join("", structure.SingleChars);
|
|
|
+ var (charCondition, charParams) = BuildSingleCharCondition(
|
|
|
+ charsText, searchFields, $"{prefix}single", false);
|
|
|
+
|
|
|
+ if (!string.IsNullOrEmpty(charCondition))
|
|
|
+ {
|
|
|
+ conditions.Add(charCondition);
|
|
|
+ parameters.AddRange(charParams);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // 构建最终条件：使用层次化OR连接
|
|
|
+ if (conditions.Count == 0)
|
|
|
+ return (string.Empty, parameters);
|
|
|
+
|
|
|
+ if (conditions.Count == 1)
|
|
|
+ return (conditions[0], parameters);
|
|
|
+
|
|
|
+ // 对条件进行分组和优先级排序
|
|
|
+ var groupedConditions = GroupConditionsByPriority(conditions, longWords);
|
|
|
+ return (BuildHierarchicalCondition(groupedConditions), parameters);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 为单个长词构建多层次条件
|
|
|
+ /// </summary>
|
|
|
+ private static (List<string> Conditions, List<SugarParameter> Parameters) BuildMultiLevelConditionForWord(
|
|
|
+ string longWord,
|
|
|
+ List<string> searchFields,
|
|
|
+ string prefix,
|
|
|
+ SearchConfig config)
|
|
|
+ {
|
|
|
+ var conditions = new List<string>();
|
|
|
+ var parameters = new List<SugarParameter>();
|
|
|
+
|
|
|
+ // 第一层：完整词匹配（最高优先级）
|
|
|
+ var (fullCondition, fullParams) = BuildSingleWordCondition(
|
|
|
+ longWord, searchFields, $"{prefix}_full", config);
|
|
|
+
|
|
|
+ if (!string.IsNullOrEmpty(fullCondition))
|
|
|
+ {
|
|
|
+ conditions.Add(fullCondition);
|
|
|
+ parameters.AddRange(fullParams);
|
|
|
+ }
|
|
|
+
|
|
|
+ // 第二层：智能拆分成子词
|
|
|
+ var subWords = SplitCombinationWord(longWord);
|
|
|
+ if (subWords.Count >= 2)
|
|
|
+ {
|
|
|
+ var (splitCondition, splitParams) = BuildMultiWordCondition(
|
|
|
+ string.Join(" ", subWords),
|
|
|
+ searchFields,
|
|
|
+ $"{prefix}_split",
|
|
|
+ config.RequireAllWordsForSplit);
|
|
|
+
|
|
|
+ if (!string.IsNullOrEmpty(splitCondition))
|
|
|
+ {
|
|
|
+ conditions.Add($"({splitCondition})"); // 用括号包裹
|
|
|
+ parameters.AddRange(splitParams);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // 第三层：拆分成单字作为备选
|
|
|
+ var chars = longWord.ToCharArray().Select(c => c.ToString()).ToList();
|
|
|
+ var (charCondition, charParams) = BuildSingleCharCondition(
|
|
|
+ string.Join("", chars),
|
|
|
+ searchFields,
|
|
|
+ $"{prefix}_chars",
|
|
|
+ config.RequireAllCharsForSplit);
|
|
|
+
|
|
|
+ if (!string.IsNullOrEmpty(charCondition))
|
|
|
+ {
|
|
|
+ conditions.Add($"({charCondition})");
|
|
|
+ parameters.AddRange(charParams);
|
|
|
+ }
|
|
|
+
|
|
|
+ // 如果有多层条件，构建OR连接
|
|
|
+ if (conditions.Count > 1)
|
|
|
+ {
|
|
|
+ var combinedCondition = $"({string.Join(" OR ", conditions)})";
|
|
|
+ return (new List<string> { combinedCondition }, parameters);
|
|
|
+ }
|
|
|
+
|
|
|
+ return (conditions, parameters);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 构建智能拆分条件（用于分阶段搜索）
|
|
|
+ /// </summary>
|
|
|
+ private static (string, List<SugarParameter>) BuildSmartSplitConditionForWord(
|
|
|
+ string longWord,
|
|
|
+ List<string> searchFields,
|
|
|
+ string prefix,
|
|
|
+ SearchConfig config)
|
|
|
+ {
|
|
|
+ var (conditions, parameters) = BuildMultiLevelConditionForWord(longWord, searchFields, prefix, config);
|
|
|
+
|
|
|
+ if (conditions.Any())
|
|
|
+ {
|
|
|
+ return (conditions[0], parameters);
|
|
|
+ }
|
|
|
+
|
|
|
+ return (string.Empty, new List<SugarParameter>());
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 词语和单字组合条件
|
|
|
+ /// </summary>
|
|
|
+ private static (string, List<SugarParameter>) BuildWordsAndCharsCondition(
|
|
|
+ SearchStructure structure,
|
|
|
+ List<string> searchFields,
|
|
|
+ string prefix,
|
|
|
+ SearchConfig config)
|
|
|
+ {
|
|
|
+ var parameters = new List<SugarParameter>();
|
|
|
+ var conditions = new List<string>();
|
|
|
+
|
|
|
+ // 词语部分（必须满足）
|
|
|
+ if (structure.Words.Any())
|
|
|
+ {
|
|
|
+ var wordsText = string.Join(" ", structure.Words);
|
|
|
+ var (wordsCondition, wordsParams) = BuildMultiWordCondition(
|
|
|
+ wordsText, searchFields, $"{prefix}w", true);
|
|
|
+
|
|
|
+ if (!string.IsNullOrEmpty(wordsCondition))
|
|
|
+ {
|
|
|
+ conditions.Add(wordsCondition);
|
|
|
+ parameters.AddRange(wordsParams);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // 单字部分（作为增强条件）
|
|
|
+ if (structure.SingleChars.Any())
|
|
|
+ {
|
|
|
+ var charsText = string.Join("", structure.SingleChars);
|
|
|
+ var (charsCondition, charsParams) = BuildSingleCharCondition(
|
|
|
+ charsText, searchFields, $"{prefix}c", false);
|
|
|
+
|
|
|
+ if (!string.IsNullOrEmpty(charsCondition))
|
|
|
+ {
|
|
|
+ // 单字作为加分项，用OR连接
|
|
|
+ conditions.Add($"({charsCondition})");
|
|
|
+ parameters.AddRange(charsParams);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!conditions.Any())
|
|
|
+ return (string.Empty, parameters);
|
|
|
+
|
|
|
+ // 构建条件：词语必须满足，单字作为增强
|
|
|
+ string finalCondition = conditions.Count > 1
|
|
|
+ ? $"({conditions[0]} AND ({string.Join(" OR ", conditions.Skip(1))}))"
|
|
|
+ : conditions[0];
|
|
|
+
|
|
|
+ return (finalCondition, parameters);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 仅词语条件
|
|
|
+ /// </summary>
|
|
|
+ private static (string, List<SugarParameter>) BuildWordsOnlyCondition(
|
|
|
+ SearchStructure structure,
|
|
|
+ List<string> searchFields,
|
|
|
+ string prefix,
|
|
|
+ SearchConfig config)
|
|
|
+ {
|
|
|
+ if (!structure.Words.Any())
|
|
|
+ return (string.Empty, new List<SugarParameter>());
|
|
|
+
|
|
|
+ var wordsText = string.Join(" ", structure.Words);
|
|
|
+
|
|
|
+ if (structure.Words.Count == 1)
|
|
|
+ {
|
|
|
+ return BuildSingleWordCondition(wordsText, searchFields, prefix, config);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ return BuildMultiWordCondition(wordsText, searchFields, prefix, config.RequireAllWords);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 仅单字条件
|
|
|
+ /// </summary>
|
|
|
+ private static (string, List<SugarParameter>) BuildCharsOnlyCondition(
|
|
|
+ SearchStructure structure,
|
|
|
+ List<string> searchFields,
|
|
|
+ string prefix,
|
|
|
+ SearchConfig config)
|
|
|
+ {
|
|
|
+ if (!structure.SingleChars.Any())
|
|
|
+ return (string.Empty, new List<SugarParameter>());
|
|
|
+
|
|
|
+ var charsText = string.Join("", structure.SingleChars);
|
|
|
+ return BuildSingleCharCondition(charsText, searchFields, prefix, config.RequireAllChars);
|
|
|
+ }
|
|
|
+
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region 基础条件构建方法
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 构建单词条查询条件
|
|
|
+ /// </summary>
|
|
|
+ public static (string Condition, List<SugarParameter> Parameters) BuildSingleWordCondition(
|
|
|
+ string searchTerm,
|
|
|
+ List<string> searchFields,
|
|
|
+ string prefix,
|
|
|
+ SearchConfig config = null)
|
|
|
+ {
|
|
|
+ config ??= new SearchConfig();
|
|
|
+ var parameters = new List<SugarParameter>();
|
|
|
+ var fieldConditions = new List<string>();
|
|
|
+ var paramName = $"{prefix}word";
|
|
|
+
|
|
|
+ foreach (var field in searchFields)
|
|
|
+ {
|
|
|
+ fieldConditions.Add($"{field} LIKE @{paramName}");
|
|
|
+ }
|
|
|
+
|
|
|
+ string condition = $"({string.Join(" OR ", fieldConditions)})";
|
|
|
+ parameters.Add(new SugarParameter($"@{paramName}", $"%{searchTerm}%"));
|
|
|
+
|
|
|
+ return (condition, parameters);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 构建多词条查询条件
|
|
|
+ /// </summary>
|
|
|
+ public static (string Condition, List<SugarParameter> Parameters) BuildMultiWordCondition(
|
|
|
+ string searchTerm,
|
|
|
+ List<string> searchFields,
|
|
|
+ string prefix,
|
|
|
+ bool requireAll = true)
|
|
|
+ {
|
|
|
+ var parameters = new List<SugarParameter>();
|
|
|
+ var separators = new[] { ' ', '，', '、', ',', ';', '；' };
|
|
|
+ var words = searchTerm.Split(separators, StringSplitOptions.RemoveEmptyEntries)
|
|
|
+ .Select(w => w.Trim())
|
|
|
+ .Where(w => !string.IsNullOrEmpty(w))
|
|
|
+ .Distinct()
|
|
|
+ .ToList();
|
|
|
+
|
|
|
+ if (!words.Any())
|
|
|
+ return (string.Empty, parameters);
|
|
|
+
|
|
|
+ var wordConditions = new List<string>();
|
|
|
+
|
|
|
+ foreach (var word in words)
|
|
|
+ {
|
|
|
+ var fieldConditions = new List<string>();
|
|
|
+ var paramName = $"{prefix}word_{parameters.Count}";
|
|
|
+
|
|
|
+ foreach (var field in searchFields)
|
|
|
+ {
|
|
|
+ fieldConditions.Add($"{field} LIKE @{paramName}");
|
|
|
+ }
|
|
|
+
|
|
|
+ wordConditions.Add($"({string.Join(" OR ", fieldConditions)})");
|
|
|
+ parameters.Add(new SugarParameter($"@{paramName}", $"%{word}%"));
|
|
|
+ }
|
|
|
+
|
|
|
+ // 构建条件
|
|
|
+ string condition;
|
|
|
+ if (requireAll && words.Count > 1)
|
|
|
+ {
|
|
|
+ condition = $"({string.Join(" AND ", wordConditions)})";
|
|
|
+ }
|
|
|
+ else if (!requireAll && words.Count > 1)
|
|
|
+ {
|
|
|
+ condition = $"({string.Join(" OR ", wordConditions)})";
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ condition = wordConditions.FirstOrDefault() ?? "";
|
|
|
+ }
|
|
|
+
|
|
|
+ return (condition, parameters);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 构建单字查询条件
|
|
|
+ /// </summary>
|
|
|
+ public static (string Condition, List<SugarParameter> Parameters) BuildSingleCharCondition(
|
|
|
+ string searchTerm,
|
|
|
+ List<string> searchFields,
|
|
|
+ string prefix,
|
|
|
+ bool requireAll = true)
|
|
|
+ {
|
|
|
+ var parameters = new List<SugarParameter>();
|
|
|
+ var cleanTerm = RemoveSeparators(searchTerm);
|
|
|
+ var chars = cleanTerm.ToCharArray().Distinct().ToArray();
|
|
|
+
|
|
|
+ if (chars.Length == 0)
|
|
|
+ return (string.Empty, parameters);
|
|
|
+
|
|
|
+ var charConditions = new List<string>();
|
|
|
+
|
|
|
+ foreach (char c in chars)
|
|
|
+ {
|
|
|
+ var fieldConditions = new List<string>();
|
|
|
+ var paramName = $"{prefix}char_{parameters.Count}";
|
|
|
+
|
|
|
+ foreach (var field in searchFields)
|
|
|
+ {
|
|
|
+ fieldConditions.Add($"{field} LIKE @{paramName}");
|
|
|
+ }
|
|
|
+
|
|
|
+ charConditions.Add($"({string.Join(" OR ", fieldConditions)})");
|
|
|
+ parameters.Add(new SugarParameter($"@{paramName}", $"%{c}%"));
|
|
|
+ }
|
|
|
+
|
|
|
+ // 构建条件
|
|
|
+ string condition;
|
|
|
+ if (requireAll && chars.Length > 1)
|
|
|
+ {
|
|
|
+ condition = $"({string.Join(" AND ", charConditions)})";
|
|
|
+ }
|
|
|
+ else if (!requireAll && chars.Length > 1)
|
|
|
+ {
|
|
|
+ condition = $"({string.Join(" OR ", charConditions)})";
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ condition = charConditions.FirstOrDefault() ?? "";
|
|
|
+ }
|
|
|
+
|
|
|
+ return (condition, parameters);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 构建增强的单字搜索条件（支持不同策略）
|
|
|
+ /// </summary>
|
|
|
+ private static (string, List<SugarParameter>) BuildEnhancedCharCondition(
|
|
|
+ string searchTerm,
|
|
|
+ List<string> searchFields,
|
|
|
+ string prefix,
|
|
|
+ bool requireAll,
|
|
|
+ string strategy)
|
|
|
+ {
|
|
|
+ var parameters = new List<SugarParameter>();
|
|
|
+ var cleanTerm = RemoveSeparators(searchTerm);
|
|
|
+ var chars = cleanTerm.ToCharArray().Distinct().ToArray();
|
|
|
+
|
|
|
+ if (chars.Length == 0)
|
|
|
+ return (string.Empty, parameters);
|
|
|
+
|
|
|
+ // 根据策略调整处理方式
|
|
|
+ var charConditions = new List<string>();
|
|
|
+
|
|
|
+ foreach (char c in chars)
|
|
|
+ {
|
|
|
+ var fieldConditions = new List<string>();
|
|
|
+ var paramName = $"{prefix}char_{parameters.Count}";
|
|
|
+
|
|
|
+ foreach (var field in searchFields)
|
|
|
+ {
|
|
|
+ // 根据不同策略使用不同的匹配方式
|
|
|
+ if (strategy == "optimized" && IsChineseCharacter(c))
|
|
|
+ {
|
|
|
+ // 优化策略：中文单字更宽松
|
|
|
+ fieldConditions.Add($"({field} LIKE @{paramName} OR {field} LIKE @{paramName}_prefix)");
|
|
|
+ parameters.Add(new SugarParameter($"@{paramName}", $"%{c}%"));
|
|
|
+ parameters.Add(new SugarParameter($"@{paramName}_prefix", $"{c}%"));
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ fieldConditions.Add($"{field} LIKE @{paramName}");
|
|
|
+ parameters.Add(new SugarParameter($"@{paramName}", $"%{c}%"));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ charConditions.Add($"({string.Join(" OR ", fieldConditions)})");
|
|
|
+ }
|
|
|
+
|
|
|
+ // 根据策略构建条件
|
|
|
+ string condition;
|
|
|
+ if (requireAll && chars.Length > 1)
|
|
|
+ {
|
|
|
+ // 必须包含所有单字
|
|
|
+ condition = $"({string.Join(" AND ", charConditions)})";
|
|
|
+ }
|
|
|
+ else if (!requireAll && chars.Length > 1)
|
|
|
+ {
|
|
|
+ // 任意一个单字即可
|
|
|
+ condition = $"({string.Join(" OR ", charConditions)})";
|
|
|
+ }
|
|
|
+ else if (strategy == "optimized" && chars.Length > 2)
|
|
|
+ {
|
|
|
+ // 优化策略：3个以上单字时，至少匹配一半
|
|
|
+ int requiredCount = (int)Math.Ceiling(chars.Length / 2.0);
|
|
|
+ var orConditions = new List<string>();
|
|
|
+
|
|
|
+ // 生成所有可能的组合（限制数量避免爆炸）
|
|
|
+ var combinations = GetCharCombinations(charConditions, chars.Length, requiredCount, 5);
|
|
|
+
|
|
|
+ foreach (var combination in combinations)
|
|
|
+ {
|
|
|
+ orConditions.Add($"({string.Join(" AND ", combination)})");
|
|
|
+ }
|
|
|
+
|
|
|
+ condition = orConditions.Any() ? $"({string.Join(" OR ", orConditions)})" : charConditions.FirstOrDefault() ?? "";
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ condition = charConditions.FirstOrDefault() ?? "";
|
|
|
+ }
|
|
|
+
|
|
|
+ return (condition, parameters);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 构建精确匹配条件
|
|
|
+ /// </summary>
|
|
|
+ public static (string Condition, List<SugarParameter> Parameters) BuildExactCondition(
|
|
|
+ string searchTerm,
|
|
|
+ List<string> searchFields,
|
|
|
+ string prefix)
|
|
|
+ {
|
|
|
+ var parameters = new List<SugarParameter>();
|
|
|
+ var fieldConditions = new List<string>();
|
|
|
+ var paramName = $"{prefix}exact";
|
|
|
+
|
|
|
+ foreach (var field in searchFields)
|
|
|
+ {
|
|
|
+ fieldConditions.Add($"{field} = @{paramName}");
|
|
|
+ }
|
|
|
+
|
|
|
+ string condition = $"({string.Join(" OR ", fieldConditions)})";
|
|
|
+ parameters.Add(new SugarParameter($"@{paramName}", searchTerm.Trim()));
|
|
|
+
|
|
|
+ return (condition, parameters);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 构建开头匹配条件
|
|
|
+ /// </summary>
|
|
|
+ public static (string Condition, List<SugarParameter> Parameters) BuildPrefixCondition(
|
|
|
+ string searchTerm,
|
|
|
+ List<string> searchFields,
|
|
|
+ string prefix)
|
|
|
+ {
|
|
|
+ var parameters = new List<SugarParameter>();
|
|
|
+ var fieldConditions = new List<string>();
|
|
|
+ var paramName = $"{prefix}prefix";
|
|
|
+
|
|
|
+ foreach (var field in searchFields)
|
|
|
+ {
|
|
|
+ fieldConditions.Add($"{field} LIKE @{paramName}");
|
|
|
+ }
|
|
|
+
|
|
|
+ string condition = $"({string.Join(" OR ", fieldConditions)})";
|
|
|
+ parameters.Add(new SugarParameter($"@{paramName}", $"{searchTerm}%"));
|
|
|
+
|
|
|
+ return (condition, parameters);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 构建结尾匹配条件
|
|
|
+ /// </summary>
|
|
|
+ public static (string Condition, List<SugarParameter> Parameters) BuildSuffixCondition(
|
|
|
+ string searchTerm,
|
|
|
+ List<string> searchFields,
|
|
|
+ string prefix)
|
|
|
+ {
|
|
|
+ var parameters = new List<SugarParameter>();
|
|
|
+ var fieldConditions = new List<string>();
|
|
|
+ var paramName = $"{prefix}suffix";
|
|
|
+
|
|
|
+ foreach (var field in searchFields)
|
|
|
+ {
|
|
|
+ fieldConditions.Add($"{field} LIKE @{paramName}");
|
|
|
+ }
|
|
|
+
|
|
|
+ string condition = $"({string.Join(" OR ", fieldConditions)})";
|
|
|
+ parameters.Add(new SugarParameter($"@{paramName}", $"%{searchTerm}"));
|
|
|
+
|
|
|
+ return (condition, parameters);
|
|
|
+ }
|
|
|
+
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region 智能拆分方法
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 判断是否为可拆分的组合词
|
|
|
+ /// </summary>
|
|
|
+ private static bool IsSplittableCombinationWord(string word)
|
|
|
+ {
|
|
|
+ if (word.Length < 4)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ // 检查是否由常见的地名+名词等组成
|
|
|
+ var commonPatterns = new HashSet<string>
|
|
|
+ {
|
|
|
+ "重庆", "北京", "上海", "广州", "深圳", "天津", "武汉", "成都", "杭州", "南京",
|
|
|
+ "科学", "技术", "研究", "发展", "教育", "培训", "管理", "系统", "工程", "设计",
|
|
|
+ "大学", "学院", "学校", "公司", "集团", "中心", "研究所", "实验室", "医院", "银行"
|
|
|
+ };
|
|
|
+
|
|
|
+ // 尝试找到明显的组合边界
|
|
|
+ for (int i = 2; i <= word.Length - 2; i++)
|
|
|
+ {
|
|
|
+ var part1 = word.Substring(0, i);
|
|
|
+ var part2 = word.Substring(i);
|
|
|
+
|
|
|
+ if (commonPatterns.Contains(part1) || commonPatterns.Contains(part2))
|
|
|
+ return true;
|
|
|
+
|
|
|
+ // 检查是否都是常见词汇
|
|
|
+ if (IsCommonWord(part1) && IsCommonWord(part2))
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 拆分组合词
|
|
|
+ /// </summary>
|
|
|
+ private static List<string> SplitCombinationWord(string word)
|
|
|
+ {
|
|
|
+ var result = new List<string>();
|
|
|
+
|
|
|
+ if (word.Length <= 2)
|
|
|
+ {
|
|
|
+ result.Add(word);
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+
|
|
|
+ // 优先按2+2模式拆分（如"重庆科学" -> "重庆", "科学"）
|
|
|
+ if (word.Length == 4)
|
|
|
+ {
|
|
|
+ result.Add(word.Substring(0, 2));
|
|
|
+ result.Add(word.Substring(2, 2));
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+
|
|
|
+ // 尝试按常见模式拆分
|
|
|
+ var commonTwoCharWords = new HashSet<string>
|
|
|
+ {
|
|
|
+ "重庆", "北京", "上海", "广州", "深圳", "天津", "武汉", "成都", "杭州", "南京",
|
|
|
+ "科学", "技术", "研究", "发展", "教育", "培训", "管理", "系统", "工程", "设计",
|
|
|
+ "大学", "学院", "学校", "公司", "集团", "中心", "医院", "银行", "保险", "证券",
|
|
|
+ "软件", "硬件", "网络", "数据", "信息", "智能", "数字", "电子", "通信", "互联网"
|
|
|
+ };
|
|
|
+
|
|
|
+ // 检查前缀
|
|
|
+ for (int i = 2; i <= Math.Min(4, word.Length - 2); i++)
|
|
|
+ {
|
|
|
+ var prefix = word.Substring(0, i);
|
|
|
+ var suffix = word.Substring(i);
|
|
|
+
|
|
|
+ if (commonTwoCharWords.Contains(prefix) ||
|
|
|
+ (i == 2 && IsLikelyWord(prefix)))
|
|
|
+ {
|
|
|
+ result.Add(prefix);
|
|
|
+
|
|
|
+ // 递归拆分剩余部分
|
|
|
+ if (suffix.Length >= 2)
|
|
|
+ {
|
|
|
+ var subSplits = SplitCombinationWord(suffix);
|
|
|
+ result.AddRange(subSplits);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ result.Add(suffix);
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // 无法智能拆分，按固定长度拆分
|
|
|
+ int splitLength = word.Length >= 6 ? 3 : 2;
|
|
|
+ for (int i = 0; i < word.Length; i += splitLength)
|
|
|
+ {
|
|
|
+ var part = word.Substring(i, Math.Min(splitLength, word.Length - i));
|
|
|
+ result.Add(part);
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 检查是否可能是常见词汇
|
|
|
+ /// </summary>
|
|
|
+ private static bool IsLikelyWord(string word)
|
|
|
+ {
|
|
|
+ if (word.Length != 2) return false;
|
|
|
+
|
|
|
+ // 检查是否为常见的中文二字词
|
|
|
+ // 这里可以扩展更复杂的判断逻辑
|
|
|
+ return IsChineseCharacter(word[0]) && IsChineseCharacter(word[1]);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 检查是否是常见词汇
|
|
|
+ /// </summary>
|
|
|
+ private static bool IsCommonWord(string word)
|
|
|
+ {
|
|
|
+ // 这里可以扩展更复杂的常见词判断逻辑
|
|
|
+ // 例如从词典加载、使用统计等
|
|
|
+ var commonWords = new HashSet<string>
|
|
|
+ {
|
|
|
+ "中国", "国家", "人民", "社会", "经济", "文化", "教育", "科技", "发展",
|
|
|
+ "企业", "公司", "市场", "产品", "服务", "技术", "管理", "工作", "生活"
|
|
|
+ };
|
|
|
+
|
|
|
+ return commonWords.Contains(word) ||
|
|
|
+ (word.Length == 2 && IsChineseCharacter(word[0]) && IsChineseCharacter(word[1]));
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 按优先级分组条件
|
|
|
+ /// </summary>
|
|
|
+ private static Dictionary<string, List<string>> GroupConditionsByPriority(
|
|
|
+ List<string> conditions, List<string> longWords)
|
|
|
+ {
|
|
|
+ var groups = new Dictionary<string, List<string>>
|
|
|
+ {
|
|
|
+ ["original"] = new List<string>(), // 原词条件
|
|
|
+ ["split"] = new List<string>(), // 拆分子词条件
|
|
|
+ ["chars"] = new List<string>(), // 单字条件
|
|
|
+ ["normal"] = new List<string>() // 普通词条件
|
|
|
+ };
|
|
|
+
|
|
|
+ // 简单分组逻辑，实际使用中可能需要更复杂的判断
|
|
|
+ int longWordCount = longWords.Count;
|
|
|
+ int currentIndex = 0;
|
|
|
+
|
|
|
+ // 原词条件（每个长词一个）
|
|
|
+ for (int i = 0; i < longWordCount && currentIndex < conditions.Count; i++)
|
|
|
+ {
|
|
|
+ groups["original"].Add(conditions[currentIndex]);
|
|
|
+ currentIndex++;
|
|
|
+ }
|
|
|
+
|
|
|
+ // 拆分子词条件
|
|
|
+ for (int i = 0; i < longWordCount && currentIndex < conditions.Count; i++)
|
|
|
+ {
|
|
|
+ groups["split"].Add(conditions[currentIndex]);
|
|
|
+ currentIndex++;
|
|
|
+ }
|
|
|
+
|
|
|
+ // 单字条件
|
|
|
+ for (int i = 0; i < longWordCount && currentIndex < conditions.Count; i++)
|
|
|
+ {
|
|
|
+ groups["chars"].Add(conditions[currentIndex]);
|
|
|
+ currentIndex++;
|
|
|
+ }
|
|
|
+
|
|
|
+ // 剩余的都是普通词条件
|
|
|
+ while (currentIndex < conditions.Count)
|
|
|
+ {
|
|
|
+ groups["normal"].Add(conditions[currentIndex]);
|
|
|
+ currentIndex++;
|
|
|
+ }
|
|
|
+
|
|
|
+ return groups;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 构建层次化条件
|
|
|
+ /// </summary>
|
|
|
+ private static string BuildHierarchicalCondition(Dictionary<string, List<string>> groups)
|
|
|
+ {
|
|
|
+ var parts = new List<string>();
|
|
|
+
|
|
|
+ // 第一层：原词匹配（最高优先级）
|
|
|
+ if (groups["original"].Any())
|
|
|
+ {
|
|
|
+ parts.Add($"({string.Join(" OR ", groups["original"])})");
|
|
|
+ }
|
|
|
+
|
|
|
+ // 第二层：拆分子词匹配
|
|
|
+ if (groups["split"].Any())
|
|
|
+ {
|
|
|
+ var splitCondition = groups["split"].Count == 1
|
|
|
+ ? groups["split"][0]
|
|
|
+ : $"({string.Join(" AND ", groups["split"])})";
|
|
|
+ parts.Add($"({splitCondition})");
|
|
|
+ }
|
|
|
+
|
|
|
+ // 普通词条件（插入到合适位置）
|
|
|
+ if (groups["normal"].Any())
|
|
|
+ {
|
|
|
+ var normalCondition = groups["normal"].Count == 1
|
|
|
+ ? groups["normal"][0]
|
|
|
+ : $"({string.Join(" AND ", groups["normal"])})";
|
|
|
+
|
|
|
+ // 如果已经有原词条件，放在第二层；否则放在第一层
|
|
|
+ if (parts.Count >= 1)
|
|
|
+ parts.Insert(1, normalCondition);
|
|
|
+ else
|
|
|
+ parts.Add(normalCondition);
|
|
|
+ }
|
|
|
+
|
|
|
+ // 第三层：单字匹配（最低优先级）
|
|
|
+ if (groups["chars"].Any())
|
|
|
+ {
|
|
|
+ var charCondition = groups["chars"].Count == 1
|
|
|
+ ? groups["chars"][0]
|
|
|
+ : $"({string.Join(" OR ", groups["chars"])})";
|
|
|
+ parts.Add($"({charCondition})");
|
|
|
+ }
|
|
|
+
|
|
|
+ if (parts.Count == 0)
|
|
|
+ return string.Empty;
|
|
|
+
|
|
|
+ if (parts.Count == 1)
|
|
|
+ return parts[0];
|
|
|
+
|
|
|
+ // 构建层次化OR条件
|
|
|
+ return $"({string.Join(" OR ", parts)})";
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 根据策略构建混合条件
|
|
|
+ /// </summary>
|
|
|
+ private static string BuildMixedConditionByStrategy(
|
|
|
+ List<string> conditions,
|
|
|
+ SearchStructure structure,
|
|
|
+ string strategy)
|
|
|
+ {
|
|
|
+ if (conditions.Count == 1)
|
|
|
+ return conditions[0];
|
|
|
+
|
|
|
+ switch (strategy)
|
|
|
+ {
|
|
|
+ case "char_optimized":
|
|
|
+ // 单字优化策略：词语作为主要条件，单字作为增强
|
|
|
+ return BuildCharOptimizedCondition(conditions, structure);
|
|
|
+
|
|
|
+ case "word_focused":
|
|
|
+ // 词语聚焦策略：词语必须，单字作为加分
|
|
|
+ return BuildWordFocusedCondition(conditions, structure);
|
|
|
+
|
|
|
+ case "strict_mixed":
|
|
|
+ // 严格混合：所有条件必须满足
|
|
|
+ return BuildStrictCondition(conditions, structure);
|
|
|
+
|
|
|
+ case "balanced_mixed":
|
|
|
+ // 平衡混合：词语必须，单字推荐
|
|
|
+ return BuildBalancedCondition(conditions, structure);
|
|
|
+
|
|
|
+ case "loose_mixed":
|
|
|
+ // 宽松混合：任意条件满足即可
|
|
|
+ return BuildLooseCondition(conditions, structure);
|
|
|
+
|
|
|
+ default:
|
|
|
+ return BuildBalancedCondition(conditions, structure);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 构建单字优化条件
|
|
|
+ /// </summary>
|
|
|
+ private static string BuildCharOptimizedCondition(List<string> conditions, SearchStructure structure)
|
|
|
+ {
|
|
|
+ var wordConditions = conditions
|
|
|
+ .Where((c, i) => i < structure.Words.Count)
|
|
|
+ .ToList();
|
|
|
+
|
|
|
+ var charConditions = conditions
|
|
|
+ .Skip(structure.Words.Count)
|
|
|
+ .ToList();
|
|
|
+
|
|
|
+ if (wordConditions.Any() && charConditions.Any())
|
|
|
+ {
|
|
|
+ // 词语必须，单字作为重要补充（至少匹配一定比例）
|
|
|
+ if (charConditions.Count > 2)
|
|
|
+ {
|
|
|
+ // 多个单字时，要求至少匹配一半
|
|
|
+ int requiredChars = (int)Math.Ceiling(charConditions.Count / 2.0);
|
|
|
+ var charCombinations = GetConditionCombinations(charConditions, requiredChars, 3);
|
|
|
+
|
|
|
+ if (charCombinations.Any())
|
|
|
+ {
|
|
|
+ var charCombinationStrings = charCombinations
|
|
|
+ .Select(comb => $"({string.Join(" AND ", comb)})")
|
|
|
+ .ToList();
|
|
|
+
|
|
|
+ return $"({string.Join(" AND ", wordConditions)} AND ({string.Join(" OR ", charCombinationStrings)}))";
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return $"({string.Join(" AND ", wordConditions)} AND ({string.Join(" OR ", charConditions)}))";
|
|
|
+ }
|
|
|
+ else if (charConditions.Any())
|
|
|
+ {
|
|
|
+ // 只有单字时，至少匹配一半
|
|
|
+ if (charConditions.Count > 1)
|
|
|
+ {
|
|
|
+ int requiredChars = (int)Math.Ceiling(charConditions.Count / 2.0);
|
|
|
+ var combinations = GetConditionCombinations(charConditions, requiredChars, 3);
|
|
|
+
|
|
|
+ if (combinations.Any())
|
|
|
+ {
|
|
|
+ var combinationStrings = combinations
|
|
|
+ .Select(comb => $"({string.Join(" AND ", comb)})")
|
|
|
+ .ToList();
|
|
|
+
|
|
|
+ return $"({string.Join(" OR ", combinationStrings)})";
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return $"({string.Join(" OR ", charConditions)})";
|
|
|
+ }
|
|
|
+
|
|
|
+ return conditions.FirstOrDefault() ?? "";
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 构建词语聚焦条件
|
|
|
+ /// </summary>
|
|
|
+ private static string BuildWordFocusedCondition(List<string> conditions, SearchStructure structure)
|
|
|
+ {
|
|
|
+ var wordConditions = conditions
|
|
|
+ .Where((c, i) => i < structure.Words.Count)
|
|
|
+ .ToList();
|
|
|
+
|
|
|
+ var charConditions = conditions
|
|
|
+ .Skip(structure.Words.Count)
|
|
|
+ .ToList();
|
|
|
+
|
|
|
+ if (wordConditions.Any() && charConditions.Any())
|
|
|
+ {
|
|
|
+ // 词语必须满足，单字作为加分项（OR连接）
|
|
|
+ return $"({string.Join(" AND ", wordConditions)} AND ({string.Join(" OR ", charConditions)}))";
|
|
|
+ }
|
|
|
+
|
|
|
+ return $"({string.Join(" AND ", conditions)})";
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 获取条件组合（限制数量避免爆炸）
|
|
|
+ /// </summary>
|
|
|
+ private static List<List<string>> GetConditionCombinations(
|
|
|
+ List<string> conditions,
|
|
|
+ int requiredCount,
|
|
|
+ int maxCombinations = 10)
|
|
|
+ {
|
|
|
+ var result = new List<List<string>>();
|
|
|
+
|
|
|
+ if (conditions.Count <= requiredCount || conditions.Count <= 1)
|
|
|
+ {
|
|
|
+ result.Add(conditions);
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+
|
|
|
+ // 生成C(n, requiredCount)组合，但限制数量
|
|
|
+ var indices = Enumerable.Range(0, conditions.Count).ToArray();
|
|
|
+ var combinations = GetCombinations(indices, requiredCount, maxCombinations);
|
|
|
+
|
|
|
+ foreach (var combination in combinations)
|
|
|
+ {
|
|
|
+ var selectedConditions = combination
|
|
|
+ .Select(idx => conditions[idx])
|
|
|
+ .ToList();
|
|
|
+
|
|
|
+ result.Add(selectedConditions);
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 获取字符条件组合
|
|
|
+ /// </summary>
|
|
|
+ private static List<List<string>> GetCharCombinations(
|
|
|
+ List<string> charConditions,
|
|
|
+ int totalChars,
|
|
|
+ int requiredCount,
|
|
|
+ int maxCombinations)
|
|
|
+ {
|
|
|
+ return GetConditionCombinations(charConditions, requiredCount, maxCombinations);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 获取索引组合（算法）
|
|
|
+ /// </summary>
|
|
|
+ private static List<List<int>> GetCombinations(int[] indices, int k, int maxCombinations)
|
|
|
+ {
|
|
|
+ var result = new List<List<int>>();
|
|
|
+ var combination = new List<int>();
|
|
|
+
|
|
|
+ void Backtrack(int start)
|
|
|
+ {
|
|
|
+ if (result.Count >= maxCombinations)
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (combination.Count == k)
|
|
|
+ {
|
|
|
+ result.Add(new List<int>(combination));
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (int i = start; i < indices.Length; i++)
|
|
|
+ {
|
|
|
+ combination.Add(indices[i]);
|
|
|
+ Backtrack(i + 1);
|
|
|
+ combination.RemoveAt(combination.Count - 1);
|
|
|
+
|
|
|
+ if (result.Count >= maxCombinations)
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ Backtrack(0);
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region 分析工具方法
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 分析搜索词结构
|
|
|
+ /// </summary>
|
|
|
+ public static SearchStructure AnalyzeSearchStructure(string searchTerm)
|
|
|
+ {
|
|
|
+ var structure = new SearchStructure
|
|
|
+ {
|
|
|
+ OriginalTerm = searchTerm,
|
|
|
+ CleanTerm = searchTerm.Trim(),
|
|
|
+ AnalyzedAt = DateTime.Now
|
|
|
+ };
|
|
|
+
|
|
|
+ // 移除分隔符获取所有字符
|
|
|
+ var cleanTerm = RemoveSeparators(searchTerm);
|
|
|
+ structure.AllCharacters = cleanTerm.ToCharArray().ToList();
|
|
|
+
|
|
|
+ // 分割成词条（保持原始分割）
|
|
|
+ var separators = new[] { ' ', '，', '、', ',', ';', '；', '|', '/', '\\' };
|
|
|
+ var rawSegments = searchTerm.Split(separators, StringSplitOptions.RemoveEmptyEntries)
|
|
|
+ .Select(s => s.Trim())
|
|
|
+ .Where(s => !string.IsNullOrEmpty(s))
|
|
|
+ .ToList();
|
|
|
+
|
|
|
+ structure.Segments = rawSegments;
|
|
|
+
|
|
|
+ // 分析每个段落的类型
|
|
|
+ foreach (var segment in rawSegments)
|
|
|
+ {
|
|
|
+ if (segment.Length == 1 && IsChineseCharacter(segment[0]))
|
|
|
+ {
|
|
|
+ structure.SingleChars.Add(segment);
|
|
|
+ structure.HasSingleChars = true;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ structure.Words.Add(segment);
|
|
|
+ structure.HasWords = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // 设置组合类型
|
|
|
+ if (structure.HasWords && structure.HasSingleChars)
|
|
|
+ {
|
|
|
+ structure.CombinationType = CombinationType.WordsAndChars;
|
|
|
+ structure.Notes = "混合查询：包含词语和单字";
|
|
|
+ }
|
|
|
+ else if (structure.HasWords && !structure.HasSingleChars)
|
|
|
+ {
|
|
|
+ structure.CombinationType = CombinationType.WordsOnly;
|
|
|
+ structure.Notes = structure.Words.Count > 1 ? "多词查询" : "单词查询";
|
|
|
+ }
|
|
|
+ else if (!structure.HasWords && structure.HasSingleChars)
|
|
|
+ {
|
|
|
+ structure.CombinationType = CombinationType.CharsOnly;
|
|
|
+ structure.Notes = structure.SingleChars.Count > 1 ? "多字查询" : "单字查询";
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ structure.CombinationType = CombinationType.Unknown;
|
|
|
+ structure.Notes = "无法识别的查询类型";
|
|
|
+ }
|
|
|
+
|
|
|
+ // 计算复杂度评分
|
|
|
+ structure.ComplexityScore = CalculateComplexityScore(structure);
|
|
|
+
|
|
|
+ return structure;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 计算搜索复杂度评分
|
|
|
+ /// </summary>
|
|
|
+ private static int CalculateComplexityScore(SearchStructure structure)
|
|
|
+ {
|
|
|
+ int score = 0;
|
|
|
+
|
|
|
+ // 词条数量（1-5分）
|
|
|
+ int segmentCount = structure.Words.Count + structure.SingleChars.Count;
|
|
|
+ score += Math.Min(segmentCount, 5);
|
|
|
+
|
|
|
+ // 是否混合类型（加3分）
|
|
|
+ if (structure.HasWords && structure.HasSingleChars)
|
|
|
+ score += 3;
|
|
|
+
|
|
|
+ // 单字数量（每3个加1分，最多2分）
|
|
|
+ if (structure.SingleChars.Count >= 3)
|
|
|
+ score += Math.Min(structure.SingleChars.Count / 3, 2);
|
|
|
+
|
|
|
+ // 词语平均长度（长词加2分）
|
|
|
+ if (structure.Words.Any())
|
|
|
+ {
|
|
|
+ double avgLength = structure.Words.Average(w => w.Length);
|
|
|
+ if (avgLength > 4) score += 2;
|
|
|
+ }
|
|
|
+
|
|
|
+ // 总字符数（10个以上加1分）
|
|
|
+ if (structure.AllCharacters.Count > 10)
|
|
|
+ score += 1;
|
|
|
+
|
|
|
+ return Math.Min(score, 10); // 最高10分
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 获取搜索策略
|
|
|
+ /// </summary>
|
|
|
+ private static MatchStrategy GetMatchStrategy(SearchStructure structure, SearchConfig config)
|
|
|
+ {
|
|
|
+ var complexity = CalculateComplexityScore(structure);
|
|
|
+
|
|
|
+ return new MatchStrategy
|
|
|
+ {
|
|
|
+ StrategyName = complexity >= 7 ? "strict" :
|
|
|
+ complexity >= 4 ? "balanced" : "loose",
|
|
|
+ ComplexityScore = complexity,
|
|
|
+ UseExactMatch = config.EnableExactMatch && structure.Words.Any(w => w.Length >= 3),
|
|
|
+ UsePrefixMatch = config.EnablePrefixMatch,
|
|
|
+ UseFuzzySearch = config.EnableFuzzySearch,
|
|
|
+ UseCharSearch = config.EnableCharSearch && structure.SingleChars.Any(),
|
|
|
+ UseSmartSplitting = config.EnableSmartSplitting && structure.Words.Any(w => w.Length >= config.MinSplitLength),
|
|
|
+ RecommendedPageSize = complexity >= 7 ? 10 : 20
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 获取计分规则
|
|
|
+ /// </summary>
|
|
|
+ private static List<ScoringRule> GetScoringRules(SearchStructure structure, SearchConfig config)
|
|
|
+ {
|
|
|
+ var rules = new List<ScoringRule>();
|
|
|
+
|
|
|
+ // 词语匹配规则
|
|
|
+ foreach (var word in structure.Words)
|
|
|
+ {
|
|
|
+ rules.Add(new ScoringRule
|
|
|
+ {
|
|
|
+ Type = "word",
|
|
|
+ Value = word,
|
|
|
+ BaseScore = 10,
|
|
|
+ Bonus = word.Length >= 3 ? 5 : 2,
|
|
|
+ Multiplier = 1.0,
|
|
|
+ Condition = $"包含词语'{word}'"
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ // 单字匹配规则
|
|
|
+ foreach (var ch in structure.SingleChars)
|
|
|
+ {
|
|
|
+ rules.Add(new ScoringRule
|
|
|
+ {
|
|
|
+ Type = "char",
|
|
|
+ Value = ch,
|
|
|
+ BaseScore = 3,
|
|
|
+ Bonus = 1,
|
|
|
+ Multiplier = 1.0,
|
|
|
+ Condition = $"包含单字'{ch}'"
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ // 混合匹配奖励
|
|
|
+ if (structure.HasWords && structure.HasSingleChars)
|
|
|
+ {
|
|
|
+ rules.Add(new ScoringRule
|
|
|
+ {
|
|
|
+ Type = "combo",
|
|
|
+ Value = "words_and_chars",
|
|
|
+ BaseScore = 0,
|
|
|
+ Bonus = 8,
|
|
|
+ Multiplier = 1.2,
|
|
|
+ Condition = "同时匹配词语和单字"
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ // 智能拆分奖励
|
|
|
+ if (config.EnableSmartSplitting && structure.Words.Any(w => w.Length >= config.MinSplitLength))
|
|
|
+ {
|
|
|
+ rules.Add(new ScoringRule
|
|
|
+ {
|
|
|
+ Type = "smart_split",
|
|
|
+ Value = "smart_split_match",
|
|
|
+ BaseScore = 0,
|
|
|
+ Bonus = 5,
|
|
|
+ Multiplier = 1.1,
|
|
|
+ Condition = "智能拆分匹配"
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ // 完全匹配奖励
|
|
|
+ rules.Add(new ScoringRule
|
|
|
+ {
|
|
|
+ Type = "exact",
|
|
|
+ Value = "exact_match",
|
|
|
+ BaseScore = 0,
|
|
|
+ Bonus = 15,
|
|
|
+ Multiplier = 1.5,
|
|
|
+ Condition = "完全匹配搜索词"
|
|
|
+ });
|
|
|
+
|
|
|
+ return rules;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 获取需要提升权重的字段
|
|
|
+ /// </summary>
|
|
|
+ private static List<string> GetBoostFields(SearchStructure structure, List<string> searchFields)
|
|
|
+ {
|
|
|
+ var boostFields = new List<string>();
|
|
|
+
|
|
|
+ if (structure.HasWords && structure.Words.Any(w => w.Length >= 2))
|
|
|
+ {
|
|
|
+ // 长词语在名称字段中效果更好
|
|
|
+ boostFields.AddRange(searchFields.Where(f =>
|
|
|
+ f.Contains("name", StringComparison.OrdinalIgnoreCase) ||
|
|
|
+ f.Contains("title", StringComparison.OrdinalIgnoreCase) ||
|
|
|
+ f.Contains("subject", StringComparison.OrdinalIgnoreCase)));
|
|
|
+ }
|
|
|
+
|
|
|
+ if (structure.HasSingleChars)
|
|
|
+ {
|
|
|
+ // 单字在描述、内容字段中效果更好
|
|
|
+ boostFields.AddRange(searchFields.Where(f =>
|
|
|
+ f.Contains("desc", StringComparison.OrdinalIgnoreCase) ||
|
|
|
+ f.Contains("content", StringComparison.OrdinalIgnoreCase) ||
|
|
|
+ f.Contains("remark", StringComparison.OrdinalIgnoreCase) ||
|
|
|
+ f.Contains("note", StringComparison.OrdinalIgnoreCase)));
|
|
|
+ }
|
|
|
+
|
|
|
+ return boostFields.Distinct().ToList();
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 计算预期匹配数
|
|
|
+ /// </summary>
|
|
|
+ private static int CalculateExpectedMatches(SearchStructure structure, int fieldCount)
|
|
|
+ {
|
|
|
+ int baseMatches = structure.Words.Count + structure.SingleChars.Count;
|
|
|
+ int expected = baseMatches * fieldCount;
|
|
|
+
|
|
|
+ // 调整预期值
|
|
|
+ if (structure.CombinationType == CombinationType.WordsAndChars)
|
|
|
+ expected = (int)(expected * 1.5);
|
|
|
+ else if (structure.CombinationType == CombinationType.CharsOnly)
|
|
|
+ expected = (int)(expected * 0.7);
|
|
|
+
|
|
|
+ return Math.Max(expected, 1);
|
|
|
+ }
|
|
|
+
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region 条件构建策略
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 构建严格条件（所有条件必须满足）
|
|
|
+ /// </summary>
|
|
|
+ private static string BuildStrictCondition(List<string> conditions, SearchStructure structure)
|
|
|
+ {
|
|
|
+ if (conditions.Count == 1)
|
|
|
+ return conditions[0];
|
|
|
+
|
|
|
+ // 词语条件在前，单字条件在后
|
|
|
+ var wordConditions = conditions
|
|
|
+ .Where((c, i) => i < structure.Words.Count)
|
|
|
+ .ToList();
|
|
|
+
|
|
|
+ var charConditions = conditions
|
|
|
+ .Skip(structure.Words.Count)
|
|
|
+ .ToList();
|
|
|
+
|
|
|
+ if (wordConditions.Any() && charConditions.Any())
|
|
|
+ {
|
|
|
+ return $"({string.Join(" AND ", wordConditions)} AND ({string.Join(" OR ", charConditions)}))";
|
|
|
+ }
|
|
|
+
|
|
|
+ return $"({string.Join(" AND ", conditions)})";
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 构建平衡条件
|
|
|
+ /// </summary>
|
|
|
+ private static string BuildBalancedCondition(List<string> conditions, SearchStructure structure)
|
|
|
+ {
|
|
|
+ if (conditions.Count == 1)
|
|
|
+ return conditions[0];
|
|
|
+
|
|
|
+ // 词语优先，单字作为增强
|
|
|
+ if (structure.HasWords && structure.HasSingleChars)
|
|
|
+ {
|
|
|
+ var wordCondition = conditions.First();
|
|
|
+ var charConditions = conditions.Skip(1).ToList();
|
|
|
+
|
|
|
+ return $"({wordCondition} AND ({string.Join(" OR ", charConditions)}))";
|
|
|
+ }
|
|
|
+
|
|
|
+ return $"({string.Join(" AND ", conditions)})";
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 构建宽松条件（提高召回率）
|
|
|
+ /// </summary>
|
|
|
+ private static string BuildLooseCondition(List<string> conditions, SearchStructure structure)
|
|
|
+ {
|
|
|
+ if (conditions.Count == 1)
|
|
|
+ return conditions[0];
|
|
|
+
|
|
|
+ // 所有条件OR连接
|
|
|
+ return $"({string.Join(" OR ", conditions)})";
|
|
|
+ }
|
|
|
+
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region 实用工具方法
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 检查字符是否为中文字符
|
|
|
+ /// </summary>
|
|
|
+ public static bool IsChineseCharacter(char c)
|
|
|
+ {
|
|
|
+ // 基本汉字（0x4E00-0x9FFF）
|
|
|
+ if (c >= 0x4E00 && c <= 0x9FFF)
|
|
|
+ return true;
|
|
|
+
|
|
|
+ // 扩展A区（0x3400-0x4DBF）
|
|
|
+ if (c >= 0x3400 && c <= 0x4DBF)
|
|
|
+ return true;
|
|
|
+
|
|
|
+ // 基本汉字补充（0x9FA6-0x9FFF）
|
|
|
+ if (c >= 0x9FA6 && c <= 0x9FFF)
|
|
|
+ return true;
|
|
|
+
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 移除字符串中的分隔符
|
|
|
+ /// </summary>
|
|
|
+ private static string RemoveSeparators(string text)
|
|
|
+ {
|
|
|
+ if (string.IsNullOrEmpty(text))
|
|
|
+ return text;
|
|
|
+
|
|
|
+ var separators = new[] { ' ', '，', '、', ',', ';', '；', '-', '_', '.', '。', '·', '|', '/', '\\' };
|
|
|
+ return new string(text.Where(c => !separators.Contains(c)).ToArray());
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 验证搜索字段列表
|
|
|
+ /// </summary>
|
|
|
+ public static (bool IsValid, string Message, List<string> ValidFields) ValidateSearchFields(
|
|
|
+ List<string> searchFields, List<string> allFields)
|
|
|
+ {
|
|
|
+ if (searchFields == null || !searchFields.Any())
|
|
|
+ return (false, "搜索字段列表不能为空", new List<string>());
|
|
|
+
|
|
|
+ if (allFields == null || !allFields.Any())
|
|
|
+ return (true, "无验证字段列表，接受所有输入", searchFields);
|
|
|
+
|
|
|
+ var validFields = searchFields.Intersect(allFields).ToList();
|
|
|
+ var invalidFields = searchFields.Except(allFields).ToList();
|
|
|
+
|
|
|
+ if (invalidFields.Any())
|
|
|
+ {
|
|
|
+ return (false,
|
|
|
+ $"发现无效字段: {string.Join(", ", invalidFields)}",
|
|
|
+ validFields);
|
|
|
+ }
|
|
|
+
|
|
|
+ return (true, "所有字段有效", validFields);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 生成搜索统计信息
|
|
|
+ /// </summary>
|
|
|
+ public static SearchStats GenerateSearchStats(SearchStructure structure, int resultCount)
|
|
|
+ {
|
|
|
+ return new SearchStats
|
|
|
+ {
|
|
|
+ SearchTerm = structure.OriginalTerm,
|
|
|
+ CombinationType = structure.CombinationType,
|
|
|
+ WordCount = structure.Words.Count,
|
|
|
+ CharCount = structure.SingleChars.Count,
|
|
|
+ TotalSegments = structure.Segments.Count,
|
|
|
+ ComplexityScore = structure.ComplexityScore,
|
|
|
+ ResultCount = resultCount,
|
|
|
+ GeneratedAt = DateTime.Now
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ #endregion
|
|
|
+ }
|
|
|
+
|
|
|
+ #region 数据模型和枚举
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 搜索模式枚举
|
|
|
+ /// </summary>
|
|
|
+ public enum SearchMode
|
|
|
+ {
|
|
|
+ /// <summary>
|
|
|
+ /// 自动检测搜索类型
|
|
|
+ /// </summary>
|
|
|
+ [Description("自动检测")]
|
|
|
+ AutoDetect = 0,
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 单词条搜索
|
|
|
+ /// </summary>
|
|
|
+ [Description("单词条搜索")]
|
|
|
+ SingleWord = 1,
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 多词条搜索
|
|
|
+ /// </summary>
|
|
|
+ [Description("多词条搜索")]
|
|
|
+ MultiWord = 2,
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 单字搜索
|
|
|
+ /// </summary>
|
|
|
+ [Description("单字搜索")]
|
|
|
+ SingleChar = 3,
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 精确匹配
|
|
|
+ /// </summary>
|
|
|
+ [Description("精确匹配")]
|
|
|
+ Exact = 4,
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 高级查询
|
|
|
+ /// </summary>
|
|
|
+ [Description("高级查询")]
|
|
|
+ Advanced = 5
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 组合模式枚举
|
|
|
+ /// </summary>
|
|
|
+ public enum CombinationMode
|
|
|
+ {
|
|
|
+ /// <summary>
|
|
|
+ /// 智能混合（自动调整权重和连接方式）
|
|
|
+ /// </summary>
|
|
|
+ [Description("智能混合")]
|
|
|
+ SmartMix = 0,
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 词语和单字组合（词语必须，单字增强）
|
|
|
+ /// </summary>
|
|
|
+ [Description("词语+单字")]
|
|
|
+ WordsAndChars = 1,
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 仅词语
|
|
|
+ /// </summary>
|
|
|
+ [Description("仅词语")]
|
|
|
+ WordsOnly = 2,
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 仅单字
|
|
|
+ /// </summary>
|
|
|
+ [Description("仅单字")]
|
|
|
+ CharsOnly = 3
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 组合类型
|
|
|
+ /// </summary>
|
|
|
+ public enum CombinationType
|
|
|
+ {
|
|
|
+ [Description("未知")]
|
|
|
+ Unknown,
|
|
|
+
|
|
|
+ [Description("仅词语")]
|
|
|
+ WordsOnly,
|
|
|
+
|
|
|
+ [Description("仅单字")]
|
|
|
+ CharsOnly,
|
|
|
+
|
|
|
+ [Description("词语和单字混合")]
|
|
|
+ WordsAndChars
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 搜索结构分析结果
|
|
|
+ /// </summary>
|
|
|
+ public class SearchStructure
|
|
|
+ {
|
|
|
+ public string OriginalTerm { get; set; } = "";
|
|
|
+ public string CleanTerm { get; set; } = "";
|
|
|
+ public DateTime AnalyzedAt { get; set; }
|
|
|
+ public List<string> Segments { get; set; } = new List<string>();
|
|
|
+ public List<string> Words { get; set; } = new List<string>();
|
|
|
+ public List<string> SingleChars { get; set; } = new List<string>();
|
|
|
+ public List<char> AllCharacters { get; set; } = new List<char>();
|
|
|
+ public bool HasWords { get; set; }
|
|
|
+ public bool HasSingleChars { get; set; }
|
|
|
+ public CombinationType CombinationType { get; set; }
|
|
|
+ public string Notes { get; set; } = "";
|
|
|
+ public int ComplexityScore { get; set; }
|
|
|
+
|
|
|
+ // 统计信息
|
|
|
+ public int TotalWordLength => Words.Sum(w => w.Length);
|
|
|
+ public int MaxWordLength => Words.Any() ? Words.Max(w => w.Length) : 0;
|
|
|
+ public double AvgWordLength => Words.Any() ? Words.Average(w => w.Length) : 0;
|
|
|
+ public int TotalCharacterCount => AllCharacters.Count;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 搜索配置类（增强版）
|
|
|
+ /// 控制搜索行为、匹配策略和性能优化的参数集合
|
|
|
+ /// </summary>
|
|
|
+ public class SearchConfig
|
|
|
+ {
|
|
|
+ /// <summary>
|
|
|
+ /// 是否启用精确匹配
|
|
|
+ /// 默认值: true
|
|
|
+ /// 说明: 当设置为true时，系统会尝试使用等号(=)进行完全匹配
|
|
|
+ /// 适用场景: 搜索ID、编码、精确名称等唯一标识
|
|
|
+ /// 示例: 搜索"1001"时，只匹配完全等于"1001"的记录
|
|
|
+ /// 性能影响: 精确匹配通常使用索引，性能最好
|
|
|
+ /// </summary>
|
|
|
+ public bool EnableExactMatch { get; set; } = true;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 是否启用前缀匹配
|
|
|
+ /// 默认值: true
|
|
|
+ /// 说明: 当设置为true时，系统会尝试匹配以搜索词开头的记录
|
|
|
+ /// 适用场景: 自动补全、拼音首字母搜索、编码前缀搜索
|
|
|
+ /// 示例: 搜索"北京"时，会匹配"北京市"、"北京旅游"等
|
|
|
+ /// 性能影响: 前缀匹配可以使用索引，性能良好
|
|
|
+ /// </summary>
|
|
|
+ public bool EnablePrefixMatch { get; set; } = true;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 是否启用模糊搜索
|
|
|
+ /// 默认值: true
|
|
|
+ /// 说明: 当设置为true时，系统会使用LIKE '%关键词%'进行模糊匹配
|
|
|
+ /// 适用场景: 通用全文搜索、包含关系搜索
|
|
|
+ /// 示例: 搜索"长城"时，会匹配"长城旅游"、"八达岭长城"等
|
|
|
+ /// 性能影响: 模糊搜索不能使用普通索引，建议配合全文索引使用
|
|
|
+ /// 注意: 大数据量时可能会影响性能，建议合理设置搜索字段
|
|
|
+ /// </summary>
|
|
|
+ public bool EnableFuzzySearch { get; set; } = true;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 是否启用单字搜索
|
|
|
+ /// 默认值: true
|
|
|
+ /// 说明: 当设置为true时，系统会将搜索词拆分成单个字符进行匹配
|
|
|
+ /// 适用场景: 中文单字搜索、记忆不完整的模糊搜索
|
|
|
+ /// 示例: 搜索"北上广"时，会分别匹配包含"北"、"上"、"广"的记录
|
|
|
+ /// 注意: 启用后会生成多个LIKE条件，可能影响性能
|
|
|
+ /// 建议: 单字数量较多时，考虑使用RequireAllChars控制匹配逻辑
|
|
|
+ /// </summary>
|
|
|
+ public bool EnableCharSearch { get; set; } = true;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 是否要求所有词语都必须匹配
|
|
|
+ /// 默认值: true
|
|
|
+ /// 说明: 当设置为true时，多词搜索中所有词语都必须在记录中出现
|
|
|
+ /// 当设置为false时，任意一个词语出现即可匹配
|
|
|
+ /// 适用场景:
|
|
|
+ /// true - 精确搜索，如"北京 长城"要求同时包含"北京"和"长城"
|
|
|
+ /// false - 宽松搜索，如"北京 长城"匹配包含"北京"或"长城"的记录
|
|
|
+ /// 性能影响: true时可能返回更少结果，但条件更复杂
|
|
|
+ /// 用户体验: true时结果更精确，false时召回率更高
|
|
|
+ /// </summary>
|
|
|
+ public bool RequireAllWords { get; set; } = true;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 是否要求所有单字都必须匹配
|
|
|
+ /// 默认值: true
|
|
|
+ /// 说明: 当设置为true时，单字搜索中所有字符都必须在记录中出现
|
|
|
+ /// 当设置为false时，任意一个字符出现即可匹配
|
|
|
+ /// 适用场景:
|
|
|
+ /// true - 如"北上广"要求同时包含"北"、"上"、"广"
|
|
|
+ /// false - 如"北上广"匹配包含"北"或"上"或"广"的记录
|
|
|
+ /// 注意: 单字数量较多时，建议设为false以提高召回率
|
|
|
+ /// </summary>
|
|
|
+ public bool RequireAllChars { get; set; } = true;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 精确匹配的最小长度要求
|
|
|
+ /// 默认值: 2
|
|
|
+ /// 说明: 只有当搜索词长度大于等于此值时，才会尝试精确匹配
|
|
|
+ /// 适用场景: 避免短词（如"a"、"的"）使用精确匹配
|
|
|
+ /// 示例: 设置为3时，"北京"不会使用精确匹配，"北京市"会使用
|
|
|
+ /// 单位: 字符数
|
|
|
+ /// 建议值: 2-5之间，根据业务需求调整
|
|
|
+ /// </summary>
|
|
|
+ public int MinExactMatchLength { get; set; } = 2;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 搜索词的最大长度限制
|
|
|
+ /// 默认值: 200
|
|
|
+ /// 说明: 超过此长度的搜索词会被自动截断
|
|
|
+ /// 目的:
|
|
|
+ /// 1. 防止恶意输入导致性能问题
|
|
|
+ /// 2. 避免过长的SQL语句
|
|
|
+ /// 3. 提高系统安全性
|
|
|
+ /// 注意: 实际截断时保留前面部分，不会影响搜索意图
|
|
|
+ /// 单位: 字符数
|
|
|
+ /// 建议值: 50-500之间，根据业务场景调整
|
|
|
+ /// </summary>
|
|
|
+ public int MaxSearchTermLength { get; set; } = 200;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 匹配度的最低分数要求
|
|
|
+ /// 默认值: 0
|
|
|
+ /// 说明: 只有匹配度分数大于等于此值的记录才会被返回
|
|
|
+ /// 适用场景: 质量控制，过滤掉相关性太低的结果
|
|
|
+ /// 分数范围: 通常为0-100，具体取决于评分算法
|
|
|
+ /// 示例: 设置为10时，匹配度低于10分的记录会被过滤
|
|
|
+ /// 注意: 需要EnableRelevanceScoring=true才会生效
|
|
|
+ /// </summary>
|
|
|
+ public double MinScore { get; set; } = 0;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 是否启用相关性评分
|
|
|
+ /// 默认值: true
|
|
|
+ /// 说明: 当设置为true时，系统会计算每条记录的匹配度分数
|
|
|
+ /// 功能:
|
|
|
+ /// 1. 按匹配度排序（分数高的在前）
|
|
|
+ /// 2. 可以设置MinScore过滤低分记录
|
|
|
+ /// 3. 提供MatchScore字段供前端显示
|
|
|
+ /// 性能影响: 会增加计算开销，但用户体验更好
|
|
|
+ /// 建议: 搜索结果需要排序时启用，简单列表查询可关闭
|
|
|
+ /// </summary>
|
|
|
+ public bool EnableRelevanceScoring { get; set; } = true;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 是否启用分阶段搜索
|
|
|
+ /// 默认值: false
|
|
|
+ /// 说明: 当设置为true时，系统会按优先级分阶段执行搜索
|
|
|
+ /// 搜索阶段:
|
|
|
+ /// 1. 精确匹配（最高优先级）
|
|
|
+ /// 2. 前缀匹配
|
|
|
+ /// 3. 模糊匹配
|
|
|
+ /// 4. 单字匹配（最低优先级）
|
|
|
+ /// 优点:
|
|
|
+ /// 1. 优先返回最相关的结果
|
|
|
+ /// 2. 可以设置降级策略
|
|
|
+ /// 3. 提高搜索成功率
|
|
|
+ /// 缺点:
|
|
|
+ /// 1. 可能执行多次查询
|
|
|
+ /// 2. 逻辑更复杂
|
|
|
+ /// 适用场景: 对搜索结果质量要求较高的场景
|
|
|
+ /// </summary>
|
|
|
+ public bool EnableStagedSearch { get; set; } = false;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 字段权重配置
|
|
|
+ /// 默认值: 预定义的权重字典
|
|
|
+ /// 说明: 控制不同字段在匹配度计算中的重要性
|
|
|
+ /// 权重范围: 建议0.5-2.0之间
|
|
|
+ /// 示例配置:
|
|
|
+ /// "name": 1.5 // 名称字段权重高
|
|
|
+ /// "title": 1.5 // 标题字段权重高
|
|
|
+ /// "code": 1.3 // 编码字段权重中
|
|
|
+ /// "desc": 1.0 // 描述字段权重正常
|
|
|
+ /// "remark": 0.7 // 备注字段权重低
|
|
|
+ /// 使用方式:
|
|
|
+ /// 1. 匹配度分数 = 基础分 × 字段权重
|
|
|
+ /// 2. 权重高的字段对总分影响更大
|
|
|
+ /// 建议: 根据业务重要性调整权重
|
|
|
+ /// </summary>
|
|
|
+ public Dictionary<string, double> FieldWeights { get; set; } = new Dictionary<string, double>
|
|
|
+ {
|
|
|
+ { "name", 1.5 },
|
|
|
+ { "title", 1.5 },
|
|
|
+ { "code", 1.3 },
|
|
|
+ { "description", 1.0 },
|
|
|
+ { "content", 0.8 },
|
|
|
+ { "remark", 0.7 }
|
|
|
+ };
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 是否启用同义词扩展
|
|
|
+ /// 默认值: false
|
|
|
+ /// 说明: 当设置为true时，系统会自动扩展搜索词的同义词
|
|
|
+ /// 示例: 搜索"电脑"时，也会搜索"计算机"、"微机"等
|
|
|
+ /// 实现方式: 需要配合同义词词典使用
|
|
|
+ /// 优点: 提高召回率，改善搜索体验
|
|
|
+ /// 缺点: 可能引入不相关结果
|
|
|
+ /// 适用场景: 专业术语搜索、方言词汇搜索
|
|
|
+ /// </summary>
|
|
|
+ public bool EnableSynonymExpansion { get; set; } = false;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 是否启用拼音搜索
|
|
|
+ /// 默认值: false
|
|
|
+ /// 说明: 当设置为true时，系统会将中文转换为拼音进行搜索
|
|
|
+ /// 示例: 搜索"beijing"可以匹配"北京"
|
|
|
+ /// 实现方式: 需要拼音转换库
|
|
|
+ /// 适用场景:
|
|
|
+ /// 1. 输入拼音搜索中文
|
|
|
+ /// 2. 首字母搜索（如"bj"匹配"北京"）
|
|
|
+ /// 注意: 会增加搜索复杂度和索引大小
|
|
|
+ /// </summary>
|
|
|
+ public bool EnablePinyinSearch { get; set; } = false;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 搜索结果的最大数量限制
|
|
|
+ /// 默认值: 1000
|
|
|
+ /// 说明: 限制单次搜索返回的最大记录数
|
|
|
+ /// 目的:
|
|
|
+ /// 1. 防止返回过多数据影响性能
|
|
|
+ /// 2. 避免内存溢出
|
|
|
+ /// 3. 提高响应速度
|
|
|
+ /// 注意: 分页查询时，此限制针对总记录数
|
|
|
+ /// 建议值: 500-5000之间，根据系统承载能力调整
|
|
|
+ /// </summary>
|
|
|
+ public int MaxResultCount { get; set; } = 1000;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 是否启用搜索缓存
|
|
|
+ /// 默认值: false
|
|
|
+ /// 说明: 当设置为true时，相同的搜索条件会使用缓存结果
|
|
|
+ /// 缓存策略:
|
|
|
+ /// 1. 基于搜索词和参数的哈希值
|
|
|
+ /// 2. 可设置缓存时间
|
|
|
+ /// 3. 支持滑动过期
|
|
|
+ /// 适用场景:
|
|
|
+ /// 1. 热门搜索词
|
|
|
+ /// 2. 数据更新频率低的场景
|
|
|
+ /// 3. 性能要求高的搜索
|
|
|
+ /// 注意: 数据频繁更新时，需要合理设置缓存时间
|
|
|
+ /// </summary>
|
|
|
+ public bool EnableSearchCache { get; set; } = false;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 缓存时间（分钟）
|
|
|
+ /// 默认值: 5
|
|
|
+ /// 说明: 搜索结果的缓存保留时间
|
|
|
+ /// 单位: 分钟
|
|
|
+ /// 使用条件: 需要EnableSearchCache=true
|
|
|
+ /// 建议值:
|
|
|
+ /// - 高频搜索: 1-5分钟
|
|
|
+ /// - 低频搜索: 10-30分钟
|
|
|
+ /// - 静态数据: 60分钟以上
|
|
|
+ /// </summary>
|
|
|
+ public int CacheDurationMinutes { get; set; } = 5;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 是否启用搜索词分析
|
|
|
+ /// 默认值: true
|
|
|
+ /// 说明: 当设置为true时，系统会对搜索词进行智能分析
|
|
|
+ /// 分析内容:
|
|
|
+ /// 1. 去除停用词（的、了、在等）
|
|
|
+ /// 2. 提取关键词
|
|
|
+ /// 3. 识别搜索意图
|
|
|
+ /// 4. 分析词性
|
|
|
+ /// 优点: 提高搜索准确性和智能性
|
|
|
+ /// 性能影响: 轻微，主要消耗在分析算法上
|
|
|
+ /// 建议: 一般保持启用状态
|
|
|
+ /// </summary>
|
|
|
+ public bool EnableQueryAnalysis { get; set; } = true;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 是否记录搜索日志
|
|
|
+ /// 默认值: false
|
|
|
+ /// 说明: 当设置为true时，系统会记录搜索行为日志
|
|
|
+ /// 记录内容:
|
|
|
+ /// 1. 搜索词
|
|
|
+ /// 2. 搜索时间
|
|
|
+ /// 3. 返回结果数
|
|
|
+ /// 4. 响应时间
|
|
|
+ /// 5. 用户信息（可选）
|
|
|
+ /// 用途:
|
|
|
+ /// 1. 分析用户搜索习惯
|
|
|
+ /// 2. 优化搜索算法
|
|
|
+ /// 3. 监控搜索性能
|
|
|
+ /// 4. 安全审计
|
|
|
+ /// 注意: 涉及隐私时需谨慎处理
|
|
|
+ /// </summary>
|
|
|
+ public bool EnableSearchLogging { get; set; } = false;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 搜索超时时间（秒）
|
|
|
+ /// 默认值: 30
|
|
|
+ /// 说明: 搜索操作的最大执行时间
|
|
|
+ /// 目的:
|
|
|
+ /// 1. 防止长时间运行的查询
|
|
|
+ /// 2. 提高系统稳定性
|
|
|
+ /// 3. 改善用户体验
|
|
|
+ /// 单位: 秒
|
|
|
+ /// 建议值:
|
|
|
+ /// - 实时搜索: 5-10秒
|
|
|
+ /// - 后台搜索: 30-60秒
|
|
|
+ /// - 大数据搜索: 120秒以上
|
|
|
+ /// 注意: 超时后会取消查询，返回已有结果或错误
|
|
|
+ /// </summary>
|
|
|
+ public int SearchTimeoutSeconds { get; set; } = 30;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 是否启用异步搜索
|
|
|
+ /// 默认值: true
|
|
|
+ /// 说明: 当设置为true时，搜索操作会异步执行
|
|
|
+ /// 优点:
|
|
|
+ /// 1. 不阻塞主线程
|
|
|
+ /// 2. 提高并发处理能力
|
|
|
+ /// 3. 更好的用户体验
|
|
|
+ /// 适用场景:
|
|
|
+ /// 1. 复杂搜索条件
|
|
|
+ /// 2. 大数据量搜索
|
|
|
+ /// 3. 高并发场景
|
|
|
+ /// 注意: 需要合理的线程管理和资源控制
|
|
|
+ /// </summary>
|
|
|
+ public bool EnableAsyncSearch { get; set; } = true;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 是否启用智能提示
|
|
|
+ /// 默认值: false
|
|
|
+ /// 说明: 当设置为true时，系统会根据输入提供搜索建议
|
|
|
+ /// 功能:
|
|
|
+ /// 1. 自动补全
|
|
|
+ /// 2. 热门搜索建议
|
|
|
+ /// 3. 相关搜索推荐
|
|
|
+ /// 4. 拼写纠正
|
|
|
+ /// 实现方式: 基于搜索历史、词典、算法模型
|
|
|
+ /// 适用场景: 搜索框智能提示功能
|
|
|
+ /// 注意: 需要额外的数据处理和存储
|
|
|
+ /// </summary>
|
|
|
+ public bool EnableSmartSuggestions { get; set; } = false;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 是否启用搜索结果高亮
|
|
|
+ /// 默认值: false
|
|
|
+ /// 说明: 当设置为true时，搜索结果中的匹配部分会被高亮显示
|
|
|
+ /// 高亮方式:
|
|
|
+ /// 1. HTML标记（如<em>关键词</em>）
|
|
|
+ /// 2. 特殊字符包裹
|
|
|
+ /// 3. 前端处理
|
|
|
+ /// 适用场景: 需要突出显示匹配内容的搜索
|
|
|
+ /// 注意: 会增加数据传输量和前端处理复杂度
|
|
|
+ /// </summary>
|
|
|
+ public bool EnableResultHighlighting { get; set; } = false;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 是否启用搜索结果分组
|
|
|
+ /// 默认值: false
|
|
|
+ /// 说明: 当设置为true时，搜索结果会按指定字段进行分组
|
|
|
+ /// 分组方式:
|
|
|
+ /// 1. 按类型分组
|
|
|
+ /// 2. 按时间分组
|
|
|
+ /// 3. 按相关度分组
|
|
|
+ /// 适用场景:
|
|
|
+ /// 1. 多类型混合搜索
|
|
|
+ /// 2. 时间线展示
|
|
|
+ /// 3. 分类浏览
|
|
|
+ /// 注意: 会增加查询复杂度和处理时间
|
|
|
+ /// </summary>
|
|
|
+ public bool EnableResultGrouping { get; set; } = false;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 是否启用智能拆分
|
|
|
+ /// 默认值: true
|
|
|
+ /// 说明: 当设置为true时，系统会自动将长词拆分成合理的子词组合
|
|
|
+ /// 适用场景: 搜索"重庆科学"这类组合词时，会自动尝试"重庆"+"科学"的组合
|
|
|
+ /// 工作方式:
|
|
|
+ /// 1. 检测长度为MinSplitLength及以上的词语
|
|
|
+ /// 2. 使用智能算法判断是否为可拆分组合词
|
|
|
+ /// 3. 如果可拆分，生成多层次搜索条件
|
|
|
+ /// 多层次条件示例: "重庆科学" →
|
|
|
+ /// - 完整词匹配（最高优先级）
|
|
|
+ /// - 拆分子词匹配（"重庆" AND "科学"）
|
|
|
+ /// - 单字匹配（"重" OR "庆" OR "科" OR "学"）
|
|
|
+ /// 优点:
|
|
|
+ /// 1. 提高组合词的搜索成功率
|
|
|
+ /// 2. 保持搜索结果的准确性
|
|
|
+ /// 3. 提升用户体验
|
|
|
+ /// 性能影响: 会增加搜索条件复杂度，但能显著提高召回率
|
|
|
+ /// 建议: 中文搜索场景建议启用
|
|
|
+ /// </summary>
|
|
|
+ public bool EnableSmartSplitting { get; set; } = true;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 智能拆分时是否要求所有子词都匹配
|
|
|
+ /// 默认值: false
|
|
|
+ /// 说明: 控制智能拆分时对拆分子词的匹配严格度
|
|
|
+ /// 示例:
|
|
|
+ /// - true: "重庆科学"拆分为"重庆"和"科学"，要求同时包含这两个词
|
|
|
+ /// - false: "重庆科学"拆分为"重庆"和"科学"，包含任意一个即可匹配
|
|
|
+ /// 适用场景:
|
|
|
+ /// true: 需要精确拆分匹配的场景
|
|
|
+ /// false: 需要提高召回率的场景
|
|
|
+ /// 建议: 通常设置为false以获得更好的搜索结果覆盖率
|
|
|
+ /// 注意: 此设置仅影响智能拆分的子词匹配，不影响原始词语匹配
|
|
|
+ /// </summary>
|
|
|
+ public bool RequireAllWordsForSplit { get; set; } = false;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 智能拆分时是否要求所有单字都匹配
|
|
|
+ /// 默认值: false
|
|
|
+ /// 说明: 控制智能拆分成单字时的匹配严格度
|
|
|
+ /// 示例:
|
|
|
+ /// - true: "重庆科学"拆分为单字时，要求同时包含"重"、"庆"、"科"、"学"
|
|
|
+ /// - false: "重庆科学"拆分为单字时，包含任意一个单字即可匹配
|
|
|
+ /// 适用场景:
|
|
|
+ /// true: 需要完全匹配所有单字的严格场景
|
|
|
+ /// false: 需要宽松匹配以提高召回率的场景
|
|
|
+ /// 建议: 通常设置为false，因为单字完全匹配要求较高，容易漏掉相关结果
|
|
|
+ /// 注意: 此设置仅影响智能拆分的单字匹配阶段
|
|
|
+ /// </summary>
|
|
|
+ public bool RequireAllCharsForSplit { get; set; } = false;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 最小拆分长度
|
|
|
+ /// 默认值: 4
|
|
|
+ /// 说明: 只有长度大于等于此值的词才会被考虑进行智能拆分
|
|
|
+ /// 单位: 字符数
|
|
|
+ /// 示例:
|
|
|
+ /// - 设置为4时，"重庆科学"（4字）会被考虑拆分
|
|
|
+ /// - 设置为5时，"北京长城游"（5字）会被考虑拆分
|
|
|
+ /// 适用场景:
|
|
|
+ /// - 较低值（3-4）：适用于短词较多的场景
|
|
|
+ /// - 较高值（5-6）：适用于长词较多的专业场景
|
|
|
+ /// 建议值:
|
|
|
+ /// - 中文搜索: 4
|
|
|
+ /// - 英文搜索: 8（对应4个英文单词）
|
|
|
+ /// - 混合搜索: 根据主要语言调整
|
|
|
+ /// 注意: 设置过低可能导致过多词语被拆分，影响性能；设置过高可能错过可拆分的组合词
|
|
|
+ /// </summary>
|
|
|
+ public int MinSplitLength { get; set; } = 4;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 最大拆分组合数
|
|
|
+ /// 默认值: 3
|
|
|
+ /// 说明: 限制一个词的最大拆分方式数量，防止组合爆炸
|
|
|
+ /// 示例:
|
|
|
+ /// - 设置为3时，一个6字词最多尝试3种拆分方式
|
|
|
+ /// - 设置为1时，只使用最优的拆分方式
|
|
|
+ /// 适用场景:
|
|
|
+ /// - 性能敏感场景: 1-2
|
|
|
+ /// - 平衡场景: 3
|
|
|
+ /// - 准确性优先场景: 5-10
|
|
|
+ /// 性能影响: 每增加一个拆分组合，会增加一个搜索条件分支
|
|
|
+ /// 建议:
|
|
|
+ /// - 实时搜索: 1-3
|
|
|
+ /// - 后台搜索: 3-5
|
|
|
+ /// - 复杂分析: 5-10
|
|
|
+ /// 注意: 过高的值可能导致SQL条件过于复杂，影响数据库性能
|
|
|
+ /// </summary>
|
|
|
+ public int MaxSplitCombinations { get; set; } = 3;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 搜索阶段
|
|
|
+ /// </summary>
|
|
|
+ public class SearchStage
|
|
|
+ {
|
|
|
+ public int Stage { get; set; }
|
|
|
+ public string Name { get; set; } = "";
|
|
|
+ public string Condition { get; set; } = "";
|
|
|
+ public List<SugarParameter> Parameters { get; set; } = new List<SugarParameter>();
|
|
|
+ public int Priority { get; set; }
|
|
|
+ public string Description { get; set; } = "";
|
|
|
+ public bool FallbackToNext { get; set; } = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 相关性信息（增强版）
|
|
|
+ /// </summary>
|
|
|
+ public class RelevanceInfo
|
|
|
+ {
|
|
|
+ public SearchStructure SearchStructure { get; set; }
|
|
|
+ public int ExpectedMatches { get; set; }
|
|
|
+ public List<string> BoostFields { get; set; } = new List<string>();
|
|
|
+ public List<ScoringRule> ScoringRules { get; set; } = new List<ScoringRule>();
|
|
|
+ public MatchStrategy MatchStrategy { get; set; }
|
|
|
+ public DateTime GeneratedAt { get; set; }
|
|
|
+ public bool HasSmartSplitting { get; set; }
|
|
|
+ public List<string> SplittableWords { get; set; } = new List<string>();
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 匹配策略（增强版）
|
|
|
+ /// </summary>
|
|
|
+ public class MatchStrategy
|
|
|
+ {
|
|
|
+ public string StrategyName { get; set; } = "";
|
|
|
+ public int ComplexityScore { get; set; }
|
|
|
+ public bool UseExactMatch { get; set; }
|
|
|
+ public bool UsePrefixMatch { get; set; }
|
|
|
+ public bool UseFuzzySearch { get; set; }
|
|
|
+ public bool UseCharSearch { get; set; }
|
|
|
+ public bool UseSmartSplitting { get; set; }
|
|
|
+ public int RecommendedPageSize { get; set; } = 20;
|
|
|
+ public string Description { get; set; } = "";
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 计分规则
|
|
|
+ /// </summary>
|
|
|
+ public class ScoringRule
|
|
|
+ {
|
|
|
+ public string Type { get; set; } = ""; // word, char, combo, exact, smart_split
|
|
|
+ public string Value { get; set; } = "";
|
|
|
+ public int BaseScore { get; set; }
|
|
|
+ public int Bonus { get; set; }
|
|
|
+ public double Multiplier { get; set; } = 1.0;
|
|
|
+ public string Condition { get; set; } = "";
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 搜索统计信息
|
|
|
+ /// </summary>
|
|
|
+ public class SearchStats
|
|
|
+ {
|
|
|
+ public string SearchTerm { get; set; } = "";
|
|
|
+ public CombinationType CombinationType { get; set; }
|
|
|
+ public int WordCount { get; set; }
|
|
|
+ public int CharCount { get; set; }
|
|
|
+ public int TotalSegments { get; set; }
|
|
|
+ public int ComplexityScore { get; set; }
|
|
|
+ public int ResultCount { get; set; }
|
|
|
+ public DateTime GeneratedAt { get; set; }
|
|
|
+
|
|
|
+ public double MatchRatio => TotalSegments > 0 ? (double)ResultCount / TotalSegments : 0;
|
|
|
+ public string ComplexityLevel => ComplexityScore >= 7 ? "高" :
|
|
|
+ ComplexityScore >= 4 ? "中" : "低";
|
|
|
+ }
|
|
|
+
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region 扩展方法
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// AdvancedSearchHelper 扩展方法
|
|
|
+ /// </summary>
|
|
|
+ public static class EnhancedSearchExtensions
|
|
|
+ {
|
|
|
+ /// <summary>
|
|
|
+ /// 获取组合类型的详细说明
|
|
|
+ /// </summary>
|
|
|
+ public static string GetDetail(this CombinationType type)
|
|
|
+ {
|
|
|
+ return type switch
|
|
|
+ {
|
|
|
+ CombinationType.WordsOnly => "仅使用词语进行搜索，适合精确的关键词匹配",
|
|
|
+ CombinationType.CharsOnly => "仅使用单字进行搜索，适合模糊或记忆不完整的搜索",
|
|
|
+ CombinationType.WordsAndChars => "混合使用词语和单字，提供更灵活的搜索体验",
|
|
|
+ _ => "未知的搜索类型"
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 获取搜索模式的推荐使用场景
|
|
|
+ /// </summary>
|
|
|
+ public static string GetUsageScenario(this SearchMode mode)
|
|
|
+ {
|
|
|
+ return mode switch
|
|
|
+ {
|
|
|
+ SearchMode.AutoDetect => "适用于通用搜索场景，系统自动识别最佳搜索方式",
|
|
|
+ SearchMode.SingleWord => "适用于已知确切名称或关键词的搜索",
|
|
|
+ SearchMode.MultiWord => "适用于多个相关关键词的组合搜索",
|
|
|
+ SearchMode.SingleChar => "适用于模糊搜索或拼音首字母搜索",
|
|
|
+ SearchMode.Exact => "适用于需要完全匹配的精确搜索",
|
|
|
+ SearchMode.Advanced => "适用于专业用户的高级搜索需求",
|
|
|
+ _ => "通用搜索场景"
|
|
|
+ };
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ #endregion
|
|
|
+}
|
Lyyyi