FreeSql中动态查询条件转换为SQL的实现方案

前言

在实际开发中，我们经常需要处理动态查询条件，特别是在构建报表系统或数据查询功能时。FreeSql作为一款强大的.NET ORM框架，提供了丰富的查询功能，但在某些特定场景下，我们需要将前端传入的动态查询条件直接转换为SQL语句进行拼接。本文将详细介绍如何实现这一功能。

动态查询条件的常见形式

前端通常会以JSON格式传递查询条件，例如：

{
    "Logic": "And",
    "Filters": [
        {
            "Field": "id",
            "Operator": "Equals",
            "Value": 1
        },
        {
            "Field": "id",
            "Operator": "Equals",
            "Value": 2
        }
    ]
}

我们的目标是将这样的条件转换为SQL语句中的WHERE部分，如：WHERE id = 1 AND id = 2。

实现方案

核心思路

1. 递归解析条件树：动态查询条件通常是一个树形结构，需要递归处理
2. 操作符映射：将前端传入的操作符映射为SQL中的对应操作符
3. 参数化处理：确保生成的SQL语句是参数化的，防止SQL注入
4. 特殊条件处理：如日期范围、数组条件等特殊情况的处理

代码实现

以下是完整的实现代码，包含核心类和扩展方法：

public class QueryHelper
{
    private static bool isArray = false;
    private static DateTime[] dates;
    private static bool isDate1 = false;

    public static (string, Dictionary<string, object>, string) GenerateWhereString(DynamicFilterInfo filterInfo)
    {
        string order = "Id desc";
        var lstValues = new Dictionary<string, object>();
        int index = 0;
        var whereClause = GenerateWhereClause(filterInfo, ref index);

        filterInfo.Travel((filterInfo) => lstValues.Add(lstValues.Count.ToString(), GetValue(filterInfo)));
        return (whereClause, lstValues, order);
    }

    public static string GenerateOrder(QueryCondition queryCondition)
    {
        string order = "Id desc";
        if (queryCondition.sort.Count > 0)
        {
            order = string.Empty;
            foreach (var item in queryCondition.sort)
            {
                order += $"{item.field} {item.order},";
            }
            order = order.Trim(',');
        }
        return order;
    }

    protected static string GenerateWhereClause(DynamicFilterInfo filterInfo, ref int index)
    {
        var lstConditions = new List<string>();

        if (filterInfo.Value != null && filterInfo.Value.ToString().Trim() != string.Empty)
        {
            if (filterInfo.Value.GetType() == typeof(JArray))
            {
                isArray = true;
                dates = Newtonsoft.Json.JsonConvert.DeserializeObject<DateTime[]>(filterInfo.Value.ToString());
                isDate1 = true;
                lstConditions.Add(ConvertToCondition(filterInfo, index++));
            }
            isArray = false;
            lstConditions.Add(ConvertToCondition(filterInfo, index++));
        }
        
        if (filterInfo.Filters != null && filterInfo.Filters.Count > 0)
        {
            foreach (var subGroup in filterInfo.Filters)
            {
                if (subGroup.Value != null && subGroup.Value.ToString().Trim() != string.Empty)
                {
                    lstConditions.Add(GenerateWhereClause(subGroup, ref index));
                }
            }
        }

        return $"({lstConditions.JoinAsString(filterInfo.Logic.ToString().ToLower() == "and" ? " and " : " or ")})";
    }

    protected static string ConvertToCondition(DynamicFilterInfo condition, int index)
    {
        string left = GetLeft(condition, index);
        string right = GetRight(condition, index);
        
        switch (condition.Operator.ToString().ToLower())
        {
            case "equals": case "equal": case "eq": case "=": case "==":
                return $"{left} = {right}";
            case "<>": case "!=": case "notequal":
                return $"{left} <> {right}";
            case "greater": case "greaterthan": case ">":
                return $"{left} > {right}";
            case "greaterorequal": case "greaterthanorequal": case ">=":
                return $"{left} >= {right}";
            case "less": case "lessthan": case "<":
                return $"{left} < {right}";
            case "lessorequal": case "lessthanorequal": case "<=":
                return $"{left} <= {right}";
            case "startwith":
                return $"{left} like {right}";
            case "notstartwith":
                return $"{left} not like {right}";
            case "endwith":
                return $"{left} like {right}";
            case "notendwith":
                return $"{left} not like {right}";
            case "contain": case "contains": case "like":
                return $"{left} like {right}";
            case "notcontains":
                return $"{left} not like {right}";
            case "range":
                return $"{left} in({right})";
            case "daterange":
                if (isArray) return $"{left} >={right}";
                else return $"{left} <={right}";
            case "in": case "any":
                return $"{left} in({right})";
            case "notany": case "notcontain":
                return $"{left} not in({right})";
            default:
                throw new InvalidOperationException($"Unknown dynamic query operator: {condition.Operator}");
        }
    }

