.NET ORM开发手册：基于SqlSugar的高效数据访问全攻略

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);
    });