【.NET 6】使用EF Core 访问Oracle+Mysql+PostgreSQL并进行简单增改操作与性能比较

前言

唠嗑一下。都在说去O或者开源，但是对于数据库选型来说，很多人却存在着误区。例如，去O，狭义上讲，是去Oracle数据库。但是从广义上来说，是去Oracle公司产品或者具有漂亮国垄断地位和需要商业授权的数据库产品。

去O，目前国内有一个现象，就是很多公司或个人听到去O，第一反应是改用Mysql，实际上Mysql也是Oracle公司的。而且Mysql虽然是开源的，但是需要遵循GPL开源协议，这个协议里面(大概意思)含有这么两点就可以窥见一斑：

1、如果用Mysql源码进行二次修改，修改后的产品也必须开源，例如目前国产分布式数据库TiDB就遵循该协议进行开源；

2、如果要对Mysql二次封装或者修改后进行实现商业版本，就必须取得甲骨文公司授权。以上这两条，就足以让Mysql这款开源数据库并不具备“开源优势”，将来该被制裁还是会被制裁。

目前去O，还有一款备选开源数据库是PostgreSQL,它是基于BSD开源协议的，该开源协议是四大开源协议里面最“开放”和自由的，不会受到商业版权化影响，并且组织或个人也可以通过它的源码进行二次封装或者进行发行商业版，例如华为的OpenGuass是基于该开源版本进行二次开发的，并且基于PostgreSQL或者基于OpenGuass进行二次封装成商业版本的数据库(国产、非国产等)也比比皆是。

以上只是吐个槽，本篇文章主要是想通过.NET6+EF CORE + 三大数据库，进行一个在同等环境下的简单的读写性能测试。

【备注】由于各种原因，接下来的测试结果可能会不准确，以下仅供学习或参考使用。

数据库运行环境：Cent OS 7.5

PostgreSQL版本：14

MySQL数据库版本：8.0

Oracle数据库：12C 64位

客户端环境：WIN 10 专业版

运行时环境：.NET 6

ORM：EF CORE

开发语言：C#

CentOS环境安装PostgreSQL

远程服务器上已有授权的Oracle环境和Mysql环境，所以具体安装细节不再进行描述，如果感兴趣的小伙伴也可以自行百度一下Oracle和Mysql的安装教程，应该非常多。由于服务器上暂时还没有PostgreSQL环境，我暂且也把安装PostgreSQL的安装步骤也顺手记录下。

PostgreSQL安装：

下载地址：

https://www.postgresql.org/download/linux/redhat/

选择版本以后，会有对应提示的安装方式命令，就不发出来了，可自行参考。

以下是安装以后的一些配置。

安装完毕，并且启动pgsql服务以后，此处我先创建一个测试用的数据库：testdb

使用命令：su – postgres 可以进行默认的登录，默认无密码。

【.NET 6】使用EF Core 访问Oracle+Mysql+PostgreSQL并进行简单增改操作与性能比较

登陆以后使用命令：psql 可以进入到可执行SQL的命令的页面，以postgres=# 开头。其他命令和有关创建用户的SQL语句如图所示。

修改配置文件： /var/lib/pgsql/14/data/postgresql.conf

将注释的listen_addresses打开，设置值为 ‘*’

路径上的14代表版本，如果是13版本就是13，以此类推，下同。

修改/var/lib/pgsql/14/data/pg_hba.conf配置文件，对IPV4访问新增一行配置如下：

然后要重启pgsql服务，以用于生效。

由于pgsql默认的端口是5432，为了可以跨远程访问，此处把远程服务器上的端口开放出来。命令：firewall-cmd –zone=public –add-port=5432/tcp –permanent

然后重载防火墙，命令：firewall-cmd –reload

测试数据库有关表结构。以下表均没有设置索引，仅单表测试，结果仅供参考。

Mysql表结构:

PostgreSQL表结构：

Oracle表结构:

.NET 6开发测试代码

先创建一个minimal api项目，以及一个服务类库项目。类库引用需要操作Oracle数据库、MySQL数据库以及Postgresql数据库有关的组件。

对服务类设置为启动项，然后新增三个文件夹(MyModel,OraModel和PgModel)，用于分别存放三个数据库的实体类。然后在程序包管理控制台上，通过命令：

Scaffold-DbContext “mysql连接字符串” Pomelo.EntityFrameworkCore.MySql -OutputDir MyModel -Force

自动生成指定的mysql数据库实体类。其中，MyModel是需要生成的目标目录文件夹。

通过命令：

Scaffold-DbContext “Oracle连接字符串” Oracle.EntityFrameworkCore -OutputDir OraModel -Force

自动生成Oracle数据库实体类。

通过命令：

Scaffold-DbContext “pgsql连接字符串” Npgsql.EntityFrameworkCore.PostgreSQL -OutputDir PgModel -Force

自动生成PostgreSQL数据库实体类。

新建一个测试服务类DatabaseTestService，提供简单插入和更新功能：

