lsm/SqlSugar
1
0
Fork 0
mirror of https://gitee.com/dotnetchina/SqlSugar.git synced 2025-09-19 01:58:13 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update core

Browse Source
This commit is contained in:
sunkaixuna
2021-07-04 14:12:19 +08:00
parent d4a7e97b82
commit 9643b7eee5
14 changed files with 470 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs
View File

@@ -330,12 +330,20 @@ namespace SqlSugar
WhereType = WhereType.Or;
}
}
cons.ConditionalList.Add(new KeyValuePair<WhereType, ConditionalModel>(WhereType, new ConditionalModel()
var data = new KeyValuePair<WhereType, ConditionalModel>(WhereType, new ConditionalModel()
{
ConditionalType = ConditionalType.Equal,
FieldName = this.QueryBuilder.Builder.GetTranslationColumnName(column.DbColumnName),
FieldValue = value.ObjToString()
}));
});
if (this.Context.CurrentConnectionConfig.DbType == DbType.PostgreSQL)
{
data.Value.FieldValueConvertFunc = it =>
{
return UtilMethods.ChangeType2(it, value.GetType());
};
}
cons.ConditionalList.Add(data);
}
if (cons.HasValue())
{
@@ -782,6 +790,10 @@ namespace SqlSugar
result.QueryBuilder.WhereIndex = index;
result.QueryBuilder.LambdaExpressions.ParameterIndex = QueryBuilder.LambdaExpressions.ParameterIndex++;
result.QueryBuilder.LambdaExpressions.Index = QueryBuilder.LambdaExpressions.Index++;
if (this.Context.CurrentConnectionConfig.DbType == DbType.Oracle)
{
result.Select("MergeTable.*");
}
return result;
}
@@ -868,6 +880,15 @@ namespace SqlSugar
else
return null;
}
public async virtual Task<T[]> ToArrayAsync()
{
var result =await this.ToListAsync();
if (result.HasValue())
return result.ToArray();
else
return null;
}
public virtual string ToJson()
{
if (IsCache)
@@ -1061,6 +1082,56 @@ namespace SqlSugar
InitMapping();
return _ToList<T>();
}
public List<T> ToOffsetPage(int pageIndex, int pageSize)
{
if (this.Context.CurrentConnectionConfig.DbType != DbType.SqlServer)
{
return this.ToPageList(pageIndex, pageSize);
}
else
{
_ToOffsetPage(pageIndex, pageSize);
return this.ToList();
}
}
public List<T> ToOffsetPage(int pageIndex, int pageSize, ref int totalNumber)
{
if (this.Context.CurrentConnectionConfig.DbType != DbType.SqlServer)
{
return this.ToPageList(pageIndex, pageSize, ref totalNumber);
}
else
{
totalNumber = this.Clone().Count();
_ToOffsetPage(pageIndex, pageSize);
return this.Clone().ToList();
}
}
public Task<List<T>> ToOffsetPageAsync(int pageIndex, int pageSize)
{
if (this.Context.CurrentConnectionConfig.DbType != DbType.SqlServer)
{
return this.ToPageListAsync(pageIndex, pageSize);
}
else
{
_ToOffsetPage(pageIndex, pageSize);
return this.ToListAsync();
}
}
public async Task<List<T>> ToOffsetPageAsync(int pageIndex, int pageSize, RefAsync<int> totalNumber)
{
if (this.Context.CurrentConnectionConfig.DbType != DbType.SqlServer)
{
return await this.ToPageListAsync(pageIndex, pageSize, totalNumber);
}
else
{
totalNumber.Value =await this.Clone().CountAsync();
_ToOffsetPage(pageIndex, pageSize);
return await this.Clone().ToListAsync();
}
}
public virtual List<T> ToPageList(int pageIndex, int pageSize)
{
pageIndex = _PageList(pageIndex, pageSize);
@@ -1487,6 +1558,11 @@ namespace SqlSugar
return this;
}
}
private void _ToOffsetPage(int pageIndex, int pageSize)
{
QueryBuilder.Offset = $" OFFSET {(pageIndex - 1) * pageSize} ROWS FETCH NEXT {pageSize} ROWS ONLY";
}
private int _PageList(int pageIndex, int pageSize)
{
if (pageIndex == 0)
@@ -2267,6 +2343,7 @@ namespace SqlSugar
asyncQueryableBuilder.IgnoreColumns = this.QueryBuilder.IgnoreColumns;
asyncQueryableBuilder.AsTables = this.QueryBuilder.AsTables;
asyncQueryableBuilder.DisableTop = this.QueryBuilder.DisableTop;
asyncQueryableBuilder.Offset = this.QueryBuilder.Offset;
}
protected int SetCacheTime(int cacheDurationInSeconds)
{

224
Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/Reportable/ReportableProvider.cs Normal file
View File

@@ -0,0 +1,224 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
namespace SqlSugar
{
public class ReportableProvider<T> : IReportable<T>
{
public SqlSugarProvider Context { get; set; }
private List<T> datas = new List<T>();
private List<DateTime> dates = new List<DateTime>();
private bool isDates = false;
internal QueryBuilder queryBuilder;
internal InsertBuilder formatBuilder { get; set; }
public ReportableProvider(T data)
{
datas.Add(data);
Init();
}
public ReportableProvider(List<T> list)
{
datas = list;
Init();
}
//public IReportable<T> MakeUp(Func<T, object> auto)
//{
// throw new NotImplementedException();
//}
public ISugarQueryable<T> ToQueryable()
{
StringBuilder sb = new StringBuilder();
if (datas.Any())
{
if (isDates)
{
var da = this.dates;
Each(sb, da);
}
else
{
var da = this.datas;
Each(sb, da);
}
}
else
{
if (typeof(T).IsClass())
{
var result = (T)Activator.CreateInstance(typeof(T), true);
datas.Add(result);
ClassMethod(result, sb, true);
}
else
{
sb.Append("SELECT NULL as ColumnName ");
sb.Append(GetNextSql);
}
}
return this.Context.SqlQueryable<object>(sb.ToString()).Select<T>();
}
public ISugarQueryable<SingleColumnEntity<Y>> ToQueryable<Y>()
{
return ToQueryable().Select<SingleColumnEntity<Y>>();
}
private void Each<Y>(StringBuilder sb, List<Y> list)
{
foreach (var item in list)
{
var isLast = list.IndexOf(item) == list.Count - 1;
var isClass = typeof(T).IsClass();
if (isClass)
{
ClassMethod(item, sb, isLast);
}
else
{
NoClassMethod(item, sb, isLast);
}
}
}
private void ClassMethod<Y>(Y data, StringBuilder sb,bool isLast)
{
var columns = new StringBuilder();
var entity=this.Context.EntityMaintenance.GetEntityInfo<T>();
columns.Append(string.Join(",",entity.Columns.Where(it=>it.IsIgnore==false).Select(it=>GetSelect(it,data))));
columns.Append(",null as NoCacheColumn");
sb.AppendLine(" SELECT " + columns.ToString());
sb.Append(GetNextSql);
if (!isLast)
{
sb.AppendLine(" UNION ALL ");
}
}
private object GetSelect<Y>(EntityColumnInfo it,Y data)
{
return string.Format(" {0} AS {1} ", FormatValue(it.PropertyInfo.GetValue(data,null)),it.PropertyName);
}
private void NoClassMethod<Y>(Y data, StringBuilder sb,bool isLast)
{
sb.AppendLine(" SELECT "+ FormatValue(data));
sb.Append(" AS ColumnName ");
sb.Append(GetNextSql);
if (!isLast)
{
sb.AppendLine(" UNION ALL ");
}
}
public string GetNextSql
{
get
{
if (this.Context.CurrentConnectionConfig.DbType == DbType.Oracle)
{
return " from dual ";
}
else
{
return null;
}
}
}
private void Init()
{
if (datas.Count == 1)
{
isDates = true;
var data=datas.First();
if (data is ReportableDateType)
{
var type = UtilMethods.ChangeType2(data, typeof(ReportableDateType));
switch (type)
{
case ReportableDateType.MonthsInLast1years:
dates.AddRange(GetMonths(1));
break;
case ReportableDateType.MonthsInLast3years:
dates.AddRange(GetMonths(3));
break;
case ReportableDateType.MonthsInLast10years:
dates.AddRange(GetMonths(10));
break;
case ReportableDateType.years1:
dates.AddRange(GetYears(1));
break;
case ReportableDateType.years3:
dates.AddRange(GetYears(3));
break;
case ReportableDateType.years10:
dates.AddRange(GetYears(10));
break;
default:
break;
}
}
}
}
private List<DateTime> GetYears(int v)
{
List<DateTime> result = new List<DateTime>();
for (int i = 0; i < v; i++)
{
var year= (DateTime.Now.AddYears(i * -1).Year+"-01"+"-01").ObjToDate();
result.Add(year);
}
return result;
}
private List<DateTime> GetMonths(int v)
{
List<DateTime> result = new List<DateTime>();
var years = GetYears(v);
foreach (var item in years)
{
for (int i = 0; i < 12; i++)
{
result.Add(item.AddMonths(i));
}
}
return result;
}
private object FormatValue(object value)
{
if (value == null)
return "null";
var type =UtilMethods.GetUnderType(value.GetType());
if (type.IsIn(typeof(int), typeof(uint), typeof(long), typeof(ulong), typeof(short), typeof(ushort)))
{
return value;
}
else if (type.IsIn(typeof(decimal), typeof(double)))
{
return value;
}
else if (type.IsIn(typeof(DateTime)))
{
Expression<Func<SingleColumnEntity<object>, object>> exp= it => Convert.ToDateTime(it.ColumnName);
var result= queryBuilder.GetExpressionValue(exp,ResolveExpressType.WhereSingle).GetResultString();
result = Regex.Replace(result, @"\[ColumnName\]", formatBuilder.FormatValue(value)+"",RegexOptions.IgnoreCase);
result = Regex.Replace(result, @"\`ColumnName\`", formatBuilder.FormatValue(value) + "", RegexOptions.IgnoreCase);
result = Regex.Replace(result, @"""ColumnName""", formatBuilder.FormatValue(value) + "", RegexOptions.IgnoreCase);
return result;
}
else
{
return formatBuilder.FormatValue(value);
}
}
}
}

2
Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/QueryBuilder.cs
View File

@@ -477,6 +477,7 @@ namespace SqlSugar
#endregion
#region Get SQL Partial
public string Offset { get; set; }
public virtual string GetSelectValue
{
get
@@ -640,6 +641,7 @@ namespace SqlSugar
}
}
#endregion
private string GetTableName(string entityName)

