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

2025-06-15 19:57:31作者：董斯意

背景介绍

在使用 FreeSql 进行数据库操作时，我们经常会遇到需要根据前端传入的动态条件构建 SQL 查询语句的需求。FreeSql 提供了 DynamicFilterInfo 类型来表示动态查询条件，但在直接执行原生 SQL 时，无法直接使用 WhereDynamicFilter 方法。本文将介绍如何将 DynamicFilterInfo 转换为 SQL 条件语句的完整解决方案。

核心实现思路

实现动态查询条件转换为 SQL 语句的核心思路是递归解析 DynamicFilterInfo 结构，并根据不同的操作符生成对应的 SQL 条件表达式。同时需要考虑参数化查询，防止 SQL 注入。

完整实现代码

以下是完整的实现代码，包含查询条件生成、参数处理以及排序条件生成等功能：

public class QueryHelper
{
    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;
    }

    static bool isArray = false;
    static DateTime[] dates;
    static bool isDate1 = false;

    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);
}