    protected static object GetValue(DynamicFilterInfo condition)
    {
        switch (condition.Operator.ToString().ToLower())
        {
            case "startwith": case "notstartwith":
                return $"{condition.Value}%";
            case "endwith": case "notendwith":
                return $"%{condition.Value}";
            case "contain": case "contains": case "like": case "notcontains":
                return $"%{condition.Value}%";
            case "daterange":
                if (isDate1)
                {
                    isDate1 = false;
                    return dates[0];
                }
                else return dates[1];
            default:
                return condition.Value;
        }
    }

    protected static string GetLeft(DynamicFilterInfo condition, int index)
    {
        return condition.Field;
    }

    protected static string GetRight(DynamicFilterInfo condition, int index)
    {
        return $"@{index}";
    }
}

public static class FilterExtensions
{
    public static void Travel(this DynamicFilterInfo dynamicFilterInfo, Action<DynamicFilterInfo> conditionAction)
    {
        if (dynamicFilterInfo.Value != null && dynamicFilterInfo.Value.ToString().Trim() != string.Empty)
        {
            if (dynamicFilterInfo.Value.GetType() == typeof(JArray))
            {
                conditionAction(dynamicFilterInfo);
            }
            conditionAction(dynamicFilterInfo);
        }
        if (dynamicFilterInfo.Filters != null && dynamicFilterInfo.Filters.Count > 0)
        {
            foreach (var subGroup in dynamicFilterInfo.Filters)
            {
                Travel(subGroup, conditionAction);
            }
        }
    }

    public static string JoinAsString<T>(this IEnumerable<T> source, string separator)
    {
        return string.Join(separator, source);
    }
}

使用示例

var (predicate, args, order) = QueryHelper.GenerateWhereString(search.FilterInfo);
var sql = "select * from table"; // 你的SQL

if (args.Count > 0)
{
    if (sql.IndexOf("where", StringComparison.OrdinalIgnoreCase) > 0)
    {
        sql = sql + predicate;
    }
    else
    {
        sql = $"{sql} where {predicate}";
    }
    
    DbParameter[] cmdParms = _reportRepository.FreeSql.Ado.GetDbParamtersByObject(args);
    var cmdType = System.Data.CommandType.Text;
    var dynamics = _reportRepository.FreeSql.Ado.Query<dynamic>(cmdType, sql, cmdParms);
}

实现细节解析

1. 递归处理条件树：GenerateWhereClause方法递归处理条件树，支持多层嵌套的条件组合

2. 操作符映射：ConvertToCondition方法将前端传入的操作符映射为SQL操作符，支持常见的比较、包含、范围等操作

3. 参数化处理：使用@index形式的参数占位符，并通过字典收集参数值，确保SQL安全

4. 特殊条件处理：

   • 日期范围：特殊处理daterange操作符，支持开始和结束日期的区分
   • 数组条件：处理JArray类型的值，支持IN操作
   • 模糊查询：自动为like操作添加%通配符

5. 扩展方法：Travel扩展方法提供遍历条件树的便捷方式

注意事项

1. SQL注入防护：虽然使用了参数化查询，但仍需确保字段名是可信的

2. 性能考虑：对于复杂条件树，递归深度可能影响性能

3. 数据库兼容性：不同数据库的SQL语法可能有差异，需要根据实际使用的数据库调整

4. 空值处理：需要特别注意null值的处理逻辑

总结

本文介绍了在FreeSql中将动态查询条件转换为SQL语句的完整方案。通过递归解析条件树、操作符映射和参数化处理，我们实现了安全、灵活的动态查询功能。这种方案特别适合需要高度自定义查询条件的场景，如报表系统、数据分析等应用。

在实际项目中，可以根据具体需求对代码进行调整和扩展，例如添加更多操作符支持、优化性能或增强错误处理等。