32
Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarProvider.cs
View File

@@ -754,6 +754,38 @@ namespace SqlSugar
}
#endregion
#region Reportable
public IReportable<T> Reportable<T>(T data)
{
var result = new ReportableProvider<T>(data);
result.formatBuilder = InstanceFactory.GetInsertBuilder(this.Context.CurrentConnectionConfig);
result.Context = this;
result.formatBuilder.Context = this;
result.queryBuilder = this.Queryable<object>().QueryBuilder;
return result;
}
public IReportable<T> Reportable<T>(List<T> list)
{
var result = new ReportableProvider<T>(list);
result.formatBuilder = InstanceFactory.GetInsertBuilder(this.Context.CurrentConnectionConfig);
result.Context = this;
result.formatBuilder.Context = this;
result.queryBuilder = this.Queryable<object>().QueryBuilder;
return result;
}
public IReportable<T> Reportable<T>(T [] list)
{
if (list == null)
list = new T[] { };
var result = new ReportableProvider<T>(list.ToList());
result.formatBuilder = InstanceFactory.GetInsertBuilder(this.Context.CurrentConnectionConfig);
result.Context = this;
result.formatBuilder.Context = this;
result.queryBuilder = this.Queryable<object>().QueryBuilder;
return result;
}
#endregion
#region DbFirst
public virtual IDbFirst DbFirst
{

13
Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Entities/SingleColumnsEntity.cs Normal file
View File

@@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SqlSugar
{
public class SingleColumnEntity<T>
{
public T ColumnName { get; set; }
}
}

18
Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Enum/ReportableDateType.cs Normal file
View File

@@ -0,0 +1,18 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SqlSugar
{
public enum ReportableDateType
{
MonthsInLast1years=0,
MonthsInLast3years=1,
MonthsInLast10years=2,
years1=3,
years3=4,
years10=5
}
}

2
Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs
View File

@@ -131,7 +131,7 @@ namespace SqlSugar
foreach (var item in entity.Parameter)
{
var oldName = item.ParameterName;
item.ParameterName = oldName + "_con_" + this.Context.ParameterIndex;
item.ParameterName = Regex.Split(oldName,"_con_").First() + "_con_" + this.Context.ParameterIndex;
entity.Where = entity.Where.Replace(oldName, item.ParameterName);
}
this.Context.ParameterIndex++;

27
Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/NewExpressionResolve.cs
View File

@@ -41,10 +41,18 @@ namespace SqlSugar
case ResolveExpressType.ArrayMultiple:
case ResolveExpressType.ArraySingle:
foreach (var item in expression.Arguments)
{
if (IsDateValue(item))
{
var value = GetNewExpressionValue(item);
base.Context.Result.Append(value);
}
else
{
base.Expression = item;
base.Start();
}
}
break;
case ResolveExpressType.Join:
base.Context.ResolveType = ResolveExpressType.WhereMultiple;
@@ -75,6 +83,25 @@ namespace SqlSugar
}
}
private bool IsDateValue(Expression item)
{
var isMember = item is MemberExpression;
if (isMember)
{
var m = (item as MemberExpression);
var isInt= m.Type == UtilConstants.IntType;
if (m.Expression != null && isInt&& m.Expression is MemberExpression)
{
var mm = (m.Expression as MemberExpression);
if (m.Member.Name.IsIn("Year", "Day", "Month")&&mm.Type==UtilConstants.DateType)
{
return true;
}
}
}
return false;
}
private void NewValueType(ExpressionParameter parameter, NewExpression expression)
{
try

6
Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/ContextMethods.cs
View File

@@ -288,7 +288,11 @@ namespace SqlSugar
}
else if (IsBytes(readerValues, item))
{
result.Add(name,(byte[])readerValues[item.Name.ToLower()]);
result.Add(name, (byte[])readerValues[item.Name.ToLower()]);
}
else if (item.PropertyType == typeof(object))
{
result.Add(name, readerValues[item.Name.ToLower()]);
}
else
{

5
Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IQueryable.cs
View File

@@ -133,6 +133,7 @@ namespace SqlSugar
Task<List<Dictionary<string, object>>> ToDictionaryListAsync();
T[] ToArray();
Task<T[]> ToArrayAsync();
Task<List<T>> ToListAsync();
string ToJson();
@@ -154,6 +155,10 @@ namespace SqlSugar
DataTable ToDataTablePage(int pageIndex, int pageSize, ref int totalNumber,ref int totalPage);
Task<DataTable> ToDataTablePageAsync(int pageIndex, int pageSize, RefAsync<int> totalNumber);
List<T> ToOffsetPage(int pageIndex,int pageSize);
List<T> ToOffsetPage(int pageIndex, int pageSize,ref int totalNumber);
Task<List<T>> ToOffsetPageAsync(int pageIndex, int pageSize);
Task<List<T>> ToOffsetPageAsync(int pageIndex, int pageSize, RefAsync<int> totalNumber);
List<T> ToPageList(int pageIndex, int pageSize);
Task<List<T>> ToPageListAsync(int pageIndex, int pageSize);
List<T> ToPageList(int pageIndex, int pageSize, ref int totalNumber);

15
Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IReportable.cs Normal file
View File

@@ -0,0 +1,15 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SqlSugar
{
public interface IReportable<T>
{
//IReportable<T> MakeUp(Func<T,object> auto);
ISugarQueryable<T> ToQueryable();
ISugarQueryable<SingleColumnEntity<Y>> ToQueryable<Y>();
}
}

8
Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/SqlServer/SqlBuilder/SqlServerQueryBuilder.cs
View File

@@ -48,6 +48,14 @@ namespace SqlSugar
result = ToPageSql2(result, ExternalPageIndex, ExternalPageSize, true);
}
this.OrderByValue = oldOrderBy;
if (!string.IsNullOrEmpty(this.Offset))
{
if (this.OrderByValue.IsNullOrEmpty())
{
result += " ORDER BY GETDATE() ";
}
result += this.Offset;
}
return result;
}
}