在minimai api项目里，新增两个简单的测试API用于测试。为了简单，就直接实例化一下进行访问，然后返回执行结果。

以上方法可能执行适合会导致耗时而失败，为了直观一点，改成控制台里面输出。

实现里面也做点调整。

测试插入和更新

运行程序以后，对三个数据库分别插入数据并计时。

先看Oracle物理表情况。

插入总共数据条数：

部分数据结果集：

然后是mysql物理表数据。

插入数据总数：

部分数据结果集：

最后是PostgreSQL。插入总条数：

部分数据结果集：

以下是通过EF CORE进行插入的结果：

接下来进行一轮更新操作，为了防止数据量太大，所以只进行批量更新10000条数据。结果如下：

看下数据更新结果是不是正常。

Oracle数据：

MySQL数据:

PGSQL数据：

数据库数据清空，屏蔽掉C#代码一些实体赋值时间，重新执行两次仅统计批量插入数据库部分的执行的时间进行重新测试，仅测试批量插入耗时结果。

第一回测试结果：

接下来不删除数据，重新执行一轮。

Oracle估计哪儿有问题，数据让人很尴尬啊。接下来只比较MySQL和PgSQL

来一波批量插入：

再来一波三次的批量更新：

有关代码(最后测试使用)：

 public class DatabaseTestService
    {
        public String TestInsert()
        {
            StringBuilder sb = new StringBuilder();
           Console.WriteLine("*************************开始插入测试************************");
            for(int i = 1; i < 5; i++)
            {
          //      Console.WriteLine(TestOracleInsert(i));
                Console.WriteLine(TestMysqlInsert(i));
                Console.WriteLine(TestPostgreSQLInsert(i));
            }
            return sb.ToString();
        }
        public String TestUpdate()
        {
            StringBuilder sb = new StringBuilder();
            Console.WriteLine("*************************开始更新测试************************");
            //       Console.WriteLine(TestOracleUpdate());
            for (int i =0;i<3;i++) {
                Console.WriteLine(TestMysqlUpdate(i));
                Console.WriteLine(TestPostgreSQLUpdate(i));
            }
            return sb.ToString();
        }
        private String TestOracleInsert(int loop)
        {
            StringBuilder sb = new();
            Stopwatch stopwatch = new();
            List<OraModel.TestTable> tables = new();

            for (int i = 1; i <= 50000; i++)
            {
                OraModel.TestTable table = new();
                table.Id = Guid.NewGuid().ToString("N");
                table.Message = $"第{loop}轮测试数据{i}";
                table.CurrentTime = DateTime.Now;
                table.Code = (loop * 5000) + i;
                tables.Add(table);
            }
            using (var context = new OraModel.ModelContext())
            {
                try {

                    stopwatch.Start();
                    context.Database.BeginTransaction();
                    context.TestTables.AddRange(tables);
                    context.SaveChanges();
                    context.Database.CommitTransaction();
                    stopwatch.Stop();
                    sb.Append($"第{loop}轮插入50000条到【Oracle】数据库【成功】:耗时{stopwatch.ElapsedMilliseconds} ms...");

                }
                catch(Exception ex)
                {
                    context.Database.RollbackTransaction();
                    stopwatch.Stop();
                    sb.Append($"第{loop}轮插入50000条到【Oracle】数据库【失败】:耗时{stopwatch.ElapsedMilliseconds} ms...");
                }
                finally
                {
                }
            }

            return sb.ToString();
        }
        private String TestMysqlInsert(int loop)
        {
            StringBuilder sb = new();
            Stopwatch stopwatch = new();
            List<MyModel.TestTable> tables = new();
            for (int i = 1; i <= 100000; i++)
            {
                MyModel.TestTable table = new();
                table.Id = Guid.NewGuid().ToString("N");
                table.Message = $"第{loop}轮测试数据{i}";
                table.CurrentTime = DateTime.Now;
                table.Code = i;
                tables.Add(table);
            }
            using (var context = new MyModel.testdbContext())
            {
                try
                {
                    stopwatch.Start();
                    context.Database.BeginTransaction();
                    context.TestTables.AddRange(tables);
                    context.SaveChanges();
                    context.Database.CommitTransaction();
                    stopwatch.Stop();
                    sb.Append($"第{loop}轮插入100000条到【MySQL】数据库【成功】:耗时{stopwatch.ElapsedMilliseconds} ms...");

                }
                catch (Exception ex)
                {
                    context.Database.RollbackTransaction();
                    stopwatch.Stop();
                    sb.Append($"第{loop}轮插入100000条到【MySQL】数据库【失败】:耗时{stopwatch.ElapsedMilliseconds} ms...");
                }
                finally
                {
                }
            }

            return sb.ToString();
        }
        private String TestPostgreSQLInsert(int loop)
        {
            StringBuilder sb = new();
            Stopwatch stopwatch = new();
            List<PgModel.TestTable> tables = new();

            for (int i = 1; i <= 100000; i++)
            {
                PgModel.TestTable table = new();
                table.Id = Guid.NewGuid().ToString("N");
                table.Message = $"第{loop}轮测试数据{i}";
                table.CurrentTime = DateTime.Now;
                table.Code = i;
                tables.Add(table);
            }
            using (var context = new PgModel.testdbContext())
            {
                try
                {

                    stopwatch.Start();
                    context.Database.BeginTransaction();
                    context.TestTables.AddRange(tables);
                    context.SaveChanges();
                    context.Database.CommitTransaction();
                    stopwatch.Stop();
                    sb.Append($"第{loop}轮插入100000条到【PostgreSQL】数据库【成功】:耗时{stopwatch.ElapsedMilliseconds} ms...");

                }
                catch (Exception ex)
                {
                    context.Database.RollbackTransaction();
                    stopwatch.Stop();
                    sb.Append($"第{loop}轮插入100000条到【PostgreSQL】数据库【失败】:耗时{stopwatch.ElapsedMilliseconds} ms...");
                }
                finally
                {
                }
            }

            return sb.ToString();
        }
        private String TestOracleUpdate()
        {
            StringBuilder sb = new();
            Stopwatch stopwatch = new();
           
            using (var context = new OraModel.ModelContext())
            {
                
                var datas = context.TestTables.OrderBy(x=>x.Code).Take(10000);
                context.Database.BeginTransaction();
                foreach (var value in datas)
                {
                    value.Message = $"数据变更,code={value.Code}";
                }
                try
                {
                    stopwatch.Start();
                    context.TestTables.UpdateRange(datas);
                    context.SaveChanges();
                    context.Database.CommitTransaction();
                    stopwatch.Stop();
                    sb.Append($"批量更新【Oracle】数据库10000条【成功】:耗时{stopwatch.ElapsedMilliseconds} ms...");
                    
                }
                catch (Exception ex)
                {
                    context.Database.RollbackTransaction();
                    stopwatch.Stop();
                    sb.Append($"批量更新【Oracle】数据库10000条【失败】:耗时{stopwatch.ElapsedMilliseconds} ms...");
                }
                finally
                {
                }
            }

            return sb.ToString();
        }
        private String TestMysqlUpdate(int loop)
        {
            StringBuilder sb = new();
            Stopwatch stopwatch = new();
            using (var context = new MyModel.testdbContext())
            {

                var datas = context.TestTables.OrderBy(x => x.Code).Skip(loop*50000).Take(50000);
                context.Database.BeginTransaction();
                foreach (var value in datas)
                {
                    value.Message = $"数据变更,code={value.Code}";
                }
                try
                {
                    stopwatch.Start();
                    context.TestTables.UpdateRange(datas);
                    context.SaveChanges();
                    context.Database.CommitTransaction();
                    stopwatch.Stop();
                    sb.Append($"批量更新【MySQL】数据库50000条【成功】:耗时{stopwatch.ElapsedMilliseconds} ms...");

                }
                catch (Exception ex)
                {
                    context.Database.RollbackTransaction();
                    stopwatch.Stop();
                    sb.Append($"批量更新【MySQL】数据库50000条【失败】:耗时{stopwatch.ElapsedMilliseconds} ms...");
                }
                finally
                {
                }
            }

            return sb.ToString();
        }
        private String TestPostgreSQLUpdate(int loop)
        {
            StringBuilder sb = new();
            Stopwatch stopwatch = new();
            using (var context = new PgModel.testdbContext())
            {

                var datas = context.TestTables.OrderBy(x => x.Code).Skip(loop * 50000).Take(50000);
                context.Database.BeginTransaction();
                foreach (var value in datas)
                {
                    value.Message = $"数据变更,code={value.Code}";
                }
                try
                {
                    stopwatch.Start();
                    context.TestTables.UpdateRange(datas);
                    context.SaveChanges();
                    context.Database.CommitTransaction();
                    stopwatch.Stop();
                    sb.Append($"第{loop}轮 批量更新【PostgreSQL】数据库50000条【成功】:耗时{stopwatch.ElapsedMilliseconds} ms...");

                }
                catch (Exception ex)
                {
                    context.Database.RollbackTransaction();
                    stopwatch.Stop();
                    sb.Append($"第{loop}轮 批量更新【PostgreSQL】数据库50000条【失败】:耗时{stopwatch.ElapsedMilliseconds} ms...");
                }
                finally
                {
                }
            }

            return sb.ToString();
        }



    }

以上测试至此就结束了。结论可能有点尴尬，也许跟环境配置有关，也可能跟ef core操作数据库的支持与实现有关。并且当前仅在单表环境下测试，并没有通过多表测试、存过测试、压力测试等，结果仅供娱乐和参考。同时欢迎各位大佬们提供更多测试内容，也欢迎各位大佬转发或评论或点赞等一键三连。

本文原链接：https://www.cnblogs.com/weskynet/p/16097151.html

如果有兴趣一起探讨.NET技术，也可以点击我的原博客地址，然后点击最下方加入QQ群聊按钮加入Q群聊，或者也可以加我个人微信号【WeskyNet001】，通过后也可以拉你进微信群一起学习。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/120947.html