/// <summary>
/// 分析Lambda表达式
/// </summary>
/// <typeparam name="T">方法类型</typeparam>
/// <param name="predicate">Lambda表达式</param>
/// <returns>结果条件对象(SQL条件和参数)</returns>
public ConditionItem Convert <T>(Expression <T> predicate)
{
if (_condition == null)
{
_condition = new ConditionItem();
}
var old = _condition.ConditionSql;
var sql = ConvertExpression(predicate.Body);
var news = CheckSingle(sql);
if (string.IsNullOrEmpty(old))
{
_condition.ConditionSql = news;
}
else if (!string.IsNullOrEmpty(news))
{
_condition.ConditionSql = $"({old}) {(_mergeByAnd ? "AND" : "OR")} ({news})";
}
return(_condition);
}
/// <summary>
/// 生成更新的SQL语句
/// </summary>
/// <param name="expression">字段更新语句</param>
/// <param name="convert">更新条件</param>
/// <returns>更新的SQL语句</returns>
private string CreateUpdateSql(string expression, ConditionItem convert)
{
return(CreateUpdateSql(expression, convert.ConditionSql));
}
/// <summary>
/// 生成删除的SQL语句
/// </summary>
/// <param name="convert">删除条件</param>
/// <returns>删除的SQL语句</returns>
private string CreateDeleteSql(ConditionItem convert)
{
return(CreateDeleteSql(convert.ConditionSql));
}
/// <summary>
/// 生成载入值的SQL
/// </summary>
/// <param name="field">字段</param>
/// <param name="convert">条件</param>
/// <returns>载入字段值的SQL语句</returns>
private string CreateLoadValuesSql(string field, ConditionItem convert)
{
return($@"SELECT `{FieldDictionary[field]}`
FROM {ContextReadTable}{ContitionSqlCode(convert.ConditionSql)};");
}
/// <summary>
/// 分析Lambda表达式
/// </summary>
/// <typeparam name="T">方法类型</typeparam>
/// <param name="map">关联字段</param>
/// <param name="filter">Lambda表达式</param>
/// <param name="condition">之前已解析的条件,可为空</param>
/// <param name="mergeByAnd">与前面的条件(condition中已存在的)是用与还是或组合</param>
/// <returns>结果条件对象(SQL条件和参数)</returns>
public static ConditionItem Convert <T>(Dictionary <string, string> map, LambdaItem <T> filter, ConditionItem condition, bool mergeByAnd)
{
var root = new PredicateConvert(map)
{
_condition = condition,
_mergeByAnd = mergeByAnd
};
if (filter.Root != null)
{
root.Convert(filter.Root);
}
foreach (var ch in filter.Roots)
{
Convert(map, ch, condition, true);
}
ConditionItem item = new ConditionItem
{
ParaIndex = root._condition.ParaIndex
};
foreach (var ch in filter.Ands)
{
Convert(map, ch, item, true);
}
foreach (var ch in filter.Ors)
{
Convert(map, ch, item, false);
}
root._condition.ParaIndex = item.ParaIndex;
root._condition.AddAndCondition(item.ConditionSql, item.Parameters);
return(root._condition);
}
/// <summary>
/// 分析Lambda表达式
/// </summary>
/// <typeparam name="T">方法类型</typeparam>
/// <param name="columns">关联字段</param>
/// <param name="predicate">Lambda表达式</param>
/// <param name="condition">之前已解析的条件,可为空</param>
/// <param name="mergeByAnd">与前面的条件(condition中已存在的)是用与还是或组合</param>
/// <returns>结果条件对象(SQL条件和参数)</returns>
public static ConditionItem Convert2 <T>(string[] columns, Expression <Func <T, bool> > predicate, ConditionItem condition = null, bool mergeByAnd = true)
{
var convert = new PredicateConvert(columns.ToDictionary(p => p, p => p))
{
_condition = condition,
_mergeByAnd = mergeByAnd
};
return(convert.Convert(predicate));
}
/// <summary>
/// 分析Lambda表达式
/// </summary>
/// <typeparam name="T">方法类型</typeparam>
/// <param name="map">关联字段</param>
/// <param name="predicate">Lambda表达式</param>
/// <param name="condition">之前已解析的条件,可为空</param>
/// <param name="mergeByAnd">与前面的条件(condition中已存在的)是用与还是或组合</param>
/// <returns>结果条件对象(SQL条件和参数)</returns>
public static void Convert <T>(Dictionary <string, string> map, Expression <T> predicate, ConditionItem condition, bool mergeByAnd = true)
{
var convert = new PredicateConvert(map)
{
_condition = condition,
_mergeByAnd = mergeByAnd
};
convert.Convert(predicate);
}