15
Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarClient.cs
View File

@@ -358,6 +358,21 @@ namespace SqlSugar
}
#endregion
#region Reportable
public IReportable<T> Reportable<T>(T data)
{
return this.Context.Reportable(data);
}
public IReportable<T> Reportable<T>(List<T> list)
{
return this.Context.Reportable(list);
}
public IReportable<T> Reportable<T>(T [] array)
{
return this.Context.Reportable(array);
}
#endregion
#region Queue
public QueueList Queues { get { return this.Context.Queues; } set { this.Context.Queues = value; } }
public void AddQueue(string sql, object parsmeters = null)

24
Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Utilities/UtilMethods.cs
View File

@@ -135,6 +135,7 @@ namespace SqlSugar
itemSql = Regex.Replace(itemSql, string.Format(@" {0}\+", "\\" + itemParameter.ParameterName)," "+ newName + "+", RegexOptions.IgnoreCase);
itemSql = Regex.Replace(itemSql, string.Format(@"\|\|{0}\|\|", "\\" + itemParameter.ParameterName), "+" + newName + "+", RegexOptions.IgnoreCase);
itemSql = Regex.Replace(itemSql, string.Format(@"\={0}\+", "\\" + itemParameter.ParameterName), "=" + newName + "+", RegexOptions.IgnoreCase);
itemSql = Regex.Replace(itemSql, string.Format(@"{0}\|\|", "\\" + itemParameter.ParameterName), newName + "+", RegexOptions.IgnoreCase);
return itemSql;
}
internal static Type GetRootBaseType(Type entityType)
@@ -182,6 +183,29 @@ namespace SqlSugar
}
return returnObj;
}
public static object ChangeType2(object value, Type type)
{
if (value == null && type.IsGenericType) return Activator.CreateInstance(type);
if (value == null) return null;
if (type == value.GetType()) return value;
if (type.IsEnum)
{
if (value is string)
return Enum.Parse(type, value as string);
else
return Enum.ToObject(type, value);
}
if (!type.IsInterface && type.IsGenericType)
{
Type innerType = type.GetGenericArguments()[0];
object innerValue = ChangeType(value, innerType);
return Activator.CreateInstance(type, new object[] { innerValue });
}
if (value is string && type == typeof(Guid)) return new Guid(value as string);
if (value is string && type == typeof(Version)) return new Version(value as string);
if (!(value is IConvertible)) return value;
return Convert.ChangeType(value, type);
}
internal static T ChangeType<T>(T obj, Type type)
{