//public SqlProvider<T> FormatToList(LambdaExpression[] selector)
//{
// var selectSql = ResolveExpression.Instance(Dialect).ResolveSelect(typeof(T), Context.QuerySet.TopNum, false, selector);
// var fromTableSql = FormatTableName();
// var whereParams = ResolveExpression.Instance(Dialect).ResolveWhere(Context.QuerySet.WhereExpression);
// var whereSql = whereParams.SqlCmd;
// Params = whereParams.Param;
// var orderbySql = ResolveExpression.Instance(Dialect).ResolveOrderBy(Context.QuerySet.OrderbyExpressionList);
// var limitSql = ResolveExpression.Instance(Dialect).ResolveLimit(Context.QuerySet.TopNum);
// SqlString = $"{selectSql} {fromTableSql} {whereSql} {orderbySql} {limitSql}";
// return this;
//}
public SqlProvider <T> FormatToListZhanglei(Type type, IFieldAnyExpression fieldAnyExpression = null)
{
var selectSql = ResolveExpression.Instance(Dialect).ResolveSelect(type, Context.QuerySet.TopNum, Context.QuerySet.IsDistinct, Context.QuerySet.SelectExpression);
var fromTableSql = FormatTableName();
var whereParams = ResolveExpression.Instance(Dialect).ResolveWhere(Context.QuerySet.WhereExpression);
var whereSql = whereParams.SqlCmd;
Params = whereParams.Param;
var orderbySql = ResolveExpression.Instance(Dialect).ResolveOrderBy(Context.QuerySet.OrderbyExpressionList);
var limitSql = ResolveExpression.Instance(Dialect).ResolveLimit(Context.QuerySet.TopNum);
if (fieldAnyExpression != null)
{
var selectDistinctSql = ResolveExpression.Instance(Dialect).ResolveSelect(type, Context.QuerySet.TopNum, true, Context.QuerySet.SelectExpression);
var di = fieldAnyExpression.WhereParam.ToDictionary();
foreach (var i in di)
{
Params.Add(i.Key, i.Value);
}
SqlString = $"{selectDistinctSql} from ({selectSql} ,jsonb_array_elements({fieldAnyExpression.ListFieldName}) as \"{ResolveExpression.FieldAnyColumnName}\" {fromTableSql} {whereSql} {orderbySql}) as {ResolveExpression.FieldAnyTableName} where {fieldAnyExpression.WhereClause} {limitSql}";
}
else
{
SqlString = $"{selectSql} {fromTableSql} {whereSql} {orderbySql} {limitSql}";
}
return(this);
}
public override Tuple <string, IDbDataParameter[]> GenerateTopCountSqlText(int topCount, Expression <Func <T, bool> > filterExpression, Expression <Func <IQueryable <T>, IQueryable <T> > > orderByExpression)
{
ResolveExpression resolve = ResolveToSql(filterExpression);
StringBuilder strSql = new StringBuilder();
string tableName = GetTableName();
strSql.AppendFormat("Select * from {0}", tableName);
strSql.AppendFormat(" Where {0}", resolve.SqlWhere);
if (orderByExpression != null)
{
var orderby = AiExpressionWriterSql.BizWhereWriteToString(orderByExpression, AiExpSqlType.aiOrder);
strSql.AppendFormat(" Order by {0} LIMIT {1},{2};", orderby, 0, topCount);
}
else
{
strSql.AppendFormat(" LIMIT {0},{1};", 0, topCount);
}
var sqlText = strSql.ToString();
return(new Tuple <string, IDbDataParameter[]>(sqlText, resolve.Paras));
}
public SqlProvider <T> FormatToPageList(int pageIndex, int pageSize)
{
var orderbySql = ResolveExpression.ResolveOrderBy(Context.QuerySet.OrderbyExpressionList);
if (string.IsNullOrEmpty(orderbySql))
{
throw new Exception("分页查询需要排序条件");
}
var selectSql = ResolveExpression.ResolveSelect(typeof(T).GetProperties(), Context.QuerySet.SelectExpression, pageSize);
var fromTableSql = FormatTableName();
var whereParams = ResolveExpression.ResolveWhere(Context.QuerySet.WhereExpression);
var whereSql = whereParams.SqlCmd;
Params = whereParams.Param;
SqlString = $"SELECT COUNT(1) {fromTableSql} {whereSql};";
SqlString += $@"{selectSql}
FROM ( SELECT *
,ROW_NUMBER() OVER ( {orderbySql} ) AS ROWNUMBER
{fromTableSql}
{whereSql}
) T
WHERE ROWNUMBER > {(pageIndex - 1) * pageSize}
AND ROWNUMBER <= {pageIndex * pageSize} {orderbySql};";
return(this);
}
private SqlProvider <T> FormatGetDo(IWhereExpression whereParams, IFieldAnyExpression fieldAnyExpression)
{
var selectSql = ResolveExpression.Instance(Dialect).ResolveSelect(typeof(T).GetPropertiesInDb(true), Context.QuerySet.SelectExpression, 1, Context.QuerySet.IsDistinct);
var fromTableSql = FormatTableName();
var whereSql = whereParams.SqlCmd;
Params = whereParams.Param;
var orderbySql = ResolveExpression.Instance(Dialect).ResolveOrderBy(Context.QuerySet.OrderbyExpressionList);
var limitSql = ResolveExpression.Instance(Dialect).ResolveLimit(1);
if (fieldAnyExpression != null)
{
string selectDistinctSql = ResolveExpression.Instance(Dialect).ResolveSelect(typeof(T).GetPropertiesInDb(true), Context.QuerySet.SelectExpression, 1, true);
var di = fieldAnyExpression.WhereParam.ToDictionary();
foreach (var i in di)
{
Params.Add(i.Key, i.Value);
}
SqlString = $"{selectDistinctSql} from ({selectSql} ,jsonb_array_elements({fieldAnyExpression.ListFieldName}) as \"{ResolveExpression.FieldAnyColumnName}\" {fromTableSql} {whereSql} {orderbySql}) as {ResolveExpression.FieldAnyTableName} where {fieldAnyExpression.WhereClause} {limitSql}";
}
else
{
SqlString = $"{selectSql} {fromTableSql} {whereSql} {orderbySql} {limitSql}";
}
return(this);
}
public SqlProvider <T> FormatUpdateZhanglei <TKey>(Expression <Func <T, TKey> > expression, TKey value)
{
MemberExpression m = expression.Body as MemberExpression;
if (m == null)
{
var mbs = new ExpressionPropertyFinder(expression, typeof(T)).MemberList;
if (!mbs.Any())
{
throw new FieldAccessException($"未在更新表达式中找到类型 {typeof(T).Name} 的任何字段");
}
}
var update = ResolveExpression.Instance(Dialect).ResolveUpdateZhanglei <T>(expression, value);
var where = ResolveExpression.Instance(Dialect).ResolveWhere(Context.CommandSet.WhereExpression);
var whereSql = where.SqlCmd;
Params = where.Param;
Params.AddDynamicParams(update.Param);
SqlString = $"UPDATE {FormatTableName(false)} {update.SqlCmd} {whereSql}";
return(this);
}
/// <summary>
/// 生成获取列表sql
/// </summary>
public virtual Tuple <string, IDbDataParameter[]> GenerateGetListSqlText <TModel>(
Expression <Func <T, bool> > filterExpression = null,
Expression <Func <IQueryable <T>, IQueryable <T> > > orderByExpression = null,
Expression <Func <T, TModel> > selectExpression = null) where TModel : BaseEntity
{
StringBuilder strSql = new StringBuilder();
string tableName = GetTableName();
string selectField = selectExpression == null ? "*" : ResolveSelectExpress(selectExpression);
strSql.AppendFormat("Select {1} from {0}", tableName, selectField);
IDbDataParameter[] dbParams = null;
if (filterExpression != null)
{
ResolveExpression resolve = ResolveToSql(filterExpression);
strSql.AppendFormat(" Where {0}", resolve.SqlWhere);
dbParams = resolve.Paras;
}
if (orderByExpression != null)
{
var orderby = ExpressionResolve.Base.AiExpressionWriterSql.BizWhereWriteToString(orderByExpression, AiExpSqlType.aiOrder);
strSql.AppendFormat(" Order by {0};", orderby);
}
var sqlText = strSql.ToString();
return(new Tuple <string, IDbDataParameter[]>(sqlText, dbParams));
}
protected internal ResolveExpression ResolveToSql(Expression <Func <T, bool> > filterExpression)
{
ResolveExpression resolve = new ResolveExpression();
resolve.ResolveToWhere(filterExpression);
return(resolve);
}
public SqlProvider <T> FormatToPageList(Type type, int pageIndex, int pageSize, IFieldAnyExpression fieldAnyExpression)
{
var orderbySql = ResolveExpression.Instance(Dialect).ResolveOrderBy(Context.QuerySet.OrderbyExpressionList);
if (string.IsNullOrEmpty(orderbySql))
{
throw new Exception("分页查询需要排序条件");
}
var selectSql = ResolveExpression.Instance(Dialect).ResolveSelect(type, pageSize, false, Context.QuerySet.SelectExpression);
var fromTableSql = FormatTableName();
var whereParams = ResolveExpression.Instance(Dialect).ResolveWhere(Context.QuerySet.WhereExpression);
var whereSql = whereParams.SqlCmd;
Params = whereParams.Param;
var limitSql = ResolveExpression.Instance(Dialect).ResolveLimit(pageSize);
if (fieldAnyExpression != null)
{
var selectDistinctSql = ResolveExpression.Instance(Dialect).ResolveSelect(type, pageSize, true, Context.QuerySet.SelectExpression);
var di = fieldAnyExpression.WhereParam.ToDictionary();
foreach (var i in di)
{
Params.Add(i.Key, i.Value);
}
string newTable = $"({selectSql} ,jsonb_array_elements({fieldAnyExpression.ListFieldName}) as \"{ResolveExpression.FieldAnyColumnName}\" {fromTableSql} {whereSql} {orderbySql}) as {ResolveExpression.FieldAnyTableName}";
string newNewTable = $"{selectDistinctSql} from {newTable} where {fieldAnyExpression.WhereClause} {limitSql}";
SqlString = $"SELECT COUNT(1) from ({newNewTable}) as {ResolveExpression.FieldAnyTableName};";
SqlString += $@"{selectDistinctSql}
FROM ( SELECT *
,ROW_NUMBER() OVER ( {orderbySql} ) AS ROWNUMBER
from {newTable} where {fieldAnyExpression.WhereClause}
) T
WHERE ROWNUMBER > {(pageIndex - 1) * pageSize}
AND ROWNUMBER <= {pageIndex * pageSize} {orderbySql} {limitSql};";
}
else
{
SqlString = $"SELECT COUNT(1) {fromTableSql} {whereSql};";
SqlString += $@"{selectSql}
FROM ( SELECT *
,ROW_NUMBER() OVER ( {orderbySql} ) AS ROWNUMBER
{fromTableSql}
{whereSql}
) T
WHERE ROWNUMBER > {(pageIndex - 1) * pageSize}
AND ROWNUMBER <= {pageIndex * pageSize} {orderbySql} {limitSql};";
}
return(this);
}
public SqlProvider <T> FormatInsert(T entity)
{
var paramsAndValuesSql = FormatInsertParamsAndValues(entity);
var ifnotexistsWhere = ResolveExpression.ResolveWhere(Context.CommandSet.IfNotExistsExpression, "INE_");
Params.AddDynamicParams(ifnotexistsWhere.Param);
SqlString = Context.CommandSet.IfNotExistsExpression != null ? $"IF NOT EXISTS ( SELECT 1 FROM {FormatTableName(false)} {ifnotexistsWhere.SqlCmd} ) INSERT INTO {FormatTableName(false)} {paramsAndValuesSql}" : $"INSERT INTO {FormatTableName(false)} {paramsAndValuesSql}";
return(this);
}
public SqlProvider <T> FormatDelete <TKey>(TKey id)
{
var fromTableSql = FormatTableName();
var where = ResolveExpression.Instance(Dialect).ResolveWhere <T, TKey>(id);
var whereSql = where.SqlCmd;
Params = where.Param;
SqlString = $"DELETE {fromTableSql} {whereSql}";
return(this);
}
public SqlProvider <T> FormatDelete()
{
var fromTableSql = FormatTableName();
var whereParams = ResolveExpression.Instance(Dialect).ResolveWhere(Context.CommandSet.WhereExpression);
var whereSql = whereParams.SqlCmd;
Params = whereParams.Param;
SqlString = $"DELETE {fromTableSql} {whereSql }";
return(this);
}
public SqlProvider <T> FormatUpdateNotDefault(T entity)
{
var update = ResolveExpression.Instance(Dialect).ResolveUpdateNotDefault <T>(a => entity);
var where = ResolveExpression.Instance(Dialect).ResolveWhere(entity);
var whereSql = where.SqlCmd;
Params = where.Param;
Params = Params.Union(update.Param).ToDictionary(x => x.Key, x => x.Value);
SqlString = $"UPDATE {FormatTableName(false)} {update.SqlCmd} {whereSql}";
return(this);
}
public SqlProvider <T> FormatUpdate(Expression <Func <T, T> > updateExpression)
{
var update = ResolveExpression.Instance(Dialect).ResolveUpdate(updateExpression);
var where = ResolveExpression.Instance(Dialect).ResolveWhere(Context.CommandSet.WhereExpression);
var whereSql = where.SqlCmd;
Params = where.Param;
Params.AddDynamicParams(update.Param);
SqlString = $"UPDATE {FormatTableName(false)} {update.SqlCmd} {whereSql}";
return(this);
}
public SqlProvider <T> FormatUpdateNotDefault(T entity)
{
var update = ResolveExpression.Instance(Dialect).ResolveUpdateNotDefault <T>(a => entity);
var where = ResolveExpression.Instance(Dialect).ResolveWhere(entity);
var whereSql = where.SqlCmd;
Params = where.Param;
Params.AddDynamicParams(update.Param);
SqlString = $"UPDATE {FormatTableName(false)} {update.SqlCmd} {whereSql}";
return(this);
}
/// <summary>
/// 生成统计记录数的sql文本和参数
/// </summary>
public virtual Tuple <string, IDbDataParameter[]> GenerateCountSqlTextAndParam(Expression <Func <T, bool> > filterExpression)
{
var strSql = new StringBuilder();
string tableName = _entityAnaly.GetTableName <T>();
strSql.AppendFormat("Select Count(1) as CountRecord From {0} ", tableName);
ResolveExpression resolve = ResolveToSql(filterExpression);
strSql.AppendFormat(" Where {0};", resolve.SqlWhere);
var sqlText = strSql.ToString();
return(new Tuple <string, IDbDataParameter[]>(sqlText, resolve.Paras));
}
/// <summary>
/// 生成删除的sql文本和参数
/// </summary>
public virtual Tuple <string, IDbDataParameter[]> GenerateDeleteSqlTextAndParam(Expression <Func <T, bool> > filterExpression)
{
ResolveExpression resolve = ResolveToSql(filterExpression);
StringBuilder strSql = new StringBuilder();
string tableName = GetTableName();
strSql.AppendFormat("Delete from {0}", tableName);
strSql.AppendFormat(" Where {0};", resolve.SqlWhere);
var sqlText = strSql.ToString();
return(new Tuple <string, IDbDataParameter[]>(sqlText, resolve.Paras));
}
public SqlProvider <T> FormatExists()
{
var selectSql = "SELECT TOP 1 1";
var fromTableSql = FormatTableName();
var whereParams = ResolveExpression.ResolveWhere(Context.QuerySet.WhereExpression);
var whereSql = whereParams.SqlCmd;
Params = whereParams.Param;
SqlString = $"{selectSql} {fromTableSql} {whereSql}";
return(this);
}
public SqlProvider <T> FormatCount()
{
var selectSql = "SELECT COUNT(1)";
var fromTableSql = FormatTableName();
var whereParams = ResolveExpression.Instance(Dialect).ResolveWhere(Context.QuerySet.WhereExpression);
var whereSql = whereParams.SqlCmd;
Params = whereParams.Param;
SqlString = $"{selectSql} {fromTableSql} {whereSql} ";
return(this);
}
public SqlProvider <T> FormatSum(LambdaExpression lambdaExpression)
{
var selectSql = ResolveExpression.Instance(Dialect).ResolveSum(typeof(T).GetPropertiesInDb(true), lambdaExpression);
var fromTableSql = FormatTableName();
var whereParams = ResolveExpression.Instance(Dialect).ResolveWhere(Context.QuerySet.WhereExpression);
var whereSql = whereParams.SqlCmd;
Params = whereParams.Param;
SqlString = $"{selectSql} {fromTableSql} {whereSql} ";
return(this);
}
public SqlProvider <T> FormatToList()
{
var selectSql = ResolveExpression.ResolveSelect(typeof(T).GetProperties(), Context.QuerySet.SelectExpression, Context.QuerySet.TopNum);
var fromTableSql = FormatTableName();
var whereParams = ResolveExpression.ResolveWhere(Context.QuerySet.WhereExpression);
var whereSql = whereParams.SqlCmd;
Params = whereParams.Param;
var orderbySql = ResolveExpression.ResolveOrderBy(Context.QuerySet.OrderbyExpressionList);
SqlString = $"{selectSql} {fromTableSql} {whereSql} {orderbySql}";
return(this);
}
public SqlProvider <T> FormatExists()
{
var selectSql = Dialect.IsUseLimitInsteadOfTop ? "SELECT 1" : "SELECT TOP 1 1";
var fromTableSql = FormatTableName();
var whereParams = ResolveExpression.Instance(Dialect).ResolveWhere(Context.QuerySet.WhereExpression);
var whereSql = whereParams.SqlCmd;
Params = whereParams.Param;
var limitSql = Dialect.IsUseLimitInsteadOfTop ? " Limit 1" : string.Empty;
SqlString = $"{selectSql} {fromTableSql} {whereSql} {limitSql}";
return(this);
}
public SqlProvider <T> FormatUpdateSelect(Expression <Func <T, T> > updator)
{
var update = ResolveExpression.ResolveUpdate(updator);
var selectSql = ResolveExpression.ResolveSelectOfUpdate(typeof(T).GetProperties(), Context.QuerySet.SelectExpression);
var where = ResolveExpression.ResolveWhere(Context.QuerySet.WhereExpression);
var whereSql = where.SqlCmd;
Params = where.Param;
Params.AddDynamicParams(update.Param);
var topSql = Context.QuerySet.TopNum.HasValue ? " TOP " + Context.QuerySet.TopNum.Value : "";
SqlString = $"UPDATE {topSql} {FormatTableName(false)} WITH ( UPDLOCK, READPAST ) {update.SqlCmd} {selectSql} {whereSql}";
return(this);
}
/// <summary>
/// 添加记录
/// </summary>
/// <param name="entity"></param>
/// <param name="isHaveIdentity">代表是否含有自增标识</param>
/// <returns></returns>
public SqlProvider <T> FormatInsert(T entity, out IdentityTypeEnum isHaveIdentity, out PropertyInfo identityProperty, bool multiInsert = false)
{
//标识属性
identityProperty = typeof(T).GetPropertiesInDb(false).FirstOrDefault(x => x.CustomAttributes.Any(b => b.AttributeType == typeof(IdentityAttribute)));
SetAutoDateTime(entity);
var paramsAndValuesSql = multiInsert ? FormatInsertParamsAndValues(entity, null) : FormatInsertParamsAndValues(entity, identityProperty);
var ifnotexistsWhere = ResolveExpression.Instance(Dialect).ResolveWhere(Context.CommandSet.IfNotExistsExpression, "INE_");
Params.AddDynamicParams(ifnotexistsWhere.Param);
SqlString = Context.CommandSet.IfNotExistsExpression != null ? $"IF NOT EXISTS ( SELECT 1 FROM {FormatTableName(false)} {ifnotexistsWhere.SqlCmd} ) INSERT INTO {FormatTableName(false)} {paramsAndValuesSql}" : $"INSERT INTO {FormatTableName(false)} {paramsAndValuesSql}";
if (!multiInsert)
{
if (identityProperty != null)
{
if (identityProperty.PropertyType == typeof(Guid))
{
isHaveIdentity = IdentityTypeEnum.Guid;
//Params.Add("@id", dbType: DbType.Guid, direction: ParameterDirection.Output);
//SqlString = SqlString + ";SELECT @id=SCOPE_IDENTITY()";
}
else
{
isHaveIdentity = IdentityTypeEnum.Int;
//Params.Add("@id", dbType: DbType.Int32, direction: ParameterDirection.Output);
//SqlString = SqlString + ";SELECT @id=SCOPE_IDENTITY()";
}
}
else
{
isHaveIdentity = IdentityTypeEnum.NoIdentity;
}
}
else
{
isHaveIdentity = IdentityTypeEnum.NoIdentity;
}
return(this);
}
public SqlProvider <T> FormatUpdateSelect(Expression <Func <T, T> > updator)
{
var update = ResolveExpression.Instance(Dialect).ResolveUpdate(updator);
var selectSql = ResolveExpression.Instance(Dialect).ResolveSelectOfUpdate(typeof(T).GetPropertiesInDb(true), Context.QuerySet.SelectExpression);
var where = ResolveExpression.Instance(Dialect).ResolveWhere(Context.QuerySet.WhereExpression);
var whereSql = where.SqlCmd;
Params = where.Param;
Params = Params.Union(update.Param).ToDictionary(x => x.Key, x => x.Value);
var topSql = Context.QuerySet.TopNum.HasValue && !Dialect.IsUseLimitInsteadOfTop ? " TOP " + Context.QuerySet.TopNum.Value : "";
var limitSql = Context.QuerySet.TopNum.HasValue && Dialect.IsUseLimitInsteadOfTop ? $" Limit {Context.QuerySet.TopNum.Value}" : "";
SqlString = $"UPDATE {topSql} {FormatTableName(false)} WITH ( UPDLOCK, READPAST ) {update.SqlCmd} {selectSql} {whereSql} {limitSql}";
return(this);
}
public T Execute <T>(Expression expression)
{
//解析表达式，这里的T可能是泛型本身，也可能是集合，或者是动态值
MethodCallExpression methodCall = expression as MethodCallExpression;
Expression <Func <T, bool> > result = null;
while (methodCall != null)
{
Expression method = methodCall.Arguments[0];
Expression lambda = methodCall.Arguments[1];
LambdaExpression right = (lambda as UnaryExpression).Operand as LambdaExpression;
if (result == null)
{
result = Expression.Lambda <Func <T, bool> >(right.Body, right.Parameters);
}
else
{
Expression left = result.Body;
Expression temp = Expression.And(right.Body, left);
result = Expression.Lambda <Func <T, bool> >(temp, result.Parameters);
}
methodCall = method as MethodCallExpression;
}
var cmdText = string.Format("SELECT * FROM {0}", typeof(T).Name);
if (result != null)
{
var resolve = new ResolveExpression(_repository.DataSource);
resolve.ResolveToSql(result);
cmdText = string.Format("{0} WHERE {1}", cmdText, resolve.SqlWhere);
//Command.Parameters.AddRange(resolve.Paras);
//_repository.GetEntity<T>(cmdText,resolve.Paras);
}
//_resolveExpression.ResolveToSql(result);
//var source = new DBSql().FindAs<T>(result);
//var t = _repository.GetEntity<T>(result);
return(default);
/// <summary>
/// 生成Update语句的sql文本和参数信息
/// </summary>
public virtual Tuple <string, IDbDataParameter[]> GenerateUpdateSqlTextAndParam(Expression <Func <T, T> > updateExpression, Expression <Func <T, bool> > filterExpression)
{
StringBuilder strSql = new StringBuilder();
List <IDbDataParameter> sqlParams;
string tableName = GetTableName();
string updateField = ResolveUpdateExpress(updateExpression, out sqlParams);
strSql.AppendFormat("Update {0} Set {1}", tableName, updateField);
ResolveExpression resolve = ResolveToSql(filterExpression);
strSql.AppendFormat(" Where {0}", resolve.SqlWhere);
sqlParams.AddRange(resolve.Paras.ToList());
var sqlText = strSql.ToString();
return(new Tuple <string, IDbDataParameter[]>(sqlText, sqlParams.ToArray()));
}
public SqlProvider <T> FormatUpdateZhanglei <TKey>(Expression <Func <T, TKey> > expression, TKey value)
{
MemberExpression m = expression.Body as MemberExpression;
if (m == null)
{
throw new FieldAccessException("Field Not Found");
}
var update = ResolveExpression.Instance(Dialect).ResolveUpdateZhanglei <T>(expression, value);
var where = ResolveExpression.Instance(Dialect).ResolveWhere(Context.CommandSet.WhereExpression);
var whereSql = where.SqlCmd;
Params = where.Param;
Params.AddDynamicParams(update.Param);
SqlString = $"UPDATE {FormatTableName(false)} {update.SqlCmd} {whereSql}";
return(this);
}
public SqlProvider <T> FormatUpdateZhanglei(T entity, IEnumerable <LambdaExpression> expressionList)
{
var update = ResolveExpression.Instance(Dialect).ResolveUpdateZhanglei <T>(expressionList, entity);
IWhereExpression where;
if (Context.CommandSet.WhereExpression == null)
{
where = ResolveExpression.Instance(Dialect).ResolveWhere(entity);
}
else
{
where = ResolveExpression.Instance(Dialect).ResolveWhere(Context.CommandSet.WhereExpression);
}
var whereSql = where.SqlCmd;
Params = where.Param;
Params.AddDynamicParams(update.Param);
SqlString = $"UPDATE {FormatTableName(false)} {update.SqlCmd} {whereSql}";
return(this);
}
public SqlProvider <T> FormatGet <TKey>(TKey id, IFieldAnyExpression fieldAnyExpression)
{
var whereParams = ResolveExpression.Instance(Dialect).ResolveWhere <T, TKey>(id);
return(FormatGetDo(whereParams, fieldAnyExpression));
}
public SqlProvider <T> FormatGet(IFieldAnyExpression fieldAnyExpression)
{
var whereParams = ResolveExpression.Instance(Dialect).ResolveWhere(Context.QuerySet.WhereExpression);
return(FormatGetDo(whereParams, fieldAnyExpression));
}
