SqlSuger是一个国产，开源ORM框架，具有高性能，使用方便，功能全面的特点，支持.NET Framework和.NET Core，支持各种关系型数据库，分布式数据库，时序数据库。
官网地址：SqlSugar .Net ORM 5.X 官网 、文档、教程 - SqlSugar 5x - .NET果糖网
基础知识
1、在Nuget中搜索 SqlSugarCore安装.NET Core版本，搜索SqlSugar安装.NET Framework版本。
2、它有两种对象SqlSugarClient和SqlSugarScope访问数据库，SqlSugarClient等同于在ADO，EF，Dapper中所使用的数据库访问对象，每次请求new一个新对象，db禁止跨上下文使用，IOC建议用Scope或者瞬发注入。
以下是连接数据库，并检验是否连接成功的Demo
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
var flag = db.Ado.IsValidConnection(); //如果时间长，可以在连接字符串配置 连接超时时间
Console.WriteLine(flag == true ? "连接成功" : "连接失败");
});DBFirst
DBFirst即数据库优先模式，它指的是先生成数据库，再生成实体类，SqlSuger可以根据表的结构自动生成实体类文件。
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
});
// 生成student实体类，放在桌面的Models文件夹下，命名空间是XCYN.NET8.Print.Models
Db.DbFirst.Where("student").CreateClassFile("C:\\Users\\Administrator\\Desktop\\Models", "XCYN.NET8.Print.Models");运行完代码后，会在指定文件夹下生成一个cs文件，将它复制到项目中即可。
接着使用这个类进行查询操作
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
// 查询student表中id为1的集合
var result = Db.Queryable<student>().Where(it => it.id == "1").ToList();
result.ForEach(m => {
Console.WriteLine(m.Name.ToString());
});查询完毕后，还可以在OnLogExecuting委托中打印SQL，方便我们进行SQL优化。
CodeFirst
CodeFirst和DBFirst相比更加灵活，假如需要更换数据库，采用这种方式会自动创建数据表，而且这种方式更符合面向对象的思想。
1、创建一个实体类
public class School
{
[SugarColumn(IsIdentity = true, IsPrimaryKey = true)]
public int Id { get; set; }
public string Name { get; set; }
//ColumnDataType 一般用于单个库数据库，如果多库不建议用
[SugarColumn(ColumnDataType = "Nvarchar(255)")]
public string Text { get; set; }
[SugarColumn(IsNullable = true)]//可以为NULL
public DateTime CreateTime { get; set; }
}2、创建数据表
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
// 创建指定的表，字符串类型默认长度200
Db.CodeFirst.SetStringDefaultLength(200).InitTables(typeof(School));索引
索引可以加快数据查询的速度，在经常查询的字段上建立索引可以有效地提高查询效率。
按数量划分
1、单列索引
单列索引有可以细分为唯一索引，主键索引，普通索引
唯一索引的值不能重复，只能是唯一的
主键索引是特殊的唯一索引，表的主键拥有主键索引，主键索引不能有空值
普通索引即不是唯一的，也非主键
2、多列索引
多列索引又可被称为：组合索引，联合索引，复合索引，多值索引
将多个字段联合起来建立的索引称之为多列索引。
按功能划分
1、唯一索引
2、主键索引
3、普通索引
4、全文索引
全文索引类似于在Word中按照关键字进行检索
5、空间索引
空间索引常用于空间坐标的场合，比如地图中
按存储方式划分
1、聚集索引
聚集索引指的是在磁盘上按照逻辑顺序存放的索引，一般会将主键索引当做聚集索引
2、非聚集索引
非聚集索引指的是在磁盘上没有按照逻辑顺序存放的索引
通过执行计划分析SQL语句执行的效率
在SQL语句中使用Explain查看执行计划时，type列会显示此次查询走的是哪种索引
ALL：全表扫描，即没有走索引，需要优化
Const：通过主键或唯一索引命中的查询，仅匹配一条
Ref：通过普通索引命中的查询，可匹配多条
Eq-Ref：多表关联查询时，通过主键或唯一索引命中的查询
System：表中仅有一条数据，直接从内存中读取，如查询系统表的时间
Range：通过索引进行范围查询，如Between，>，In
Index：查询了包含索引的字段，但没加筛选条件
效率排行：System > Const > Eq-Ref > Ref > Range > Index > ALL
建议至少达到Range级别，尽量优化到Ref或Eq-Ref
在SqlSuger中，同样可以使用特性来创建索引：
// 普通索引（可以写多个）
[SugarIndex("index_School_name", nameof(School.Name), OrderByType.Asc)]
// 唯一索引 (true表示唯一索引 或者叫 唯一约束)
// [SugarIndex("unique_School_CreateTime", nameof(School.CreateTime), OrderByType.Desc, true)]
public class School
{
[SugarColumn(IsIdentity = true, IsPrimaryKey = true)]
public int Id { get; set; }
public string Name { get; set; }
//ColumnDataType 一般用于单个库数据库，如果多库不建议用
[SugarColumn(ColumnDataType = "Nvarchar(255)")]
public string Text { get; set; }
[SugarColumn(IsNullable = true)]//可以为NULL
public DateTime CreateTime { get; set; }
}给类添加SugarIndex特性，并依次设置：索引名称，字段名称，排序方式，就可以在创建表的同时设置索引，它支持唯一索引，普通索引，以及复合索引
插入数据
添加数据时需要调用Insertable方法，并传入一个实例对象。
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
// 插入单条数据
School model = new School()
{
Name = "张三",
Text = "测试数据",
CreateTime = DateTime.Now
};
// Db.Insertable<School>(model).ExecuteCommand();
// 返回自增列
var id = Db.Insertable(model).ExecuteReturnIdentity();
Console.WriteLine(id);
}由于Id是自增的，所以不用指定，还可以返回自增Id。
在分布式的场景下，使用自增Id会面临在多台数据库里出现重复Id的现象，常用的解决方案是使用Guid，即一个绝对不会重复的字符串，但这种方式也有问题，就是在聚集索引里无法排序，这时可以使用雪花ID，它是由时间戳，机器ID，自定义ID组成，既能满足不会重复的要求，也可以排序。
批量插入和单条类似，都是调用Insertable方法，不同的是传入的是一个集合，如果数据量大可以使用Fastest方法，效率更高。
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456;AllowLoadLocalInfile=true;",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
List<School> list = new List<School>();
for (int i = 0; i < 10000; i++)
{
// 插入单条数据
School model = new School()
{
Name = "张三",
Text = "测试数据：" + i.ToString(),
CreateTime = DateTime.Now
};
list.Add(model);
}
// Db.Insertable(list).ExecuteCommand();
Db.Fastest<School>().PageSize(10000).BulkCopy(list); //MySql连接字符串要加AllowLoadLocalInfile=true修改数据
修改数据时调用Updateable方法，不过如果只调用它会将没有传入的值的默认值更新到数据库中，解决方法有两个：给不希望更新的字段设置特性SugerColumn的IsOnlyIgnoreUpdate属性设置为true；或者创建一个跟踪器。
1、给不希望更新的字段设置特性SugerColumn的IsOnlyIgnoreUpdate属性设置为true
[SugarColumn(IsNullable = true, IsOnlyIgnoreUpdate = true)]//可以为NULL，忽略更新
public DateTime CreateTime { get; set; }
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
// 只更新修改了的字段，不会修改其他字段
School model = new School()
{
Id = 1,
};
model.Name = "王五";
model.Text = "测试数据";
Db.Updateable(model).ExecuteCommand();这样就不会更新CreateTime字段了
2、创建一个跟踪器
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
// 只更新修改了的字段，不会修改其他字段
School model = new School()
{
Id = 1,
};
// 创建跟踪
Db.Tracking(model);
model.Name = "王五";
model.Text = "测试数据";
Db.Updateable(model).ExecuteCommand();
Db.ClearTracking();跟踪器的原理是通过反射获取这个对象哪些字段的值发生了改变，然后将这些字段拼接为SQL。
依据非主键的字段进行更新
这种需求也很常见，毕竟主键只有一个，而更新的依据会由很多种。
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
// 只更新修改了的字段，不会修改其他字段
School model = new School()
{
Name = "李四"
};
// 创建跟踪
Db.Tracking(model);
model.Text = "测试数据2";
Db.Updateable(model).WhereColumns(m => m.Name).ExecuteCommand();
Db.ClearTracking();新增或修改
在表单与列表共存的管理界面中，通常需要同时支持数据新增和修改功能。其业务逻辑可抽象为：当用户提交数据时，系统需自动判断数据记录是否存在------若存在则执行更新操作，不存在则执行新增操作。借助SqlSugar ORM框架，该通用逻辑已被封装为Storageable方法，开发者可直接调用实现"存在即更新，不存在即插入"的智能化存储策略。
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
// 修改或更新数据，首先依据Id查询是否存在，如果不存在则新增，如果存在则修改
School model = new School()
{
Id = 2,
Name = "李四",
Text = "测试数据",
CreateTime = DateTime.Now
};
Db.Storageable(model).ExecuteCommand();删除数据
删除单条数据，多条数据，依据非主键字段删除数据
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
// 删除单条数据
Db.Deleteable<School>(new School() { Id = 1 }).ExecuteCommand();
// 删除多条数据
Db.Deleteable<School>(new List<School>() {
new School() {
Id = 2
},
new School() {
Id = 3
},
}
).ExecuteCommand();
// 依据非主键字段删除数据
Db.Deleteable<School>().WhereColumns(new List<School>() {
new School() {
Text = "测试数据：3",
},
new School() {
Text = "测试数据：4",
},
},
m => new {
m.Text
}).ExecuteCommand();逻辑删除
有时候我们希望数据能一直存在于数据库中，这样方便回滚数据，追溯数据。这时会用到逻辑删除，只对某个字段的值进行修改，SqlSuger中支持这种方式，默认将IsDelete看做是逻辑删除的字段。
[SugarColumn(IsNullable = true, DefaultValue = "0")]
public bool IsDelete { get; set; }使用CodeFirst将字段更新到数据库中后，并将值设置为0，0表示未删除。使用逻辑删除需要用到IsLogic方法。
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
// Db.CodeFirst.SetStringDefaultLength(200).InitTables(typeof(School));
// 逻辑删除数据
Db.Deleteable<School>(new School() { Id = 6 }).IsLogic().ExecuteCommand();也支持自定义字段，在ExecuteCommand方法中传入字段的名字即可，还可以指定更新时间，操作人。
自定义逻辑删除字段，更新时间和操作人
首先将更新时间和操作人字段添加到数据库中，这里也将自定义删除标记字段添加进去。
[SugarColumn(IsNullable = true, DefaultValue = "0")]
public bool is_delete { get; set; }
[SugarColumn(IsNullable = true)]
public DateTime? UpdateTime { get; set; }
[SugarColumn(IsNullable = true)]
public string? ModifierName { get; set; }逻辑删除数据，并指定更新时间和操作人，自定义的删除标记字段。
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
// Db.CodeFirst.SetStringDefaultLength(200).InitTables(typeof(School));
// 逻辑删除数据
Db.Deleteable<School>(new School() { Id = 8 }).IsLogic().ExecuteCommand("is_delete", true, "UpdateTime", "ModifierName", "04");查询数据
基础查询
基础查询时要调用Queryable方法，后续再跟一个Linq的扩展方法，比如：Where，Count，Contains，Any，OrderBy，SingleOrDefault，FirstOrDefault等，它们对应不同的SQL语句像是：Where，Count，In，Like，OrderBy，<>，is null等等。
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
// 全表查询
var list = Db.Queryable<School>().ToList();
list.ForEach(m => {
Console.WriteLine(m);
});
// 查询总数
var count = Db.Queryable<School>().Count();
Console.WriteLine("Count="+count);
// 按条件查询
var list2 = Db.Queryable<School>().Where(m => m.Id == 1).ToList();
list2.ForEach(m => {
Console.WriteLine(m);
});
// In查询
int[] ids = new int[] { 1, 2, 3 };
var list3 = Db.Queryable<School>().Where(m => ids.Contains(m.Id)).ToList();
list3.ForEach(m => {
Console.WriteLine(m);
});
// In查询（多个字段）
List<School> ids2 = new List<School>()
{
new School()
{
Id = 1,
Name = "张三"
},
new School()
{
Id = 2,
Name = "李四"
},
};
var list4 = Db.Queryable<School>().Where(m =>
ids2.Any(n =>
m.Id == n.Id && m.Name == n.Name ))
.ToList();
list4.ForEach(m => {
Console.WriteLine(m);
});
// 模糊查询
var list5 = Db.Queryable<School>().Where(m => m.Name.Contains("张")).ToList();
list5.ForEach(m => {
Console.WriteLine(m);
});
// 排序
var list6 = Db.Queryable<School>().OrderBy(m => m.Id).ToList();
Console.WriteLine("--------------正序--------------");
list6.ForEach(m => {
Console.WriteLine(m);
});
// 倒序
list6 = Db.Queryable<School>().OrderBy(m => m.Id, OrderByType.Desc).ToList();
Console.WriteLine("--------------倒序--------------");
list6.ForEach(m => {
Console.WriteLine(m);
});扩展：
SingleOrDefault与FirstOrDefault有什么区别？
SingleOrDefault是查询结果只有一条时才正常返回结果，否则抛异常。
FirstOrDefault是在有单条或多条的结果时，返回第一条。
分页查询
分页查询是经常会用到的场景，调用ToPageList方法，并传入当前页码，每页条数即可。
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取原生SQL推荐 5.1.4.63 性能OK
// Console.WriteLine(UtilMethods.GetNativeSql(sql, pars));
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
var count = 0;
var totalPage = 0;
for (int i = 1; i < 100; i++)
{
var index = i;
var size = 10;
var list = Db.Queryable<School>().ToPageList(index, size, ref count, ref totalPage);
list.ForEach(m => {
Console.WriteLine(m.ToString());
});
}
Console.WriteLine($"合计：{count}条，{totalPage}页");使用Count 统计数据时，由于是全表扫描所以耗时很长，当数据大于1个亿的时候需要约1分钟，这时可以在MySQL的Schema中查询表的行数，但这种方法不是很准确
SELECT table_rows FROM Information_Schema.`TABLES`
WHERE table_Schema = 'mes' AND TABLE_NAME = 'school'
还有一种方法是通过缓存技术去实现，比如定时读取表的行数后更新到缓存中，只有当数据增加或删除时才会查询总行数，其他操作都只从缓存中读取。
分组和去重
分组是数据库的常见操作，在统计数据时经常会用到，就好比上学的时候会分班，就是以班级名称为分组依据，比如要统计每个班级里男生和女生的数量时，就是求各个班级的性别的Count值；或者期末时统计考试成绩的平均数时，就是对分数字段求Avg值。
在SqlSuger中使用GroupBy 方法并配合Select实现分组查询。
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取原生SQL推荐 5.1.4.63 性能OK
// Console.WriteLine(UtilMethods.GetNativeSql(sql, pars));
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
// 以CreateTime分组，显示每组Id的数量
var list = Db.Queryable<School>().GroupBy(m => m.CreateTime).Select(m => new
{
CreateTime = m.CreateTime,
Count = SqlFunc.AggregateCount(m.Id),
}).OrderBy(m => m.CreateTime).ToList();
list.ForEach(m => {
Console.WriteLine(m.ToString());
});
// 去重，去重方法得和Select一起使用，因为主键不可能重复，只能去指定其他可以重复的字段，这里指定的是Text
var count1 = Db.Queryable<School>().Distinct().Select(m => m.Text).Count();
var count2 = Db.Queryable<School>().Select(m => m.Text).Count();
Console.WriteLine($"去重前：{count1}");
Console.WriteLine($"去重后：{count2}");SqlFunc 是SqlSuger的开窗函数，比如：SqlFunc.AggregateCount()具有汇总的作用。
去重操作的方法和SQL里的一致都是Distinct 方法，也要与Select配合使用。
联表查询
一张表往往不足以包含所有的数据，有时还需要和其他表进行关联来获取更多信息，这时就会用到联表语句Join，它有包括左连接，右连接，内连接，全连接。对应SqlSuger的LeftJoin，RightJoin，InnerJoin，FullJoin。
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
var list = Db.Queryable<School>().LeftJoin<Area>((school, area) => school.AreaCode == area.Code )
.Select((school, area) => new {
SchoolId = school.Id,
SchoolName = school.Name,
SchoolCreateTime = school.CreateTime,
AreaCode = area.Code,
AreaName = area.Name
})
.ToList();
list.ForEach(m => {
Console.WriteLine($"SchoolId={m.SchoolId}， SchoolName={m.SchoolName}，SchoolCreateTime={m.SchoolCreateTime}，" +
$"AreaCode={m.AreaCode}，AreaName={m.AreaName}");
});上述的代码中对School和Area表进行了左连接的查询，它们共有AreaCode字段。
导航查询
导航查询和连接查询查询类似，都是对多张表进行关联，只不过它更符合面对象的思维，在一个类中存放另一个类，通过特性来配置两个类的关系，映射的字段名。
1、在School中新增一个Area类的属性
/// <summary>
/// 导航查询字段，需配置这个类的字段关联的是外部类的哪个字段
/// </summary>
[Navigate(NavigateType.OneToOne, nameof(AreaCode), nameof(Area.Code))]
public Area AreaObject { get; set; }2、使用Include方法进行导航查询
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取原生SQL推荐 5.1.4.63 性能OK
// Console.WriteLine(UtilMethods.GetNativeSql(sql, pars));
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
// 导航查询
var list = Db.Queryable<School>().Includes(m => m.AreaObject).ToList();
list.ForEach(m => {
Console.WriteLine(m.ToString());
});
// 对象映射
var list2 = Db.Queryable<School>().Includes(m => m.AreaObject).ToList().Adapt<List<SchoolDTO>>();
list2.ForEach(m =>
{
Console.WriteLine(m.ToString());
});
// 对象映射，将不同名字的字段进行映射
var list3 = Db.Queryable<School>().Includes(m => m.AreaObject).Select(m => new SchoolDTO()
{
SchoolName = m.Name,
}, true).ToList();
list3.ForEach(m => {
Console.WriteLine(m.ToString());
});上述代码不仅包含导航查询，还包括对象映射的内容。
对象映射 是将一个类的部分属性映射到另一个类中，如果手动操作不仅耗时，而且容易出错，这里使用的是Mapster包，在Nuget上下载后，无需任何配置就可以使用，直接调用Adapt方法即可完成映射。如果两个类的字段名不同，需要使用Select方法，给不同名字的字段进行一一匹配，并给第二个参数赋值为true，让其他字段自动填充。
下面是映射类：
public class SchoolDTO
{
public int Id { get; set; }
public string SchoolName { get; set; }
public string Text { get; set; }
public DateTime CreateTime { get; set; }
/// <summary>
/// 所属地区.
/// </summary>
[SugarColumn(IsNullable = true)]
public string? AreaCode { get; set; }
/// <summary>
/// 导航查询字段，需配置这个类的字段关联的是外部类的哪个字段
/// </summary>
[Navigate(NavigateType.OneToOne, nameof(AreaCode), nameof(Area.Code))]
public Area AreaObject { get; set; }
public override string ToString()
{
return $"Id={Id}，Name={Name}，Text={Text}，CreateTime={CreateTime}，AreaCode={AreaCode}，AreaObject={AreaObject?.ToString()}";
}
}Json查询
Json查询原理是通过读取Json文件里的查询条件去得到不同的结果，这样就不用再去修改代码后重新编译生成程序了。
1、Json文件内容
[
{
"FieldName": "id",
"ConditionalType": "6",
"FieldValue": "1,2,3"
},
{
"FieldName": "AreaCode",
"ConditionalType": "0",
"FieldValue": "110000"
}
]FieldName是查询的键名，ConditionalType是查询条件，6对应In，0对应=，FieldValue是值，翻译过来就是id是1,2,3并且AreaCode等于110000。
2、后台代码
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
// 读取Json，将Json转换为条件对象，再将对象放到Where方法的参数中
var json = File.ReadAllText($"{Environment.CurrentDirectory}\\sqlQuery.json");
var conModels = Db.Utilities.JsonToConditionalModels(json);
var list = Db.Queryable<School>().Where(conModels).ToList();
list.ForEach(m => {
Console.WriteLine(m.ToString());
});无实体查询
无实体查询和Json查询一样都可以动态的查询数据，而不用去修改代码。
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
// 通过字符串和匿名对象来查询SQL
var list = Db.Queryable<School>().Where("Id in(@Id) And AreaCode = @AreaCode",
new {
Id = new int[3] { 1, 2, 3 },
AreaCode = "110000"
}).ToList();
list.ForEach(m => {
Console.WriteLine(m);
});将上一节的Json条件拿到这里来，返回的结果是一样的。
事务
在一些情境下数据库的操作会执行多次，而这多次的操作过程中如果发生了点小意外，那么就会抛出异常，导致数据的不一致性，为了避免这种情况的发生，事务就孕育而生了。它可以让这些操作全部执行或者全部不执行，保证了数据的一致性。
在SqlSuger中有3个方法来操作事务：BeginTran 开启事务，CommitTran 提交事务，RollbackTran回滚事务。
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
try
{
Db.Ado.BeginTran();
Area area = new Area();
area.Code = "150000";
area.Name = "内蒙古自治区";
Db.Insertable<Area>(area).ExecuteCommand();
School model = new School()
{
Id = 1,
AreaCode = "150000",
// Name = "张三",
// Text = "测试数据",
};
Db.Updateable<School>(model).ExecuteCommand();
Db.Ado.CommitTran();
}
catch (Exception ex)
{
Db.Ado.RollbackTran();
throw ex;
}上述的例子中，首先添加了一个地区，然后修改School的地区代码，如果School的Name和Text为空，则会抛出异常，回滚事务，连第一步添加地区的操作也会失效，这就达到了全部不提交的效果。如果School的Name和Text不为空，则两个操作都能执行，事务便提交上去了。
事务锁
在高并发的场景下，如果对同一条数据进行修改，就有可能会出现问题，比如在抢红包时候，同时有两个用户开启它，那么红包的金额会减少两次，当剩余金额接近0的时候，同时操作就有可能出现负数的情况，这是要避免的，解决方式是给这个操作加锁，避免当A操作进来的时候加一把锁，不让B操作进来，直到A操作结束再放B操作进来。
上面描述的是悲观锁 的机制，SqlSuger中使用TranLock方法加锁。
主键查询一般是行锁，如果非主键可以会变成表锁
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
try
{
Db.Ado.BeginTran();
// 查询条件记录后锁表
var model = Db.Queryable<School>().TranLock(DbLockType.Wait).Where(m => m.Id == 2).First();
model.Text = "企鹅";
Db.Updateable<School>(model).ExecuteCommand();
Db.Ado.CommitTran();
}
catch (Exception ex)
{
Db.Ado.RollbackTran();
throw ex;
}AOP-面向切面编程
在之前的每个例子中都有打印SQL 的委托OnLogExecuting，这个就是AOP的一个典型运用，除了打印执行的SQL还可以进行性能检测 ，将超过一定执行时间的C#文件的名称，代码行数，方法名都打印出来；还可以进行数据处理：在每条插入，修改，删除语句中给指定的列赋值，比如给每个创建日期，修改日期的字段赋值，这样就不用每次手动给这些字段赋值了。
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db =>
{
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
db.Aop.OnLogExecuted = (sql, p) =>
{
// 执行时间超过1秒
if (db.Ado.SqlExecutionTime.TotalSeconds > 1)
{
//代码CS文件名
var fileName = db.Ado.SqlStackTrace.FirstFileName;
//代码行数
var fileLine = db.Ado.SqlStackTrace.FirstLine;
//方法名
var FirstMethodName = db.Ado.SqlStackTrace.FirstMethodName;
}
};
db.Aop.DataExecuting = (oldValue, entityInfo) =>
{
/*** 列级别事件：插入的每个列都会进事件 ***/
if (entityInfo.PropertyName == "CreateTime" && entityInfo.OperationType == DataFilterType.InsertByObject)
{
// 给每条SQL中带有CreateTime的字段赋予现在的时间
entityInfo.SetValue(DateTime.Now);
}
};
});
// 插入单条数据
School model = new School()
{
Name = "李四",
Text = "测试数据",
};
Db.Insertable<School>(model).ExecuteCommand();分表组件
当数据库的数量量很大的时候，查询会变得非常缓慢，因为索引的数量也是有限制的，这时候就可以进行分表操作，提高查询效率。SqlSuger内置了分表组件，只需调用SplitTables方法就可以进行CRUD操作。
1、建立实体
[SplitTable(SplitType.Year)]//按年分表 （自带分表支持 年、季、月、周、日）
[SugarTable("SplitTestTable_{year}{month}{day}")]//3个变量必须要有，这么设计为了兼容开始按年，后面改成按月、按日
public class SplitTestTable
{
[SugarColumn(IsPrimaryKey = true)]
public long Id { get; set; }
public string Name { get; set; }
[SugarColumn(IsNullable = true)]//设置为可空字段 (更多用法看文档 迁移)
public DateTime UpdateTime { get; set; }
[SplitField] //分表字段 在插入的时候会根据这个字段插入哪个表，在更新删除的时候用这个字段找出相关表
public DateTime CreateTime { get; set; }
}2、执行SQL，创建数据表
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
// 初始化数据库
Db.CodeFirst.SplitTables().InitTables<SplitTestTable>(); // 程序启动时加这一行,如果一张表没有会初始化一张3、CRUD
//创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)
SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",
DbType = DbType.MySql,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (sql, pars) =>
{
//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
};
});
#region 插入数据
//var data = new SplitTestTable()
//{
// CreateTime = Convert.ToDateTime("2024-12-1"),//要配置分表字段通过分表字段建表
// Name = "Jack"
//};
雪花ID+表不存在会建表
//Db.Insertable(data).SplitTable().ExecuteReturnSnowflakeIdList();//插入并返回雪花ID并且自动赋值ID
//data = new SplitTestTable()
//{
// CreateTime = Convert.ToDateTime("2023-12-1"),//要配置分表字段通过分表字段建表
// Name = "Ana"
//};
雪花ID+表不存在会建表
//Db.Insertable(data).SplitTable().ExecuteReturnSnowflakeIdList();//插入并返回雪花ID并且自动赋值ID
//data = new SplitTestTable()
//{
// CreateTime = Convert.ToDateTime("2022-12-1"),//要配置分表字段通过分表字段建表
// Name = "Bob"
//};
雪花ID+表不存在会建表
//Db.Insertable(data).SplitTable().ExecuteReturnSnowflakeIdList();//插入并返回雪花ID并且自动赋值ID
//data = new SplitTestTable()
//{
// CreateTime = Convert.ToDateTime("2021-12-1"),//要配置分表字段通过分表字段建表
// Name = "Ciri"
//};
雪花ID+表不存在会建表
//Db.Insertable(data).SplitTable().ExecuteReturnSnowflakeIdList();//插入并返回雪花ID并且自动赋值ID
#endregion
// 查询数据
var beginDate = Convert.ToDateTime("2021-1-1");
var endDate = Convert.ToDateTime("2025-1-1");
var list = Db.Queryable<SplitTestTable>()
.Where(it => it.Id > 0)
.SplitTable(beginDate, endDate)
.OrderBy(m => m.Id, OrderByType.Asc)
.ToList();
// 注意：
// 1、 分页有 OrderBy写 SplitTable 后面 ,uinon all后在排序
// 2、 Where尽量写到 SplitTable 前面，先过滤在union all
// 原理：(sql union sql2) 写SplitTable 后面生成的括号外面，写前生成的在括号里面
list.ForEach(m => {
Console.WriteLine(m.Id + " " + m.Name + " " + m.CreateTime);
});