自己做項目的時候封裝的SqlSugar操作類,備份以後用…
簡介:
SqlSugar ：是一款高性能（達到ADO.NET最高性能水平）
SqlSugar ：是除EF外拉姆達解析最完善的ORM，多表 、UnionALL、 交叉子查詢、真實的批量操作和分頁
SqlSugar ：用法簡單，功能齊全
SqlSugar ：對數據庫結構沒太多要求支持多主鍵、多自增列、支持異步
SqlSugar ：支持分佈式二級緩存（CRUD可以自動清除緩存)和支持讀寫分離功能大型項目必備
SqlSugar支持.Net 4.0+ 和 .Net Core
官網:http://www.codeisbug.com
**
你們都要打包的源碼分享個大家.Net Core和.Net 二個版本,打包的版本是5.0.0.8
**
提取碼：5wbk
#region << 版 本 注 釋 >>
/*----------------------------------------------------------------
* 類 名 稱 ：OrderByClause
* 類 描 述 ：
* 作 者 ：xnlzg
* 創建時間 ：2018/11/7 14:12:53
* 更新時間 ：2018/11/7 14:12:53
* 說 明 ：
* 版 本 號 ：v1.0.0.0
*******************************************************************
* Copyright @ xnlzg 2018. All rights reserved.
*******************************************************************
//----------------------------------------------------------------*/
#endregion
namespace XN.Common
{
/// <summary>
/// 排序實體
/// </summary>
public class OrderByClause
{
/// <summary>
/// 排序字段
/// </summary>
public string Sort { get; set; }
/// <summary>
/// 排序類型
/// </summary>
public OrderSequence Order { get; set; }
}
}
#region << 版 本 注 釋 >>
/*----------------------------------------------------------------
* 類 名 稱 ：OrderSequence
* 類 描 述 ：
* 作 者 ：xnlzg
* 創建時間 ：2018/11/7 14:12:32
* 更新時間 ：2018/11/7 14:12:32
* 說 明 ：
* 版 本 號 ：v1.0.0.0
*******************************************************************
* Copyright @ xnlzg 2018. All rights reserved.
*******************************************************************
//----------------------------------------------------------------*/
#endregion
namespace XN.Common
{
/// <summary>
/// 排序枚舉
/// </summary>
public enum OrderSequence
{
/// <summary>
/// 正序
/// </summary>
Asc,
/// <summary>
/// 倒序
/// </summary>
Desc
}
}
#region << 版 本 注 釋 >>
/*----------------------------------------------------------------
* 類 名 稱 ：QueryCondition
* 類 描 述 ：
* 作 者 ：xnlzg
* 創建時間 ：2018/11/7 14:14:29
* 更新時間 ：2018/11/7 14:14:29
* 說 明 ：
* 版 本 號 ：v1.0.0.0
*******************************************************************
* Copyright @ xnlzg 2018. All rights reserved.
*******************************************************************
//----------------------------------------------------------------*/
#endregion
namespace XN.Common
{
/// <summary>
/// 查詢
/// </summary>
public class QueryCondition
{
/// <summary>
/// 字段名稱
/// </summary>
public string Key { get; set; }
/// <summary>
/// 查詢操作
/// </summary>
public QueryOperator Operator { get; set; }
/// <summary>
/// 值
/// </summary>
public object Value { get; set; }
}
}
#region << 版 本 注 釋 >>
/*----------------------------------------------------------------
* 類 名 稱 ：QueryDescriptor
* 類 描 述 ：
* 作 者 ：xnlzg
* 創建時間 ：2018/11/7 14:15:04
* 更新時間 ：2018/11/7 14:15:04
* 說 明 ：
* 版 本 號 ：v1.0.0.0
*******************************************************************
* Copyright @ xnlzg 2018. All rights reserved.
*******************************************************************
//----------------------------------------------------------------*/
#endregion
using System.Collections.Generic;
namespace XN.Common
{
/// <summary>
/// 查詢集合
/// </summary>
public class QueryDescriptor
{
/// <summary>
/// 行數
/// </summary>
public int PageSize { get; set; }
/// <summary>
/// 頁碼
/// </summary>
public int PageIndex { get; set; }
/// <summary>
/// 排序
/// </summary>
public List<OrderByClause> OrderBys { get; set; }
/// <summary>
/// 條件
/// </summary>
public List<QueryCondition> Conditions { get; set; }
}
}
#region << 版 本 注 釋 >>
/*----------------------------------------------------------------
* 類 名 稱 ：QueryOperator
* 類 描 述 ：
* 作 者 ：xnlzg
* 創建時間 ：2018/11/7 14:14:03
* 更新時間 ：2018/11/7 14:14:03
* 說 明 ：
* 版 本 號 ：v1.0.0.0
*******************************************************************
* Copyright @ xnlzg 2018. All rights reserved.
*******************************************************************
//----------------------------------------------------------------*/
#endregion
namespace XN.Common
{
/// <summary>
/// 查詢條件枚舉
/// </summary>
public enum QueryOperator
{
/// <summary>
/// 相等
/// </summary>
Equal,
/// <summary>
/// 匹配
/// </summary>
Like,
/// <summary>
/// 大於
/// </summary>
GreaterThan,
/// <summary>
/// 大於或等於
/// </summary>
GreaterThanOrEqual,
/// <summary>
/// 小於
/// </summary>
LessThan,
/// <summary>
/// 小於或等於
/// </summary>
LessThanOrEqual,
/// <summary>
/// 等於集合
/// </summary>
In,
/// <summary>
/// 不等於集合
/// </summary>
NotIn,
/// <summary>
/// 左邊匹配
/// </summary>
LikeLeft,
/// <summary>
/// 右邊匹配
/// </summary>
LikeRight,
/// <summary>
/// 不相等
/// </summary>
NoEqual,
/// <summary>
/// 爲空或空
/// </summary>
IsNullOrEmpty,
/// <summary>
/// 不爲空
/// </summary>
IsNot,
/// <summary>
/// 不匹配
/// </summary>
NoLike,
/// <summary>
/// 時間段 值用 "|" 隔開
/// </summary>
DateRange
}
}
#region 開發單位：xnlzg 版權所有Copyright (C) 2011
/***-------------------------------------------------------------------------------------
命名空間：OPPO.DBUtility.Sugar
文 件 名：BaseDbContext
創建時間：2018/6/8 10:15:10
創 建 人：xnlzg
修改時間：
修 改 人：
說 明：
-------------------------------------------------------------------------------------***/
#endregion
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using SqlSugar;
namespace XN.Common
{
/// <summary>
/// 數據庫操作類
/// </summary>
public class BaseDbContext
{
/// <summary>
/// 注意當前方法的類不能是靜態的 public static class這麼寫是錯誤的
/// </summary>
public static SqlSugarClient Db
{
get
{
var connMain = ConfigurationManager.ConnectionStrings["ConnMain"];
var connFrom = ConfigurationManager.ConnectionStrings["ConnFrom"];
return InitDataBase(connFrom == null
? new List<string> { connMain.ToString() }
: new List<string> { connMain.ToString(), connFrom.ToString() });
}
}
/// <summary>
/// 獲得SqlSugarClient
/// </summary>
/// <param name="serverIp">服務器IP或文件路徑</param>
/// <param name="user">用戶名</param>
/// <param name="pass">密碼</param>
/// <param name="dataBase">數據庫</param>
public static SqlSugarClient GetIntance(string serverIp, string user, string pass, string dataBase)
{
var listConn = new List<string>();
switch ((DbType)ConfigurationManager.ConnectionStrings["DbType"].ObjToInt())
{
case DbType.SqlServer:
listConn.Add($"server={serverIp};user id={user};password={pass};persistsecurityinfo=True;database={dataBase}");
break;
case DbType.MySql:
listConn.Add($"Server={serverIp};Database={dataBase};Uid={user};Pwd={pass};");
break;
case DbType.Oracle:
listConn.Add($"Server=(DESCRIPTION=(ADDRESS_LIST=(ADDRESS=(PROTOCOL=TCP)(HOST={serverIp})(PORT=1521)))(CONNECT_DATA=(SERVER=DEDICATED)(SERVICE_NAME={dataBase})));User Id={user};Password={pass};Persist Security Info=True;Enlist=true;Max Pool Size=300;Min Pool Size=0;Connection Lifetime=300");
break;
case DbType.PostgreSQL:
listConn.Add($"PORT=5432;DATABASE={dataBase};HOST={serverIp};PASSWORD={pass};USER ID={user}");
break;
case DbType.Sqlite:
listConn.Add($"Data Source={serverIp};Version=3;Password={pass};");
break;
}
return InitDataBase(listConn);
}
/// <summary>
/// 初始化數據庫連接
/// </summary>
/// <param name="listConn">連接字符串</param>
private static SqlSugarClient InitDataBase(List<string> listConn)
{
var connStr = "";//主庫
var slaveConnectionConfigs = new List<SlaveConnectionConfig>();//從庫集合
for (var i = 0; i < listConn.Count; i++)
{
if (i == 0)
{
connStr = listConn[i];//主數據庫連接
}
else
{
slaveConnectionConfigs.Add(new SlaveConnectionConfig()
{
HitRate = i * 2,
ConnectionString = listConn[i]
});
}
}
//如果配置了 SlaveConnectionConfigs那就是主從模式,所有的寫入刪除更新都走主庫，查詢走從庫，
//事務內都走主庫，HitRate表示權重 值越大執行的次數越高，如果想停掉哪個連接可以把HitRate設爲0
var db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = connStr,
DbType = (DbType)ConfigurationManager.ConnectionStrings["DbType"].ObjToInt(),
IsAutoCloseConnection = true,
SlaveConnectionConfigs = slaveConnectionConfigs,
IsShardSameThread = true
});
db.Ado.CommandTimeOut = 30000;//設置超時時間
db.Aop.OnLogExecuted = (sql, pars) => //SQL執行完事件
{
//LogHelper.WriteLog($"執行時間：{db.Ado.SqlExecutionTime.TotalMilliseconds}毫秒 \r\nSQL如下：{sql} \r\n參數：{GetParams(pars)} ", "SQL執行");
};
db.Aop.OnLogExecuting = (sql, pars) => //SQL執行前事件
{
if (db.TempItems == null) db.TempItems = new Dictionary<string, object>();
};
db.Aop.OnError = (exp) =>//執行SQL 錯誤事件
{
//LogHelper.WriteLog($"SQL錯誤:{exp.Message}\r\nSQL如下：{exp.Sql}", "SQL執行");
throw new Exception(exp.Message);
};
db.Aop.OnExecutingChangeSql = (sql, pars) => //SQL執行前 可以修改SQL
{
return new KeyValuePair<string, SugarParameter[]>(sql, pars);
};
db.Aop.OnDiffLogEvent = (it) => //可以方便拿到 數據庫操作前和操作後的數據變化。
{
//var editBeforeData = it.BeforeData;
//var editAfterData = it.AfterData;
//var sql = it.Sql;
//var parameter = it.Parameters;
//var data = it.BusinessData;
//var time = it.Time;
//var diffType = it.DiffType;//枚舉值 insert 、update 和 delete 用來作業務區分
//你可以在這裏面寫日誌方法
};
return db;
}
/// <summary>
/// 獲取參數信息
/// </summary>
/// <param name="pars"></param>
/// <returns></returns>
private static string GetParams(SugarParameter[] pars)
{
return pars.Aggregate("", (current, p) => current + $"{p.ParameterName}:{p.Value}, ");
}
}
}
#region << 版 本 注 釋 >>
/*----------------------------------------------------------------
* 類 名 稱 ：ISqlRepository
* 類 描 述 ：
* 作 者 ：xnlzg
* 創建時間 ：2018/7/23 15:56:57
* 更新時間 ：2018/7/23 15:56:57
* 說 明 ：
* 版 本 號 ：v1.0.0.0
*******************************************************************
* Copyright @ xnlzg 2018. All rights reserved.
*******************************************************************
//----------------------------------------------------------------*/
#endregion
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq.Expressions;
using SqlSugar;
using XN.Common;
namespace OPPO.DBUtility
{
/// <summary>
/// SqlSugar操作接口類
/// </summary>
public interface ISugerHandler : IDisposable
{
#region 事務
/// <summary>
/// 事務操作
/// 注意:代碼段裏面如果調用本身類其它方法或其它類方法必須帶着var db = SugerHandler.Instance()這個db走，不帶着走事務回滾會不成功
/// </summary>
/// <param name="serviceAction">代碼段</param>
/// <param name="level">事務級別</param>
void InvokeTransactionScope(Action serviceAction, IsolationLevel level = IsolationLevel.ReadCommitted);
#endregion
#region 數據庫管理
/// <summary>
/// 添加列
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="column">列信息</param>
/// <returns></returns>
bool AddColumn(string tableName, DbColumnInfo column);
/// <summary>
/// 添加主鍵
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="columnName">列名</param>
/// <returns></returns>
bool AddPrimaryKey(string tableName, string columnName);
/// <summary>
/// 備份數據庫
/// </summary>
/// <param name="databaseName">數據庫名</param>
/// <param name="fullFileName">文件名</param>
/// <returns></returns>
bool BackupDataBase(string databaseName, string fullFileName);
/// <summary>
/// 備份表
/// </summary>
/// <param name="oldTableName">舊錶名</param>
/// <param name="newTableName">行表名</param>
/// <param name="maxBackupDataRows">行數</param>
/// <returns></returns>
bool BackupTable(string oldTableName, string newTableName, int maxBackupDataRows = int.MaxValue);
/// <summary>
/// 創建表
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="columns">列集合</param>
/// <param name="isCreatePrimaryKey">是否創建主鍵</param>
/// <returns></returns>
bool CreateTable(string tableName, List<DbColumnInfo> columns, bool isCreatePrimaryKey = true);
/// <summary>
/// 刪除列
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="columnName">列名</param>
/// <returns></returns>
bool DropColumn(string tableName, string columnName);
/// <summary>
/// 刪除約束
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="constraintName">約束名</param>
/// <returns></returns>
bool DropConstraint(string tableName, string constraintName);
/// <summary>
/// 刪除表
/// </summary>
/// <param name="tableName"></param>
/// <returns></returns>
bool DropTable(string tableName);
/// <summary>
/// 獲取列信息
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="isCache">是否緩存</param>
/// <returns></returns>
List<DbColumnInfo> GetColumnInfosByTableName(string tableName, bool isCache = true);
/// <summary>
/// 獲取自增列
/// </summary>
/// <param name="tableName">表名</param>
/// <returns></returns>
List<string> GetIsIdentities(string tableName);
/// <summary>
/// 獲取主鍵
/// </summary>
/// <param name="tableName">表名</param>
/// <returns></returns>
List<string> GetPrimaries(string tableName);
/// <summary>
/// 獲取表集合
/// </summary>
/// <param name="isCache">是否緩存</param>
/// <returns></returns>
List<DbTableInfo> GetTableInfoList(bool isCache = true);
/// <summary>
/// 獲取視圖集合
/// </summary>
/// <param name="isCache">是否緩存</param>
/// <returns></returns>
List<DbTableInfo> GetViewInfoList(bool isCache = true);
/// <summary>
/// 檢測列是否存在
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="column">列名</param>
/// <returns></returns>
bool IsAnyColumn(string tableName, string column);
/// <summary>
/// 檢測約束
/// </summary>
/// <param name="constraintName">約束名稱</param>
/// <returns></returns>
bool IsAnyConstraint(string constraintName);
/// <summary>
/// 檢測是否有任何系統表權限
/// </summary>
/// <returns></returns>
bool IsAnySystemTablePermissions();
/// <summary>
/// 檢測表是否存在
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="isCache">是否緩存</param>
/// <returns></returns>
bool IsAnyTable(string tableName, bool isCache = true);
/// <summary>
/// 檢測列是否自增列
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="column">列名</param>
/// <returns></returns>
bool IsIdentity(string tableName, string column);
/// <summary>
/// 檢測列是否主鍵
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="column">列名</param>
/// <returns></returns>
bool IsPrimaryKey(string tableName, string column);
/// <summary>
/// 重置列名
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="oldColumnName">舊列名</param>
/// <param name="newColumnName">新列名</param>
/// <returns></returns>
bool RenameColumn(string tableName, string oldColumnName, string newColumnName);
/// <summary>
/// 重置表數據
/// </summary>
/// <param name="tableName">表名</param>
/// <returns></returns>
bool TruncateTable(string tableName);
/// <summary>
/// 修改列信息
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="column">列信息</param>
/// <returns></returns>
bool UpdateColumn(string tableName, DbColumnInfo column);
/// <summary>
/// 獲取數據庫時間
/// </summary>
/// <returns>返回值</returns>
DateTime GetDataBaseTime();
#endregion
#region 新增
/// <summary>
/// 新增
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entity"> 實體對象 </param>
/// <returns>操作影響的行數</returns>
int Add<T>(T entity) where T : class, new();
/// <summary>
/// 新增
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entitys">泛型集合</param>
/// <returns>操作影響的行數</returns>
int Add<T>(List<T> entitys) where T : class, new();
/// <summary>
/// 新增
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="keyValues">字典集合（Key:列名 Value:值）</param>
/// <returns>操作影響的行數</returns>
int Add<T>(Dictionary<string, object> keyValues) where T : class, new();
/// <summary>
/// 新增
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entity"> 實體對象 </param>
/// <returns>返回實體</returns>
T AddReturnEntity<T>(T entity) where T : class, new();
/// <summary>
/// 新增
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entity"> 實體對象 </param>
/// <returns>返回自增列</returns>
int AddReturnIdentity<T>(T entity) where T : class, new();
/// <summary>
/// 新增
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entity"> 實體對象 </param>
/// <returns>返回bool</returns>
bool AddReturnBool<T>(T entity) where T : class, new();
/// <summary>
/// 新增
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entitys">泛型集合</param>
/// <returns>返回bool</returns>
bool AddReturnBool<T>(List<T> entitys) where T : class, new();
#endregion
#region 修改
/// <summary>
/// 修改（主鍵是更新條件）
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entity"> 實體對象（必須指定主鍵特性 [SugarColumn(IsPrimaryKey=true)]），如果是聯合主鍵，請使用Where條件 </param>
/// <param name="lstIgnoreColumns">不更新的列</param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
int Update<T>(T entity, List<string> lstIgnoreColumns = null, bool isLock = true) where T : class, new();
/// <summary>
/// 修改（主鍵是更新條件）
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entitys"> 實體對象集合（必須指定主鍵特性 [SugarColumn(IsPrimaryKey=true)]），如果是聯合主鍵，請使用Where條件 </param>
/// <param name="lstIgnoreColumns">不更新的列</param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
int Update<T>(List<T> entitys, List<string> lstIgnoreColumns = null, bool isLock = true) where T : class, new();
/// <summary>
/// 修改
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entity"> 實體對象 </param>
/// <param name="where"> 條件 </param>
/// <param name="lstIgnoreColumns">不更新的列</param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
int Update<T>(T entity, Expression<Func<T, bool>> where , List<string> lstIgnoreColumns = null,
bool isLock = true) where T : class, new();
/// <summary>
/// 修改
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="update"> 實體對象 </param>
/// <param name="where"> 條件 </param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
int Update<T>(Expression<Func<T, T>> update, Expression<Func<T, bool>> where = null, bool isLock = true) where T : class, new();
/// <summary>
/// 修改
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="keyValues">字典集合（Key:列名 Value:值）</param>
/// <param name="where"> 條件 </param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
int Update<T>(Dictionary<string, object> keyValues, Expression<Func<T, bool>> where = null, bool isLock = true)
where T : class, new();
/// <summary>
/// 批量修改需要更新的列
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entitys"> 實體對象（必須指定主鍵特性 [SugarColumn(IsPrimaryKey=true)]），如果是聯合主鍵，請使用Where條件 </param>
/// <param name="updateColumns">更新指定列</param>
/// <param name="wherecolumns">條件(爲空則以主鍵更新,反之需要把wherecolumns中的列加到UpdateColumns中)</param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
int UpdateColumns<T>(List<T> entitys, Expression<Func<T, object>> updateColumns,
Expression<Func<T, object>> wherecolumns = null, bool isLock = true) where T : class, new();
/// <summary>
/// 修改 通過RowVer及主鍵Code 更新
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entity"> 實體對象 </param>
/// <param name="lstIgnoreColumns">不更新的列</param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
int UpdateRowVer<T>(T entity, List<string> lstIgnoreColumns = null, bool isLock = true)where T : class, new();
/// <summary>
/// 修改 通過RowVer及主鍵Code 更新
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="update"> 實體對象 </param>
/// <param name="where"> 更新條件 </param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
int UpdateRowVer<T>(Expression<Func<T, T>> update, Dictionary<string, object> where, bool isLock = true) where T : class, new();
#endregion
#region 刪除
/// <summary>
/// 刪除 通過主鍵數據
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="primaryKeyValues">主鍵值</param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
int DeleteByPrimary<T>(List<object> primaryKeyValues, bool isLock = true) where T : class, new();
/// <summary>
/// 刪除
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entity"> 實體對象（必須指定主鍵特性 [SugarColumn(IsPrimaryKey=true)]），如果是聯合主鍵，請使用Where條件 </param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
int Delete<T>(T entity, bool isLock = true) where T : class, new();
/// <summary>
/// 刪除
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entity"> 實體對象 （必須指定主鍵特性 [SugarColumn(IsPrimaryKey=true)]），如果是聯合主鍵，請使用Where條件</param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
int Delete<T>(List<T> entity, bool isLock = true) where T : class, new();
/// <summary>
/// 刪除
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="where"> 條件 </param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
int Delete<T>(Expression<Func<T, bool>> where, bool isLock = true) where T : class, new();
/// <summary>
/// 通過多值(主鍵)刪除數據集
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="inValues">數據集合</param>
/// <returns></returns>
int DeleteIn<T>(List<dynamic> inValues) where T : class, new();
#endregion
#region 查詢
#region 數據源
///// <summary>
///// 查詢數據源
///// </summary>
///// <typeparam name="T">泛型參數(集合成員的類型</typeparam>
///// <returns>數據源</returns>
//ISugarQueryable<T> Queryable<T>() where T : class, new();
#endregion
#region 多表查詢
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (t1,t2) => new object[] {JoinType.Left,t1.UserNo==t2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (t1, t2) => new { Id =t1.UserNo, Id1 = t2.UserNo}</param>
/// <param name="whereLambda">查詢表達式 (t1, t2) =>t1.UserNo == "")</param>
/// <returns></returns>
List<TResult> QueryMuch<T, T2, TResult>(
Expression<Func<T, T2, object[]>> joinExpression,
Expression<Func<T, T2, TResult>> selectExpression,
Expression<Func<T, T2, bool>> whereLambda = null) where T : class, new();
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式</param>
/// <param name="selectExpression">返回表達式</param>
/// <param name="whereLambda">查詢表達式</param>
/// <returns></returns>
List<TResult> QueryMuch<T, T2, T3, TResult>(
Expression<Func<T, T2, T3, object[]>> joinExpression,
Expression<Func<T, T2, T3, TResult>> selectExpression,
Expression<Func<T, T2, T3, bool>> whereLambda = null) where T : class, new();
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式</param>
/// <param name="selectExpression">返回表達式</param>
/// <param name="whereLambda">查詢表達式</param>
/// <returns></returns>
List<TResult> QueryMuch<T, T2, T3, T4, TResult>(
Expression<Func<T, T2, T3, T4, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, TResult>> selectExpression,
Expression<Func<T, T2, T3, T4, bool>> whereLambda = null) where T : class, new();
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式</param>
/// <param name="selectExpression">返回表達式</param>
/// <param name="whereLambda">查詢表達式</param>
/// <returns></returns>
List<TResult> QueryMuch<T, T2, T3, T4, T5, TResult>(
Expression<Func<T, T2, T3, T4, T5, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5, TResult>> selectExpression,
Expression<Func<T, T2, T3, T4, T5, bool>> whereLambda = null) where T : class, new();
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="T6">實體6</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="whereLambda">查詢表達式 (w1, w2) =>w1.UserNo == "")</param>
/// <returns>值</returns>
List<TResult> QueryMuch<T, T2, T3, T4, T5, T6, TResult>(
Expression<Func<T, T2, T3, T4, T5, T6, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5, T6, TResult>> selectExpression,
Expression<Func<T, T2, T3, T4, T5, T6, bool>> whereLambda = null) where T : class, new();
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="T6">實體6</typeparam>
/// <typeparam name="T7">實體7</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="whereLambda">查詢表達式 (w1, w2) =>w1.UserNo == "")</param>
/// <returns>值</returns>
List<TResult> QueryMuch<T, T2, T3, T4, T5, T6, T7, TResult>(
Expression<Func<T, T2, T3, T4, T5, T6, T7, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5, T6, T7, TResult>> selectExpression,
Expression<Func<T, T2, T3, T4, T5, T6, T7, bool>> whereLambda = null) where T : class, new();
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="T6">實體6</typeparam>
/// <typeparam name="T7">實體7</typeparam>
/// <typeparam name="T8">實體8</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="whereLambda">查詢表達式 (w1, w2) =>w1.UserNo == "")</param>
/// <returns>值</returns>
List<TResult> QueryMuch<T, T2, T3, T4, T5, T6, T7, T8, TResult>(
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, TResult>> selectExpression,
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, bool>> whereLambda = null) where T : class, new();
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="T6">實體6</typeparam>
/// <typeparam name="T7">實體7</typeparam>
/// <typeparam name="T8">實體8</typeparam>
/// <typeparam name="T9">實體9</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="whereLambda">查詢表達式 (w1, w2) =>w1.UserNo == "")</param>
/// <returns>值</returns>
List<TResult> QueryMuch<T, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, TResult>> selectExpression,
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, bool>> whereLambda = null) where T : class, new();
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (t1,t2) => new object[] {JoinType.Left,t1.UserNo==t2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (t1, t2) => new { Id =t1.UserNo, Id1 = t2.UserNo}</param>
/// <param name="query">查詢條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>值</returns>
List<TResult> QueryMuchDescriptor<T, T2, TResult>(
Expression<Func<T, T2, object[]>> joinExpression,
Expression<Func<T, T2, TResult>> selectExpression,
QueryDescriptor query, out int totalCount) where T : class, new();
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="query">查詢條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>值</returns>
List<TResult> QueryMuchDescriptor<T, T2, T3, TResult>(
Expression<Func<T, T2, T3, object[]>> joinExpression,
Expression<Func<T, T2, T3, TResult>> selectExpression,
QueryDescriptor query, out int totalCount) where T : class, new();
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="query">查詢條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>值</returns>
List<TResult> QueryMuchDescriptor<T, T2, T3, T4, TResult>(
Expression<Func<T, T2, T3, T4, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, TResult>> selectExpression,
QueryDescriptor query, out int totalCount) where T : class, new();
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="query">查詢條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>值</returns>
List<TResult> QueryMuchDescriptor<T, T2, T3, T4, T5, TResult>(
Expression<Func<T, T2, T3, T4, T5, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5, TResult>> selectExpression,
QueryDescriptor query, out int totalCount) where T : class, new();
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="T6">實體6</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="query">查詢條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>值</returns>
List<TResult> QueryMuchDescriptor<T, T2, T3, T4, T5, T6, TResult>(
Expression<Func<T, T2, T3, T4, T5, T6, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5, T6, TResult>> selectExpression,
QueryDescriptor query, out int totalCount) where T : class, new();
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="T6">實體6</typeparam>
/// <typeparam name="T7">實體7</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="query">查詢條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>值</returns>
List<TResult> QueryMuchDescriptor<T, T2, T3, T4, T5, T6, T7, TResult>(
Expression<Func<T, T2, T3, T4, T5, T6, T7, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5, T6, T7, TResult>> selectExpression,
QueryDescriptor query, out int totalCount) where T : class, new();
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="T6">實體6</typeparam>
/// <typeparam name="T7">實體7</typeparam>
/// <typeparam name="T8">實體8</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="query">查詢條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>值</returns>
List<TResult> QueryMuchDescriptor<T, T2, T3, T4, T5, T6, T7, T8, TResult>(
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, TResult>> selectExpression,
QueryDescriptor query, out int totalCount) where T : class, new();
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="T6">實體6</typeparam>
/// <typeparam name="T7">實體7</typeparam>
/// <typeparam name="T8">實體8</typeparam>
/// <typeparam name="T9">實體9</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="query">查詢條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>值</returns>
List<TResult> QueryMuchDescriptor<T, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, TResult>> selectExpression,
QueryDescriptor query, out int totalCount) where T : class, new();
#endregion
#region 查詢
/// <summary>
/// 查詢-返回自定義數據
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <typeparam name="TResult">返回值類型</typeparam>
/// <param name="expression">返回值表達式</param>
/// <param name="whereLambda">查詢表達式</param>
/// <returns>值</returns>
TResult QuerySelect<T, TResult>(Expression<Func<T, TResult>> expression,Expression<Func<T, bool>> whereLambda = null) where T : class, new();
/// <summary>
/// 查詢-返回自定義數據
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <typeparam name="TResult">返回值類型</typeparam>
/// <param name="expression">返回值表達式</param>
/// <param name="whereLambda">查詢表達式</param>
/// <returns>值</returns>
List<TResult> QuerySelectList<T, TResult>(Expression<Func<T, TResult>> expression,Expression<Func<T, bool>> whereLambda = null) where T : class, new();
/// <summary>
/// 查詢
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="whereLambda">查詢表達式</param>
/// <returns></returns>
T Query<T>(Expression<Func<T, bool>> whereLambda = null) where T : class, new();
/// <summary>
/// 查詢集合
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="whereLambda">過濾條件</param>
/// <returns>實體</returns>
List<T> QueryWhereList<T>(Expression<Func<T, bool>> whereLambda = null) where T : class, new();
/// <summary>
/// 查詢集合
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="query">過濾條件</param>
/// <returns>實體</returns>
List<T> QueryList<T>(QueryDescriptor query = null) where T : class, new();
/// <summary>
/// 查詢集合
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="sql">sql</param>
/// <returns>實體</returns>
List<T> QuerySqlList<T>(string sql) where T : class, new();
/// <summary>
/// 分頁查詢
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="query">過濾條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>實體</returns>
List<T> QueryPageList<T>(QueryDescriptor query, out int totalCount) where T : class, new();
/// <summary>
/// 通過多值查詢數據集
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="inFieldName">字段名</param>
/// <param name="inValues">數據集合</param>
/// <returns></returns>
List<T> In<T>(string inFieldName, List<dynamic> inValues) where T : class, new();
/// <summary>
/// 通過多值(主鍵)查詢數據集
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="values">主鍵數據集合</param>
/// <returns></returns>
List<T> In<T>(List<dynamic> values) where T : class, new();
/// <summary>
/// 查詢集合
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="whereLambda">查詢表達式</param>
/// <returns>實體</returns>
DataTable QueryDataTable<T>(Expression<Func<T, bool>> whereLambda = null) where T : class, new();
/// <summary>
/// 查詢集合
/// </summary>
/// <param name="sql">sql</param>
/// <returns>實體</returns>
DataTable QueryDataTable(string sql);
/// <summary>
/// 查詢單個值
/// </summary>
/// <param name="sql">sql</param>
/// <returns>單個值</returns>
object QuerySqlScalar(string sql);
/// <summary>
/// 分頁查詢
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="query">過濾條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>DataTable</returns>
DataTable QueryDataTablePageList<T>(QueryDescriptor query, out int totalCount) where T : class, new();
#endregion
#region Mapper
/// <summary>
/// Mapper查詢
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="mapperAction">操作(it, cache) =>
/// {
/// var all = cache.GetListByPrimaryKeys(vmodel => vmodel.Id); //一次性查詢出所要的外鍵引用數據
/// it.School = all.FirstOrDefault(i => i.Id == it.Id); //一對一
/// it.Schools = all.Where(i => i.Id == it.Id).ToList(); //一對多
/// /*用C#處理你想要的結果*/
/// it.Name = it.Name == null ? "null" : it.Name;
/// }
/// </param>
/// <param name="query">過濾條件</param>
/// <returns></returns>
List<T> QueryMapper<T>(Action<T> mapperAction, QueryDescriptor query = null) where T : class, new();
/// <summary>
/// Mapper查詢
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="mapperAction">操作(it, cache) =>
/// {
/// var all = cache.GetListByPrimaryKeys(vmodel => vmodel.Id); //一次性查詢出所要的外鍵引用數據
/// it.School = all.FirstOrDefault(i => i.Id == it.Id); //一對一
/// it.Schools = all.Where(i => i.Id == it.Id).ToList(); //一對多
/// /*用C#處理你想要的結果*/
/// it.Name = it.Name == null ? "null" : it.Name;
/// }
/// </param>
/// <param name="whereLambda">過濾條件</param>
/// <returns></returns>
List<T> QueryMapper<T>(Action<T> mapperAction, Expression<Func<T, bool>> whereLambda = null) where T : class, new();
#endregion
#region 存儲過程
/// <summary>
/// 查詢存儲過程
/// </summary>
/// <param name="procedureName">存儲過程名稱</param>
/// <param name="parameters">參數</param>
/// <returns>DataSet</returns>
DataSet QueryProcedureDataSet(string procedureName, List<SqlParameter> parameters);
/// <summary>
/// 查詢存儲過程
/// </summary>
/// <param name="procedureName">存儲過程名稱</param>
/// <param name="parameters">參數</param>
/// <returns>DataTable</returns>
DataTable QueryProcedure(string procedureName, List<SqlParameter> parameters);
/// <summary>
/// 查詢存儲過程
/// </summary>
/// <param name="procedureName">存儲過程名稱</param>
/// <param name="parameters">參數</param>
/// <returns>單個值</returns>
object QueryProcedureScalar(string procedureName, List<SqlParameter> parameters);
#endregion
#region 分組
/// <summary>
/// 分組
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="groupByLambda">分組表達式</param>
/// <param name="whereLambda">查詢表達式</param>
/// <returns>值</returns>
List<T> GroupBy<T>(Expression<Func<T, object>> groupByLambda,Expression<Func<T, bool>> whereLambda = null) where T : class, new();
/// <summary>
/// 分組-返回自定義數據
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <typeparam name="TResult">返回值類型</typeparam>
/// <param name="expression">返回值表達式</param>
/// <param name="groupByLambda">分組表達式</param>
/// <param name="whereLambda">查詢表達式</param>
/// <returns>值</returns>
List<TResult> GroupBy<T, TResult>(Expression<Func<T, TResult>> expression,
Expression<Func<T, object>> groupByLambda, Expression<Func<T, bool>> whereLambda = null)
where T : class, new();
#endregion
#region Json
/// <summary>
/// 查詢集合
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="whereLambda">查詢表達式</param>
/// <returns>Json</returns>
string QueryJson<T>(Expression<Func<T, bool>> whereLambda = null) where T : class, new();
#endregion
#region 其它
/// <summary>
/// 查詢前多少條數據
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型</typeparam>
/// <param name="whereLambda">查詢表達式</param>
/// <param name="num">數量</param>
/// <returns></returns>
List<T> Take<T>(Expression<Func<T, bool>> whereLambda, int num) where T : class, new();
/// <summary>
/// 查詢單條數據
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型</typeparam>
/// <param name="whereLambda">查詢表達式</param>
/// <returns></returns>
T First<T>(Expression<Func<T, bool>> whereLambda) where T : class, new();
/// <summary>
/// 是否存在
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型</typeparam>
/// <param name="whereLambda">查詢表達式</param>
/// <returns></returns>
bool IsExist<T>(Expression<Func<T, bool>> whereLambda) where T : class, new();
/// <summary>
/// 合計
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型</typeparam>
/// <param name="field">字段</param>
/// <returns></returns>
int Sum<T>(string field) where T : class, new();
/// <summary>
/// 最大值
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型</typeparam>
/// <typeparam name="TResult">返回類型</typeparam>
/// <param name="field">字段</param>
/// <returns></returns>
TResult Max<T, TResult>(string field) where T : class, new();
/// <summary>
/// 最小值
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型</typeparam>
/// <typeparam name="TResult">返回類型</typeparam>
/// <param name="field">字段</param>
/// <returns></returns>
TResult Min<T, TResult>(string field) where T : class, new();
/// <summary>
/// 平均值
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型</typeparam>
/// <param name="field">字段</param>
/// <returns></returns>
int Avg<T>(string field) where T : class, new();
/// <summary>
/// 生成流水號
/// </summary>
/// <param name="key">列名</param>
/// <param name="prefix">前綴</param>
/// <param name="fixedLength">流水號長度</param>
/// <param name="dateFomart">日期格式(yyyyMMdd) 爲空前綴後不加日期,反之加</param>
/// <returns></returns>
string CustomNumber<T>(string key, string prefix = "", int fixedLength = 4, string dateFomart = "")where T : class, new();
/// <summary>
/// 生成流水號
/// </summary>
/// <param name="key">列名</param>
/// <param name="num">數量</param>
/// <param name="prefix">前綴</param>
/// <param name="fixedLength">流水號長度</param>
/// <param name="dateFomart">日期格式(yyyyMMdd) 爲空前綴後不加日期,反之加</param>
/// <returns></returns>
List<string> CustomNumber<T>(string key,int num, string prefix = "", int fixedLength = 4, string dateFomart = "") where T : class, new();
#endregion
#endregion
}
}
#region << 版 本 注 釋 >>
/*----------------------------------------------------------------
* 類 名 稱 ：SugerHandler
* 類 描 述 ：
* 作 者 ：xnlzg
* 創建時間 ：2018/7/23 15:52:47
* 更新時間 ：2018/7/23 15:52:47
* 說 明 ：
using ( var db = SugarHandler.Instance())
{
db.BeginTran();
var userInfo = db.Query<SysUsers>(m => m.UserName == userLogin.UserName);
db.CommitTran();
}
* 版 本 號 ：v1.0.0.0
*******************************************************************
* Copyright @ xnlzg 2018. All rights reserved.
*******************************************************************
//----------------------------------------------------------------*/
#endregion
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq.Expressions;
using OPPO.DBUtility;
using SqlSugar;
namespace XN.Common
{
/// <summary>
/// SqlSugar調用類
/// </summary>
public class SugerHandler
{
#region 初始化
/// <summary>
/// 初始化
/// </summary>
/// <returns>值</returns>
public static ISugerHandler Instance()
{
return new SugerRepository();
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="serverIp">服務器IP</param>
/// <param name="user">用戶名</param>
/// <param name="pass">密碼</param>
/// <param name="dataBase">數據庫</param>
/// <returns>值</returns>
public static ISugerHandler Instance(string serverIp, string user, string pass, string dataBase)
{
var suger = new SugerRepository();
suger.Instance(serverIp, user, pass, dataBase);
return suger;
}
#endregion
}
/// <summary>
/// SqlSugar操作類型
/// </summary>
public class SugerRepository : ISugerHandler
{
/// <summary>
/// 數據庫連接對象
/// </summary>
public SqlSugarClient DbContext { get; set; } = BaseDbContext.Db;
/// <summary>
/// 初始化
/// </summary>
/// <param name="serverIp">服務器IP</param>
/// <param name="user">用戶名</param>
/// <param name="pass">密碼</param>
/// <param name="dataBase">數據庫</param>
/// <returns>值</returns>
public void Instance(string serverIp, string user, string pass, string dataBase)
{
DbContext = BaseDbContext.GetIntance(serverIp, user, pass, dataBase);
}
#region 事務
/// <summary>
/// 事務操作
/// 注意:代碼段裏面如果調用本身類其它方法或其它類方法必須帶着var db = SugerHandler.Instance()這個db走，不帶着走事務回滾會不成功
/// </summary>
/// <param name="serviceAction">代碼段</param>
/// <param name="level">事務級別</param>
public void InvokeTransactionScope(Action serviceAction, IsolationLevel level = IsolationLevel.ReadCommitted)
{
try
{
DbContext.Ado.BeginTran(level);
serviceAction();
DbContext.Ado.CommitTran();
}
catch (Exception ex)
{
DbContext.Ado.RollbackTran();
throw new Exception(ex.Message);
}
finally
{
Dispose();
}
}
#endregion
#region 數據庫管理
/// <summary>
/// 添加列
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="column">列信息</param>
/// <returns>值</returns>
public bool AddColumn(string tableName, DbColumnInfo column)
{
return DbContext.DbMaintenance.AddColumn(tableName, column);
}
/// <summary>
/// 添加主鍵
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="columnName">列名</param>
/// <returns>值</returns>
public bool AddPrimaryKey(string tableName, string columnName)
{
return DbContext.DbMaintenance.AddPrimaryKey(tableName, columnName);
}
/// <summary>
/// 備份數據庫
/// </summary>
/// <param name="databaseName">數據庫名</param>
/// <param name="fullFileName">文件名</param>
/// <returns>值</returns>
public bool BackupDataBase(string databaseName, string fullFileName)
{
return DbContext.DbMaintenance.BackupDataBase(databaseName, fullFileName);
}
/// <summary>
/// 備份表
/// </summary>
/// <param name="oldTableName">舊錶名</param>
/// <param name="newTableName">行表名</param>
/// <param name="maxBackupDataRows">行數</param>
/// <returns>值</returns>
public bool BackupTable(string oldTableName, string newTableName, int maxBackupDataRows = int.MaxValue)
{
return DbContext.DbMaintenance.BackupTable(oldTableName, newTableName, maxBackupDataRows);
}
/// <summary>
/// 創建表
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="columns">列集合</param>
/// <param name="isCreatePrimaryKey">是否創建主鍵</param>
/// <returns>值</returns>
public bool CreateTable(string tableName, List<DbColumnInfo> columns, bool isCreatePrimaryKey = true)
{
return DbContext.DbMaintenance.CreateTable(tableName, columns, isCreatePrimaryKey);
}
/// <summary>
/// 刪除列
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="columnName">列名</param>
/// <returns>值</returns>
public bool DropColumn(string tableName, string columnName)
{
return DbContext.DbMaintenance.DropColumn(tableName, columnName);
}
/// <summary>
/// 刪除約束
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="constraintName">約束名</param>
/// <returns>值</returns>
public bool DropConstraint(string tableName, string constraintName)
{
return DbContext.DbMaintenance.DropConstraint(tableName, constraintName);
}
/// <summary>
/// 刪除表
/// </summary>
/// <param name="tableName"></param>
/// <returns>值</returns>
public bool DropTable(string tableName)
{
return DbContext.DbMaintenance.DropTable(tableName);
}
/// <summary>
/// 獲取列信息
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="isCache">是否緩存</param>
/// <returns>值</returns>
public List<DbColumnInfo> GetColumnInfosByTableName(string tableName, bool isCache = true)
{
return DbContext.DbMaintenance.GetColumnInfosByTableName(tableName, isCache);
}
/// <summary>
/// 獲取自增列
/// </summary>
/// <param name="tableName">表名</param>
/// <returns>值</returns>
public List<string> GetIsIdentities(string tableName)
{
return DbContext.DbMaintenance.GetIsIdentities(tableName);
}
/// <summary>
/// 獲取主鍵
/// </summary>
/// <param name="tableName">表名</param>
/// <returns>值</returns>
public List<string> GetPrimaries(string tableName)
{
return DbContext.DbMaintenance.GetPrimaries(tableName);
}
/// <summary>
/// 獲取表集合
/// </summary>
/// <param name="isCache">是否緩存</param>
/// <returns>值</returns>
public List<DbTableInfo> GetTableInfoList(bool isCache = true)
{
return DbContext.DbMaintenance.GetTableInfoList(isCache);
}
/// <summary>
/// 獲取視圖集合
/// </summary>
/// <param name="isCache">是否緩存</param>
/// <returns>值</returns>
public List<DbTableInfo> GetViewInfoList(bool isCache = true)
{
return DbContext.DbMaintenance.GetViewInfoList(isCache);
}
/// <summary>
/// 檢測列是否存在
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="column">列名</param>
/// <returns>值</returns>
public bool IsAnyColumn(string tableName, string column)
{
return DbContext.DbMaintenance.IsAnyColumn(tableName, column);
}
/// <summary>
/// 檢測約束
/// </summary>
/// <param name="constraintName">約束名稱</param>
/// <returns>值</returns>
public bool IsAnyConstraint(string constraintName)
{
return DbContext.DbMaintenance.IsAnyConstraint(constraintName);
}
/// <summary>
/// 檢測是否有任何系統表權限
/// </summary>
/// <returns>值</returns>
public bool IsAnySystemTablePermissions()
{
return DbContext.DbMaintenance.IsAnySystemTablePermissions();
}
/// <summary>
/// 檢測表是否存在
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="isCache">是否緩存</param>
/// <returns>值</returns>
public bool IsAnyTable(string tableName, bool isCache = true)
{
return DbContext.DbMaintenance.IsAnyTable(tableName, isCache);
}
/// <summary>
/// 檢測列是否自增列
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="column">列名</param>
/// <returns>值</returns>
public bool IsIdentity(string tableName, string column)
{
return DbContext.DbMaintenance.IsIdentity(tableName, column);
}
/// <summary>
/// 檢測列是否主鍵
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="column">列名</param>
/// <returns>值</returns>
public bool IsPrimaryKey(string tableName, string column)
{
return DbContext.DbMaintenance.IsPrimaryKey(tableName, column);
}
/// <summary>
/// 重置列名
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="oldColumnName">舊列名</param>
/// <param name="newColumnName">新列名</param>
/// <returns>值</returns>
public bool RenameColumn(string tableName, string oldColumnName, string newColumnName)
{
return DbContext.DbMaintenance.RenameColumn(tableName, oldColumnName, newColumnName);
}
/// <summary>
/// 重置表數據
/// </summary>
/// <param name="tableName">表名</param>
/// <returns>值</returns>
public bool TruncateTable(string tableName)
{
return DbContext.DbMaintenance.TruncateTable(tableName);
}
/// <summary>
/// 修改列信息
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="column">列信息</param>
/// <returns>值</returns>
public bool UpdateColumn(string tableName, DbColumnInfo column)
{
return DbContext.DbMaintenance.UpdateColumn(tableName, column);
}
/// <summary>
/// 獲取數據庫時間
/// </summary>
/// <returns>返回值</returns>
public DateTime GetDataBaseTime()
{
return DbContext.GetDate();
}
#endregion
#region 新增
/// <summary>
/// 新增
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entity"> 實體對象 </param>
/// <returns>操作影響的行數</returns>
public int Add<T>(T entity) where T : class, new()
{
try
{
var result = DbContext.Insertable(entity).ExecuteCommand();
return result;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 新增
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entitys">泛型集合</param>
/// <returns>操作影響的行數</returns>
public int Add<T>(List<T> entitys) where T : class, new()
{
try
{
var result = DbContext.Insertable(entitys).ExecuteCommand();
return result;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 新增
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="keyValues">字典集合（Key:列名 Value:值）</param>
/// <returns>操作影響的行數</returns>
public int Add<T>(Dictionary<string, object> keyValues) where T : class, new()
{
try
{
var result = DbContext.Insertable<T>(keyValues).ExecuteCommand();
return result;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 新增
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entity"> 實體對象 </param>
/// <returns>返回實體</returns>
public T AddReturnEntity<T>(T entity) where T : class, new()
{
try
{
var result = DbContext.Insertable(entity).ExecuteReturnEntity();
return result;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 新增
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entity"> 實體對象 </param>
/// <returns>返回自增列</returns>
public int AddReturnIdentity<T>(T entity) where T : class, new()
{
try
{
var result = DbContext.Insertable(entity).ExecuteReturnIdentity();
return result;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 新增
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entity"> 實體對象 </param>
/// <returns>返回bool</returns>
public bool AddReturnBool<T>(T entity) where T : class, new()
{
try
{
var result = DbContext.Insertable(entity).ExecuteCommand()>0;
return result;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 新增
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entitys">泛型集合</param>
/// <returns>返回bool</returns>
public bool AddReturnBool<T>(List<T> entitys) where T : class, new()
{
try
{
var result = DbContext.Insertable(entitys).ExecuteCommand() > 0;
return result;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
#endregion
#region 修改
/// <summary>
/// 修改（主鍵是更新條件）
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entity"> 實體對象（必須指定主鍵特性 [SugarColumn(IsPrimaryKey=true)]），如果是聯合主鍵，請使用Where條件 </param>
/// <param name="lstIgnoreColumns">不更新的列</param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
public int Update<T>(T entity, List<string> lstIgnoreColumns = null, bool isLock = true) where T : class, new()
{
try
{
IUpdateable<T> up = DbContext.Updateable(entity);
if (lstIgnoreColumns != null && lstIgnoreColumns.Count > 0)
{
up = up.IgnoreColumns(lstIgnoreColumns.Contains);
}
if (isLock)
{
up = up.With(SqlWith.UpdLock);
}
var result = up.ExecuteCommand();
return result;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 修改（主鍵是更新條件）
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entitys"> 實體對象集合（必須指定主鍵特性 [SugarColumn(IsPrimaryKey=true)]），如果是聯合主鍵，請使用Where條件 </param>
/// <param name="lstIgnoreColumns">不更新的列</param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
public int Update<T>(List<T> entitys, List<string> lstIgnoreColumns = null, bool isLock = true) where T : class, new()
{
try
{
IUpdateable<T> up = DbContext.Updateable(entitys);
if (lstIgnoreColumns != null && lstIgnoreColumns.Count > 0)
{
up = up.IgnoreColumns(lstIgnoreColumns.Contains);
}
if (isLock)
{
up = up.With(SqlWith.UpdLock);
}
var result = up.ExecuteCommand();
return result;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 修改
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entity"> 實體對象 </param>
/// <param name="where"> 條件 </param>
/// <param name="lstIgnoreColumns">不更新的列</param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
public int Update<T>(T entity, Expression<Func<T, bool>> where, List<string> lstIgnoreColumns = null, bool isLock = true) where T : class, new()
{
try
{
IUpdateable<T> up = DbContext.Updateable(entity);
if (lstIgnoreColumns != null && lstIgnoreColumns.Count > 0)
{
up = up.IgnoreColumns(lstIgnoreColumns.Contains);
}
up = up.Where(where);
if (isLock)
{
up = up.With(SqlWith.UpdLock);
}
var result = up.ExecuteCommand();
return result;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 修改
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="update"> 實體對象 </param>
/// <param name="where"> 條件 </param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
public int Update<T>(Expression<Func<T, T>> update, Expression<Func<T, bool>> where=null, bool isLock = true) where T : class, new()
{
try
{
IUpdateable<T> up = DbContext.Updateable<T>().UpdateColumns(update);
if (where != null)
{
up = up.Where(where);
}
if (isLock)
{
up = up.With(SqlWith.UpdLock);
}
var result = up.ExecuteCommand();
return result;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 修改
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="keyValues">字典集合（Key:列名 Value:值）</param>
/// <param name="where"> 條件 </param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
public int Update<T>(Dictionary<string, object> keyValues, Expression<Func<T, bool>> where = null, bool isLock = true) where T : class, new()
{
try
{
IUpdateable<T> up = DbContext.Updateable<T>(keyValues);
if (where != null)
{
up = up.Where(where);
}
if (isLock)
{
up = up.With(SqlWith.UpdLock);
}
var result = up.ExecuteCommand();
return result;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 批量修改需要更新的列
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entitys"> 實體對象（必須指定主鍵特性 [SugarColumn(IsPrimaryKey=true)]），如果是聯合主鍵，請使用Where條件 </param>
/// <param name="updateColumns">更新指定列</param>
/// <param name="wherecolumns">條件(爲空則以主鍵更新,反之需要把wherecolumns中的列加到UpdateColumns中)</param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
public int UpdateColumns<T>(List<T> entitys, Expression<Func<T, object>> updateColumns, Expression<Func<T, object>> wherecolumns = null, bool isLock = true) where T : class, new()
{
try
{
IUpdateable<T> up = DbContext.Updateable(entitys).UpdateColumns(updateColumns);
if (wherecolumns != null)
{
up = up.WhereColumns(wherecolumns);
}
if (isLock)
{
up = up.With(SqlWith.UpdLock);
}
var result = up.ExecuteCommand();
return result;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 修改 通過RowVer及主鍵Code 更新
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entity"> 實體對象 </param>
/// <param name="lstIgnoreColumns">不更新的列</param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
public int UpdateRowVer<T>(T entity, List<string> lstIgnoreColumns = null, bool isLock = true) where T : class, new()
{
try
{
Type ts = entity.GetType();
var rowVerProperty = ts.GetProperty("RowVer");
if (rowVerProperty == null)
{
throw new Exception("Column RowVer Not Exist");
}
if (rowVerProperty.GetValue(entity, null) == null)
{
throw new Exception("RowVer Value Is Null");
}
var codeProperty = ts.GetProperty("Code");
if (codeProperty == null)
{
throw new Exception("Column Code Not Exist");
}
if (codeProperty.GetValue(entity, null) == null)
{
throw new Exception("Code Value Is Null");
}
var rowVerValue = int.Parse(rowVerProperty.GetValue(entity, null).ToString());
var codeValue = codeProperty.GetValue(entity, null).ToString();
var sqlWhere = $" RowVer={rowVerValue} AND Code='{codeValue}'";
rowVerProperty.SetValue(entity, rowVerValue + 1, null);
IUpdateable<T> up = DbContext.Updateable(entity);
if (lstIgnoreColumns != null && lstIgnoreColumns.Count > 0)
{
up = up.IgnoreColumns(lstIgnoreColumns.Contains);
}
up = up.Where(sqlWhere);
if (isLock)
{
up = up.With(SqlWith.UpdLock);
}
var result = up.ExecuteCommand();
return result;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 修改
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="update"> 實體對象 </param>
/// <param name="where"> 更新條件 </param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
public int UpdateRowVer<T>(Expression<Func<T, T>> update, Dictionary<string, object> where, bool isLock = true) where T : class, new()
{
try
{
if (!where.ContainsKey("RowVer"))
{
throw new Exception("Column RowVer Not Exist");
}
if (where["RowVer"] == null)
{
throw new Exception("RowVer Value Is Null");
}
if (update.Body.ToString().IndexOf("RowVer", StringComparison.Ordinal)==-1)
{
throw new Exception("Column RowVer Update Is Null");
}
var sqlWhere = "";
foreach (var item in where)
{
sqlWhere +=string.IsNullOrWhiteSpace(sqlWhere)? $" {item.Key}='{item.Value}'" : $" and {item.Key}='{item.Value}'";
}
IUpdateable<T> up = DbContext.Updateable<T>().UpdateColumns(update).Where(sqlWhere);
if (isLock)
{
up = up.With(SqlWith.UpdLock);
}
var result = up.ExecuteCommand();
return result;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
#endregion
#region 刪除
/// <summary>
/// 刪除
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="primaryKeyValues">主鍵值</param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
public int DeleteByPrimary<T>(List<object> primaryKeyValues, bool isLock = true) where T : class, new()
{
try
{
var result = isLock ?
DbContext.Deleteable<T>().In(primaryKeyValues).With(SqlWith.RowLock).ExecuteCommand()
: DbContext.Deleteable<T>().In(primaryKeyValues).ExecuteCommand();
return result;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 刪除
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entity"> 實體對象 （必須指定主鍵特性 [SugarColumn(IsPrimaryKey=true)]），如果是聯合主鍵，請使用Where條件</param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
public int Delete<T>(T entity, bool isLock = true) where T : class, new()
{
try
{
var result = isLock ?
DbContext.Deleteable(entity).With(SqlWith.RowLock).ExecuteCommand()
: DbContext.Deleteable(entity).ExecuteCommand();
return result;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 刪除
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="entity"> 實體對象 （必須指定主鍵特性 [SugarColumn(IsPrimaryKey=true)]），如果是聯合主鍵，請使用Where條件</param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
public int Delete<T>(List<T> entity, bool isLock = true) where T : class, new()
{
try
{
var result = isLock ?
DbContext.Deleteable(entity).With(SqlWith.RowLock).ExecuteCommand()
: DbContext.Deleteable(entity).ExecuteCommand();
return result;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 刪除
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="where"> 條件 </param>
/// <param name="isLock"> 是否加鎖 </param>
/// <returns>操作影響的行數</returns>
public int Delete<T>(Expression<Func<T, bool>> where, bool isLock = true) where T : class, new()
{
try
{
var result = isLock ?
DbContext.Deleteable<T>().Where(where).With(SqlWith.RowLock).ExecuteCommand()
: DbContext.Deleteable<T>().Where(where).ExecuteCommand();
return result;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 通過多值(主鍵)刪除數據集
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="inValues">數據集合</param>
/// <returns>值</returns>
public int DeleteIn<T>(List<dynamic> inValues) where T : class, new()
{
return DbContext.Deleteable<T>().With(SqlWith.RowLock).In(inValues).ExecuteCommand();
}
#endregion
#region 查詢
#region 數據源
///// <summary>
///// 查詢數據源
///// </summary>
///// <typeparam name="T">泛型參數(集合成員的類型</typeparam>
///// <returns>數據源</returns>
//public ISugarQueryable<T> Queryable<T>() where T : class, new()
//{
// return DbContext.Queryable<T>();
//}
#endregion
#region 多表查詢
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (t1,t2) => new object[] {JoinType.Left,t1.UserNo==t2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (t1, t2) => new { Id =t1.UserNo, Id1 = t2.UserNo}</param>
/// <param name="whereLambda">查詢表達式 (t1, t2) =>t1.UserNo == "")</param>
/// <returns>值</returns>
public List<TResult> QueryMuch<T, T2, TResult>(
Expression<Func<T, T2, object[]>> joinExpression,
Expression<Func<T, T2, TResult>> selectExpression,
Expression<Func<T, T2, bool>> whereLambda = null) where T : class, new()
{
if (whereLambda == null)
{
return DbContext.Queryable(joinExpression).Select(selectExpression).ToList();
}
return DbContext.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).ToList();
}
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="whereLambda">查詢表達式 (w1, w2) =>w1.UserNo == "")</param>
/// <returns>值</returns>
public List<TResult> QueryMuch<T, T2, T3, TResult>(
Expression<Func<T, T2, T3, object[]>> joinExpression,
Expression<Func<T, T2, T3, TResult>> selectExpression,
Expression<Func<T, T2, T3, bool>> whereLambda = null) where T : class, new()
{
if (whereLambda == null)
{
return DbContext.Queryable(joinExpression).Select(selectExpression).ToList();
}
return DbContext.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).ToList();
}
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="whereLambda">查詢表達式 (w1, w2) =>w1.UserNo == "")</param>
/// <returns>值</returns>
public List<TResult> QueryMuch<T, T2, T3, T4, TResult>(
Expression<Func<T, T2, T3, T4, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, TResult>> selectExpression,
Expression<Func<T, T2, T3, T4, bool>> whereLambda = null) where T : class, new()
{
if (whereLambda == null)
{
return DbContext.Queryable(joinExpression).Select(selectExpression).ToList();
}
return DbContext.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).ToList();
}
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="whereLambda">查詢表達式 (w1, w2) =>w1.UserNo == "")</param>
/// <returns>值</returns>
public List<TResult> QueryMuch<T, T2, T3, T4, T5, TResult>(
Expression<Func<T, T2, T3, T4, T5,object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5,TResult>> selectExpression,
Expression<Func<T, T2, T3, T4, T5, bool>> whereLambda = null) where T : class, new()
{
if (whereLambda == null)
{
return DbContext.Queryable(joinExpression).Select(selectExpression).ToList();
}
return DbContext.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).ToList();
}
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="T6">實體6</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="whereLambda">查詢表達式 (w1, w2) =>w1.UserNo == "")</param>
/// <returns>值</returns>
public List<TResult> QueryMuch<T, T2, T3, T4, T5,T6, TResult>(
Expression<Func<T, T2, T3, T4, T5, T6, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5, T6, TResult>> selectExpression,
Expression<Func<T, T2, T3, T4, T5, T6, bool>> whereLambda = null) where T : class, new()
{
if (whereLambda == null)
{
return DbContext.Queryable(joinExpression).Select(selectExpression).ToList();
}
return DbContext.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).ToList();
}
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="T6">實體6</typeparam>
/// <typeparam name="T7">實體7</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="whereLambda">查詢表達式 (w1, w2) =>w1.UserNo == "")</param>
/// <returns>值</returns>
public List<TResult> QueryMuch<T, T2, T3, T4, T5, T6, T7, TResult>(
Expression<Func<T, T2, T3, T4, T5, T6, T7, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5, T6, T7, TResult>> selectExpression,
Expression<Func<T, T2, T3, T4, T5, T6, T7, bool>> whereLambda = null) where T : class, new()
{
if (whereLambda == null)
{
return DbContext.Queryable(joinExpression).Select(selectExpression).ToList();
}
return DbContext.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).ToList();
}
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="T6">實體6</typeparam>
/// <typeparam name="T7">實體7</typeparam>
/// <typeparam name="T8">實體8</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="whereLambda">查詢表達式 (w1, w2) =>w1.UserNo == "")</param>
/// <returns>值</returns>
public List<TResult> QueryMuch<T, T2, T3, T4, T5, T6, T7, T8, TResult>(
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, TResult>> selectExpression,
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, bool>> whereLambda = null) where T : class, new()
{
if (whereLambda == null)
{
return DbContext.Queryable(joinExpression).Select(selectExpression).ToList();
}
return DbContext.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).ToList();
}
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="T6">實體6</typeparam>
/// <typeparam name="T7">實體7</typeparam>
/// <typeparam name="T8">實體8</typeparam>
/// <typeparam name="T9">實體9</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="whereLambda">查詢表達式 (w1, w2) =>w1.UserNo == "")</param>
/// <returns>值</returns>
public List<TResult> QueryMuch<T, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, TResult>> selectExpression,
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, bool>> whereLambda = null) where T : class, new()
{
if (whereLambda == null)
{
return DbContext.Queryable(joinExpression).Select(selectExpression).ToList();
}
return DbContext.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).ToList();
}
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (t1,t2) => new object[] {JoinType.Left,t1.UserNo==t2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (t1, t2) => new { Id =t1.UserNo, Id1 = t2.UserNo}</param>
/// <param name="query">查詢條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>值</returns>
public List<TResult> QueryMuchDescriptor<T, T2, TResult>(
Expression<Func<T, T2, object[]>> joinExpression,
Expression<Func<T, T2, TResult>> selectExpression,
QueryDescriptor query, out int totalCount) where T : class, new()
{
var up = DbContext.Queryable(joinExpression).Select(selectExpression).MergeTable();
if (query.Conditions != null)
{
var conds = ParseCondition(query.Conditions);
up = up.Where(conds);
}
if (query.OrderBys != null)
{
var orderBys = ParseOrderBy(query.OrderBys);
up = up.OrderBy(orderBys);
}
totalCount = 0;
if (query.PageSize == 0)
{
var datas = up.ToList();
totalCount = datas.Count;
return datas;
}
else
{
var datas = up.ToPageList(query.PageIndex, query.PageSize, ref totalCount);
return datas;
}
}
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="query">查詢條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>值</returns>
public List<TResult> QueryMuchDescriptor<T, T2, T3, TResult>(
Expression<Func<T, T2, T3, object[]>> joinExpression,
Expression<Func<T, T2, T3, TResult>> selectExpression,
QueryDescriptor query, out int totalCount) where T : class, new()
{
var up = DbContext.Queryable(joinExpression).Select(selectExpression).MergeTable();
if (query.Conditions != null)
{
var conds = ParseCondition(query.Conditions);
up = up.Where(conds);
}
if (query.OrderBys != null)
{
var orderBys = ParseOrderBy(query.OrderBys);
up = up.OrderBy(orderBys);
}
totalCount = 0;
if (query.PageSize == 0)
{
var datas = up.ToList();
totalCount = datas.Count;
return datas;
}
else
{
var datas = up.ToPageList(query.PageIndex, query.PageSize, ref totalCount);
return datas;
}
}
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="query">查詢條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>值</returns>
public List<TResult> QueryMuchDescriptor<T, T2, T3, T4, TResult>(
Expression<Func<T, T2, T3, T4, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, TResult>> selectExpression,
QueryDescriptor query, out int totalCount) where T : class, new()
{
var up = DbContext.Queryable(joinExpression).Select(selectExpression).MergeTable();
if (query.Conditions != null)
{
var conds = ParseCondition(query.Conditions);
up = up.Where(conds);
}
if (query.OrderBys != null)
{
var orderBys = ParseOrderBy(query.OrderBys);
up = up.OrderBy(orderBys);
}
totalCount = 0;
if (query.PageSize == 0)
{
var datas = up.ToList();
totalCount = datas.Count;
return datas;
}
else
{
var datas = up.ToPageList(query.PageIndex, query.PageSize, ref totalCount);
return datas;
}
}
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="query">查詢條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>值</returns>
public List<TResult> QueryMuchDescriptor<T, T2, T3, T4, T5, TResult>(
Expression<Func<T, T2, T3, T4, T5, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5, TResult>> selectExpression,
QueryDescriptor query, out int totalCount) where T : class, new()
{
var up = DbContext.Queryable(joinExpression).Select(selectExpression).MergeTable();
if (query.Conditions != null)
{
var conds = ParseCondition(query.Conditions);
up = up.Where(conds);
}
if (query.OrderBys != null)
{
var orderBys = ParseOrderBy(query.OrderBys);
up = up.OrderBy(orderBys);
}
totalCount = 0;
if (query.PageSize == 0)
{
var datas = up.ToList();
totalCount = datas.Count;
return datas;
}
else
{
var datas = up.ToPageList(query.PageIndex, query.PageSize, ref totalCount);
return datas;
}
}
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="T6">實體6</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="query">查詢條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>值</returns>
public List<TResult> QueryMuchDescriptor<T, T2, T3, T4, T5, T6, TResult>(
Expression<Func<T, T2, T3, T4, T5, T6, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5, T6, TResult>> selectExpression,
QueryDescriptor query, out int totalCount) where T : class, new()
{
var up = DbContext.Queryable(joinExpression).Select(selectExpression).MergeTable();
if (query.Conditions != null)
{
var conds = ParseCondition(query.Conditions);
up = up.Where(conds);
}
if (query.OrderBys != null)
{
var orderBys = ParseOrderBy(query.OrderBys);
up = up.OrderBy(orderBys);
}
totalCount = 0;
if (query.PageSize == 0)
{
var datas = up.ToList();
totalCount = datas.Count;
return datas;
}
else
{
var datas = up.ToPageList(query.PageIndex, query.PageSize, ref totalCount);
return datas;
}
}
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="T6">實體6</typeparam>
/// <typeparam name="T7">實體7</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="query">查詢條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>值</returns>
public List<TResult> QueryMuchDescriptor<T, T2, T3, T4, T5, T6, T7, TResult>(
Expression<Func<T, T2, T3, T4, T5, T6, T7, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5, T6, T7, TResult>> selectExpression,
QueryDescriptor query, out int totalCount) where T : class, new()
{
var up = DbContext.Queryable(joinExpression).Select(selectExpression).MergeTable();
if (query.Conditions != null)
{
var conds = ParseCondition(query.Conditions);
up = up.Where(conds);
}
if (query.OrderBys != null)
{
var orderBys = ParseOrderBy(query.OrderBys);
up = up.OrderBy(orderBys);
}
totalCount = 0;
if (query.PageSize == 0)
{
var datas = up.ToList();
totalCount = datas.Count;
return datas;
}
else
{
var datas = up.ToPageList(query.PageIndex, query.PageSize, ref totalCount);
return datas;
}
}
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="T6">實體6</typeparam>
/// <typeparam name="T7">實體7</typeparam>
/// <typeparam name="T8">實體8</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="query">查詢條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>值</returns>
public List<TResult> QueryMuchDescriptor<T, T2, T3, T4, T5, T6, T7, T8, TResult>(
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, TResult>> selectExpression,
QueryDescriptor query, out int totalCount) where T : class, new()
{
var up = DbContext.Queryable(joinExpression).Select(selectExpression).MergeTable();
if (query.Conditions != null)
{
var conds = ParseCondition(query.Conditions);
up = up.Where(conds);
}
if (query.OrderBys != null)
{
var orderBys = ParseOrderBy(query.OrderBys);
up = up.OrderBy(orderBys);
}
totalCount = 0;
if (query.PageSize == 0)
{
var datas = up.ToList();
totalCount = datas.Count;
return datas;
}
else
{
var datas = up.ToPageList(query.PageIndex, query.PageSize, ref totalCount);
return datas;
}
}
/// <summary>
///查詢-多表查詢
/// </summary>
/// <typeparam name="T">實體1</typeparam>
/// <typeparam name="T2">實體2</typeparam>
/// <typeparam name="T3">實體3</typeparam>
/// <typeparam name="T4">實體4</typeparam>
/// <typeparam name="T5">實體5</typeparam>
/// <typeparam name="T6">實體6</typeparam>
/// <typeparam name="T7">實體7</typeparam>
/// <typeparam name="T8">實體8</typeparam>
/// <typeparam name="T9">實體9</typeparam>
/// <typeparam name="TResult">返回對象</typeparam>
/// <param name="joinExpression">關聯表達式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表達式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="query">查詢條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>值</returns>
public List<TResult> QueryMuchDescriptor<T, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, object[]>> joinExpression,
Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, TResult>> selectExpression,
QueryDescriptor query, out int totalCount) where T : class, new()
{
var up = DbContext.Queryable(joinExpression).Select(selectExpression).MergeTable();
if (query.Conditions != null)
{
var conds = ParseCondition(query.Conditions);
up = up.Where(conds);
}
if (query.OrderBys != null)
{
var orderBys = ParseOrderBy(query.OrderBys);
up = up.OrderBy(orderBys);
}
totalCount = 0;
if (query.PageSize == 0)
{
var datas = up.ToList();
totalCount = datas.Count;
return datas;
}
else
{
var datas = up.ToPageList(query.PageIndex, query.PageSize, ref totalCount);
return datas;
}
}
#endregion
#region 查詢
/// <summary>
/// 查詢-返回自定義數據
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <typeparam name="TResult">返回值類型</typeparam>
/// <param name="expression">返回值表達式</param>
/// <param name="whereLambda">查詢表達式</param>
/// <returns>值</returns>
public TResult QuerySelect<T,TResult>( Expression<Func<T, TResult>> expression,Expression<Func<T, bool>> whereLambda = null) where T : class, new()
{
var datas = DbContext.Queryable<T>().With(SqlWith.NoLock).Where(whereLambda).Select(expression).First();
return datas;
}
/// <summary>
/// 查詢-返回自定義數據
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <typeparam name="TResult">返回值類型</typeparam>
/// <param name="expression">返回值表達式</param>
/// <param name="whereLambda">查詢表達式</param>
/// <returns>值</returns>
public List<TResult> QuerySelectList<T, TResult>(Expression<Func<T, TResult>> expression, Expression<Func<T, bool>> whereLambda = null) where T : class, new()
{
var datas = DbContext.Queryable<T>().With(SqlWith.NoLock).Where(whereLambda).Select(expression).ToList();
return datas;
}
/// <summary>
/// 查詢
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="whereLambda">查詢表達式</param>
/// <returns>值</returns>
public T Query<T>(Expression<Func<T, bool>> whereLambda = null) where T : class, new()
{
ISugarQueryable<T> up = DbContext.Queryable<T>().With(SqlWith.NoLock);
if (whereLambda != null)
{
up = up.Where(whereLambda);
}
return up.First();
}
/// <summary>
/// 查詢集合
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="whereLambda">過濾條件</param>
/// <returns>實體</returns>
public List<T> QueryWhereList<T>(Expression<Func<T, bool>> whereLambda = null) where T : class, new()
{
ISugarQueryable<T> up = DbContext.Queryable<T>().With(SqlWith.NoLock);
if (whereLambda != null)
{
up = up.Where(whereLambda);
}
return up.ToList();
}
/// <summary>
/// 查詢集合
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="query">過濾條件</param>
/// <returns>實體</returns>
public List<T> QueryList<T>(QueryDescriptor query=null) where T : class, new()
{
ISugarQueryable<T> up = DbContext.Queryable<T>().With(SqlWith.NoLock);
if (query != null)
{
if (query.Conditions != null)
{
var conds = ParseCondition(query.Conditions);
up = up.Where(conds);
}
if (query.OrderBys != null)
{
var orderBys = ParseOrderBy(query.OrderBys);
up = up.OrderBy(orderBys);
}
}
return up.ToList();
}
/// <summary>
/// 查詢集合
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="sql">sql</param>
/// <returns>實體</returns>
public List<T> QuerySqlList<T>(string sql) where T : class, new()
{
return DbContext.SqlQueryable<T>(sql).ToList();
}
/// <summary>
/// 分頁查詢
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="query">過濾條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>實體</returns>
public List<T> QueryPageList<T>(QueryDescriptor query, out int totalCount) where T : class, new()
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
var listDatas = DbContext.Queryable<T>();
if (query.Conditions != null)
{
var conds = ParseCondition(query.Conditions);
listDatas = listDatas.Where(conds);
}
if (query.OrderBys != null)
{
var orderBys = ParseOrderBy(query.OrderBys);
listDatas = listDatas.OrderBy(orderBys);
}
totalCount = 0;
if (query.PageSize == 0)
{
var datas = listDatas.ToList();
totalCount = datas.Count;
return datas;
}
else
{
var datas = listDatas.ToPageList(query.PageIndex, query.PageSize, ref totalCount);
return datas;
}
}
/// <summary>
/// 查詢集合-多值
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="inFieldName">字段名</param>
/// <param name="inValues">數據集合</param>
/// <returns>值</returns>
public List<T> In<T>(string inFieldName, List<dynamic> inValues) where T : class, new()
{
return DbContext.Queryable<T>().In(inFieldName, inValues).ToList();
}
/// <summary>
/// 查詢集合-通過多值(主鍵)
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="values">主鍵數據集合</param>
/// <returns>值</returns>
public List<T> In<T>(List<dynamic> values) where T : class, new()
{
return DbContext.Queryable<T>().In(values).ToList();
}
/// <summary>
/// 查詢集合
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="whereLambda">查詢表達式</param>
/// <returns>實體</returns>
public DataTable QueryDataTable<T>(Expression<Func<T, bool>> whereLambda = null) where T : class, new()
{
ISugarQueryable<T> up = DbContext.Queryable<T>().With(SqlWith.NoLock);
if (whereLambda != null)
{
up = up.Where(whereLambda);
}
return up.ToDataTable();
}
/// <summary>
/// 查詢集合
/// </summary>
/// <param name="sql">sql</param>
/// <returns>實體</returns>
public DataTable QueryDataTable(string sql)
{
return DbContext.Ado.GetDataTable(sql);
}
/// <summary>
/// 查詢單個值
/// </summary>
/// <param name="sql">sql</param>
/// <returns>單個值</returns>
public object QuerySqlScalar(string sql)
{
return DbContext.Ado.GetScalar(sql);
}
/// <summary>
/// 分頁查詢
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="query">過濾條件</param>
/// <param name="totalCount">總行數</param>
/// <returns>DataTable</returns>
public DataTable QueryDataTablePageList<T>(QueryDescriptor query, out int totalCount) where T : class, new()
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
var listDatas = DbContext.Queryable<T>();
if (query.Conditions != null)
{
var conds = ParseCondition(query.Conditions);
listDatas = listDatas.Where(conds);
}
if (query.OrderBys != null)
{
var orderBys = ParseOrderBy(query.OrderBys);
listDatas = listDatas.OrderBy(orderBys);
}
totalCount = 0;
var datas = listDatas.ToDataTablePage(query.PageIndex, query.PageSize, ref totalCount);
return datas;
}
#endregion
#region Mapper
/// <summary>
/// Mapper查詢 一對多和一對一
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="mapperAction">操作(it, cache) =>
/// {
/// var all = cache.GetListByPrimaryKeys(vmodel => vmodel.Id); //一次性查詢出所要的外鍵引用數據
/// it.School = all.FirstOrDefault(i => i.Id == it.Id); //一對一
/// it.Schools = all.Where(i => i.Id == it.Id).ToList(); //一對多
/// /*用C#處理你想要的結果*/
/// it.Name = it.Name == null ? "null" : it.Name;
/// }
/// </param>
/// <param name="query">過濾條件</param>
/// <returns></returns>
public List<T> QueryMapper<T>(Action<T> mapperAction,QueryDescriptor query = null) where T : class, new()
{
ISugarQueryable<T> up = DbContext.Queryable<T>();
if (query != null)
{
if (query.Conditions != null)
{
var conds = ParseCondition(query.Conditions);
up = up.Where(conds);
}
if (query.OrderBys != null)
{
var orderBys = ParseOrderBy(query.OrderBys);
up = up.OrderBy(orderBys);
}
}
var datas = up.Mapper(mapperAction).ToList();
return datas;
}
/// <summary>
/// Mapper查詢 一對多和一對一
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="mapperAction">操作(it, cache) =>
/// {
/// var all = cache.GetListByPrimaryKeys(vmodel => vmodel.Id); //一次性查詢出所要的外鍵引用數據
/// it.School = all.FirstOrDefault(i => i.Id == it.Id); //一對一
/// it.Schools = all.Where(i => i.Id == it.Id).ToList(); //一對多
/// /*用C#處理你想要的結果*/
/// it.Name = it.Name == null ? "null" : it.Name;
/// }
/// </param>
/// <param name="whereLambda">過濾條件</param>
/// <returns></returns>
public List<T> QueryMapper<T>(Action<T> mapperAction, Expression<Func<T, bool>> whereLambda = null) where T : class, new()
{
ISugarQueryable<T> up = DbContext.Queryable<T>();
if (whereLambda != null)
{
up = up.Where(whereLambda);
}
var datas = up.Mapper(mapperAction).ToList();
return datas;
}
#endregion
#region 分組
/// <summary>
/// 分組
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="groupByLambda">分組表達式</param>
/// <param name="whereLambda">查詢表達式</param>
/// <returns>值</returns>
public List<T> GroupBy<T>(Expression<Func<T, object>> groupByLambda, Expression<Func<T, bool>> whereLambda = null) where T : class, new()
{
var datas = DbContext.Queryable<T>().With(SqlWith.NoLock).Where(whereLambda).GroupBy(groupByLambda).ToList();
return datas;
}
/// <summary>
/// 分組-返回自定義數據
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <typeparam name="TResult">返回值類型</typeparam>
/// <param name="expression">返回值表達式</param>
/// <param name="groupByLambda">分組表達式</param>
/// <param name="whereLambda">查詢表達式</param>
/// <returns>值</returns>
public List<TResult> GroupBy<T, TResult>(Expression<Func<T, TResult>> expression, Expression<Func<T, object>> groupByLambda, Expression<Func<T, bool>> whereLambda = null) where T : class, new()
{
var datas = DbContext.Queryable<T>().With(SqlWith.NoLock).Where(whereLambda).GroupBy(groupByLambda).Select(expression).ToList();
return datas;
}
#endregion
#region 存儲過程
/// <summary>
/// 查詢存儲過程
/// </summary>
/// <param name="procedureName">存儲過程名稱</param>
/// <param name="parameters">參數</param>
/// <returns>DataSet</returns>
public DataSet QueryProcedureDataSet(string procedureName, List<SqlParameter> parameters)
{
var listParams = new List<SugarParameter>();
foreach (var p in parameters)
{
listParams.Add(new SugarParameter(p.ParameterName, p.Value, null, p.Direction));
}
var datas = DbContext.Ado.UseStoredProcedure().GetDataSetAll(procedureName, listParams);
return datas;
}
/// <summary>
/// 查詢存儲過程
/// </summary>
/// <param name="procedureName">存儲過程名稱</param>
/// <param name="parameters">參數</param>
/// <returns>DataTable</returns>
public DataTable QueryProcedure(string procedureName, List<SqlParameter> parameters)
{
var listParams = new List<SugarParameter>();
foreach (var p in parameters)
{
listParams.Add(new SugarParameter(p.ParameterName,p.Value,null,p.Direction));
}
var datas = DbContext.Ado.UseStoredProcedure().GetDataTable(procedureName, listParams);
return datas;
}
/// <summary>
/// 查詢存儲過程
/// </summary>
/// <param name="procedureName">存儲過程名稱</param>
/// <param name="parameters">參數</param>
/// <returns>單個值</returns>
public object QueryProcedureScalar(string procedureName, List<SqlParameter> parameters)
{
var listParams = new List<SugarParameter>();
foreach (var p in parameters)
{
listParams.Add(new SugarParameter(p.ParameterName, p.Value, null, p.Direction));
}
var datas = DbContext.Ado.UseStoredProcedure().GetScalar(procedureName, listParams);
return datas;
}
#endregion
#region Json
/// <summary>
/// 查詢集合
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型)</typeparam>
/// <param name="whereLambda">查詢表達式</param>
/// <returns>Json</returns>
public string QueryJson<T>(Expression<Func<T, bool>> whereLambda = null) where T : class, new()
{
ISugarQueryable<T> up = DbContext.Queryable<T>().With(SqlWith.NoLock);
if (whereLambda != null)
{
up = up.Where(whereLambda);
}
return up.ToJson();
}
#endregion
#region 其它
/// <summary>
/// 查詢前多少條數據
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型</typeparam>
/// <param name="whereLambda">查詢表達式</param>
/// <param name="num">數量</param>
/// <returns>值</returns>
public List<T> Take<T>(Expression<Func<T, bool>> whereLambda, int num) where T : class, new()
{
var datas = DbContext.Queryable<T>().With(SqlWith.NoLock).Where(whereLambda).Take(num).ToList();
return datas;
}
/// <summary>
/// 查詢單條數據
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型</typeparam>
/// <param name="whereLambda">查詢表達式</param>
/// <returns>值</returns>
public T First<T>(Expression<Func<T, bool>> whereLambda) where T : class, new()
{
var datas = DbContext.Queryable<T>().With(SqlWith.NoLock).Where(whereLambda).First();
return datas;
}
/// <summary>
/// 是否存在
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型</typeparam>
/// <param name="whereLambda">查詢表達式</param>
/// <returns>值</returns>
public bool IsExist<T>(Expression<Func<T, bool>> whereLambda) where T : class, new()
{
var datas = DbContext.Queryable<T>().Any(whereLambda);
return datas;
}
/// <summary>
/// 合計
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型</typeparam>
/// <param name="field">字段</param>
/// <returns>值</returns>
public int Sum<T>(string field) where T : class, new()
{
var datas = DbContext.Queryable<T>().Sum<int>(field);
return datas;
}
/// <summary>
/// 最大值
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型</typeparam>
/// <typeparam name="TResult">返回類型</typeparam>
/// <param name="field">字段</param>
/// <returns>值</returns>
public TResult Max<T, TResult>(string field) where T : class, new()
{
var datas = DbContext.Queryable<T>().Max<TResult>(field);
return datas;
}
/// <summary>
/// 最小值
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型</typeparam>
/// <typeparam name="TResult">返回類型</typeparam>
/// <param name="field">字段</param>
/// <returns>值</returns>
public TResult Min<T, TResult>(string field) where T : class, new()
{
var datas = DbContext.Queryable<T>().Min<TResult>(field);
return datas;
}
/// <summary>
/// 平均值
/// </summary>
/// <typeparam name="T">泛型參數(集合成員的類型</typeparam>
/// <param name="field">字段</param>
/// <returns>值</returns>
public int Avg<T>(string field) where T : class, new()
{
var datas = DbContext.Queryable<T>().Avg<int>(field);
return datas;
}
/// <summary>
/// 生成流水號
/// </summary>
/// <param name="key">列名</param>
/// <param name="prefix">前綴</param>
/// <param name="fixedLength">流水號長度</param>
/// <param name="dateFomart">日期格式(yyyyMMdd) 爲空前綴後不加日期,反之加</param>
/// <returns></returns>
public string CustomNumber<T>(string key, string prefix = "", int fixedLength = 4, string dateFomart = "") where T : class, new()
{
var listNumber = CustomNumber<T>(key, 1,prefix, fixedLength, dateFomart);
return listNumber[0];
}
/// <summary>
/// 生成流水號
/// </summary>
/// <param name="key">列名</param>
/// <param name="prefix">前綴</param>
/// <param name="fixedLength">流水號長度</param>
/// <param name="dateFomart">日期格式(yyyyMMdd) 爲空前綴後不加日期,反之加</param>
/// <param name="num">數量</param>
/// <returns></returns>
public List<string> CustomNumber<T>(string key,int num, string prefix = "", int fixedLength = 4,string dateFomart = "") where T : class, new()
{
List<string> numbers = new List<string>();
var dateValue = dateFomart == "" ? "" : DateTime.Now.ToString(dateFomart);
var fix = prefix.ToUpper() + dateValue;
var maxValue = DbContext.Queryable<T>().Where(key + " LIKE '" + fix + "%' AND LEN(" + key + ")=" + (fix.Length + fixedLength)).Select(key).Max<string>(key);
if (maxValue == null)
{
for (var i = 0; i < num; i++)
{
var tempNumber = fix + (i + 1).ToString().PadLeft(fixedLength, '0');
numbers.Add(tempNumber);
}
}
else
{
if (maxValue.Substring(0, maxValue.Length - fixedLength) == prefix + dateValue)
{
var tempLast = maxValue.Substring(maxValue.Length - fixedLength);
for (var i = 0; i < num; i++)
{
var tempNumber = fix + (int.Parse(tempLast) + i + 1).ToString().PadLeft(fixedLength, '0');
numbers.Add(tempNumber);
}
}
else
{
for (var i = 0; i < num; i++)
{
var tempNumber = fix + (i + 1).ToString().PadLeft(fixedLength, '0');
numbers.Add(tempNumber);
}
}
}
return numbers;
}
#endregion
#endregion
#region 私有方法
/// <summary>
/// 過濾條件轉換
/// </summary>
/// <param name="contitons">過濾條件</param>
/// <returns>值</returns>
private List<IConditionalModel> ParseCondition(List<QueryCondition> contitons)
{
var conds = new List<IConditionalModel>();
contitons.Insert(0, new QueryCondition
{
Operator = QueryOperator.Equal,
Key = "1",
Value = "1"
});
foreach (var con in contitons)
{
if (con.Key.Contains(","))
{
conds.Add(ParseKeyOr(con));
}
else if (con.Operator == QueryOperator.DateRange)
{
conds.AddRange(ParseRange(con,con.Operator));
}
else
{
conds.Add(new ConditionalModel()
{
FieldName = con.Key,
ConditionalType = (ConditionalType)(int)con.Operator,
FieldValue = con.Value.ToString()
});
}
}
return conds;
}
/// <summary>
/// 轉換Or條件
/// </summary>
/// <param name="condition">過濾條件</param>
/// <returns>值</returns>
private ConditionalCollections ParseKeyOr(QueryCondition condition)
{
var objectKeys = condition.Key.Split(',');
var conditionalList = new List<KeyValuePair<WhereType, ConditionalModel>>();
var num = 0;
foreach (var objKey in objectKeys)
{
if (num == 0)
{
var cond = new KeyValuePair<WhereType, ConditionalModel>
(WhereType.And, new ConditionalModel()
{
FieldName = objKey,
ConditionalType = (ConditionalType)(int)condition.Operator,
FieldValue = condition.Value.ToString()
});
conditionalList.Add(cond);
}
else
{
var cond = new KeyValuePair<WhereType, ConditionalModel>
(WhereType.Or, new ConditionalModel()
{
FieldName = objKey,
ConditionalType = (ConditionalType)(int)condition.Operator,
FieldValue = condition.Value.ToString()
});
conditionalList.Add(cond);
}
num++;
}
return new ConditionalCollections { ConditionalList = conditionalList };
}
/// <summary>
/// 轉換區域
/// </summary>
/// <param name="condition">過濾條件</param>
/// <param name="queryOperator">條件類型</param>
/// <returns>值</returns>
private List<ConditionalModel> ParseRange(QueryCondition condition, QueryOperator queryOperator)
{
var objectValue = condition.Value.ToString().Split('|');
var conditionalList = new List<ConditionalModel>();
if (objectValue.Length == 2)
{
var startValue = objectValue[0];
var endValue = objectValue[1];
if (queryOperator == QueryOperator.DateRange)
{
if (startValue.IndexOf(":", StringComparison.Ordinal) == -1)
{
startValue = startValue + " 00:00:00";
}
if (endValue.IndexOf(":", StringComparison.Ordinal) == -1)
{
endValue = endValue + " 23:59:59";
}
}
if (!string.IsNullOrWhiteSpace(objectValue[0]))
{
conditionalList.Add(new ConditionalModel()
{
FieldName = condition.Key,
ConditionalType = ConditionalType.GreaterThanOrEqual,
FieldValue = startValue
});
}
if (!string.IsNullOrWhiteSpace(objectValue[1]))
{
conditionalList.Add(new ConditionalModel()
{
FieldName = condition.Key,
ConditionalType = ConditionalType.LessThanOrEqual,
FieldValue = endValue
});
}
}
return conditionalList;
}
/// <summary>
/// 排序轉換
/// </summary>
/// <param name="orderBys">排序</param>
/// <returns>值</returns>
private string ParseOrderBy(List<OrderByClause> orderBys)
{
var conds = "";
foreach (var con in orderBys)
{
switch (con.Order)
{
case OrderSequence.Asc:
conds += $"{con.Sort} asc,";
break;
case OrderSequence.Desc:
conds += $"{con.Sort} desc,";
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return conds.TrimEnd(',');
}
#endregion
/// <inheritdoc />
/// <summary>
/// 釋放
/// </summary>
public void Dispose()
{
DbContext.Ado.Dispose();
DbContext.Dispose();
}
}
}