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

本文涉及的产品
云数据库 RDS MySQL,集群系列 2核4GB
推荐场景:
搭建个人博客
RDS MySQL Serverless 基础系列,0.5-2RCU 50GB
云原生数据库 PolarDB MySQL 版,通用型 2核4GB 50GB
简介: 唠嗑一下。都在说去O或者开源,但是对于数据库选型来说,很多人却存在着误区。例如,去O,狭义上讲,是去Oracle数据库。但是从广义上来说,是去Oracle公司产品或者具有漂亮国垄断地位和需要商业授权的数据库产品。


前言


唠嗑一下。都在说去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 可以进行默认的登录,默认无密码。

 1995789-20220403194620279-1540599574.png


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

1995789-20220403194633394-778797525.png

 

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

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

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

1995789-20220403194649492-2048917887.png


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

1995789-20220403194704806-161553473.png

 

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

 

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


然后重载防火墙,命令:firewall-cmd --reload

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

Mysql表结构:

1995789-20220403194748959-223491534.png

PostgreSQL表结构:

 1995789-20220403194802149-1737011706.png


Oracle表结构:

 1995789-20220403194816192-12697142.png

 

.NET 6开发测试代码


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

 1995789-20220403194829025-1171370236.png

 

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


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


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

1995789-20220403194847263-420540692.png

 

通过命令:

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

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

1995789-20220403194902299-634973823.png

 

通过命令:

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

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

1995789-20220403194920106-1120920671.png

 

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

1995789-20220403194933973-297436165.png

 

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

1995789-20220403194947958-600584117.png

 

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

1995789-20220403195010317-846772129.png

 

实现里面也做点调整。

1995789-20220403195023636-309955044.png

 

测试插入和更新


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

先看Oracle物理表情况。

插入总共数据条数:

1995789-20220403195040041-67442737.png


部分数据结果集:

 1995789-20220403195056728-809404780.png

 

然后是mysql物理表数据。

插入数据总数:

1995789-20220403195109634-132426407.png

 

部分数据结果集:

1995789-20220403195122812-145077612.png

 

最后是PostgreSQL。插入总条数:

1995789-20220403195136235-320348678.png


部分数据结果集:

1995789-20220403195148585-1344286160.png

 

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

1995789-20220403195214442-1522325998.png

 

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

 1995789-20220403195243916-1699498831.png

 

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

Oracle数据:

1995789-20220403195300822-2031078925.png

 

MySQL数据:

1995789-20220403195356696-553482220.png

 

PGSQL数据:

1995789-20220403195409416-997894490.png

 

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


第一回测试结果:

1995789-20220403195430501-1365007411.png


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

1995789-20220403195450487-292011330.png

 

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

来一波批量插入:


1995789-20220403195510499-1325385999.png

 

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

 

1995789-20220403195522940-2102001881.png

 

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


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】,通过后也可以拉你进微信群一起学习。


相关实践学习
如何在云端创建MySQL数据库
开始实验后,系统会自动创建一台自建MySQL的 源数据库 ECS 实例和一台 目标数据库 RDS。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心,利用清洁计算为万物互联的新世界提供源源不断的能源动力,目前开服的区域包括中国(华北、华东、华南、香港)、新加坡、美国(美东、美西)、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程,来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品:云服务器ECS 云服务器 ECS(Elastic Compute Service)是一种弹性可伸缩的计算服务,助您降低 IT 成本,提升运维效率,使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
目录
相关文章
|
1月前
|
存储 开发框架 JSON
ASP.NET Core OData 9 正式发布
【10月更文挑战第8天】Microsoft 在 2024 年 8 月 30 日宣布推出 ASP.NET Core OData 9,此版本与 .NET 8 的 OData 库保持一致,改进了数据编码以符合 OData 规范,并放弃了对旧版 .NET Framework 的支持,仅支持 .NET 8 及更高版本。新版本引入了更快的 JSON 编写器 `System.Text.UTF8JsonWriter`,优化了内存使用和序列化速度。
|
3月前
|
SQL DataWorks 关系型数据库
DataWorks产品使用合集之如何跨账号访问同一个MySQL
DataWorks作为一站式的数据开发与治理平台,提供了从数据采集、清洗、开发、调度、服务化、质量监控到安全管理的全套解决方案,帮助企业构建高效、规范、安全的大数据处理体系。以下是对DataWorks产品使用合集的概述,涵盖数据处理的各个环节。
|
30天前
|
关系型数据库 MySQL Linux
Docker安装Mysql5.7,解决无法访问DockerHub问题
当 Docker Hub 无法访问时,可以通过配置国内镜像加速来解决应用安装失败和镜像拉取超时的问题。本文介绍了如何在 CentOS 上一键配置国内镜像加速,并成功拉取 MySQL 5.7 镜像。
273 2
Docker安装Mysql5.7,解决无法访问DockerHub问题
|
29天前
|
SQL XML 关系型数据库
入门指南:利用NHibernate简化.NET应用程序的数据访问
【10月更文挑战第13天】NHibernate是一个面向.NET的开源对象关系映射(ORM)工具,它提供了从数据库表到应用程序中的对象之间的映射。通过使用NHibernate,开发者可以专注于业务逻辑和领域模型的设计,而无需直接编写复杂的SQL语句来处理数据持久化问题。NHibernate支持多种数据库,并且具有高度的灵活性和可扩展性。
39 2
|
1月前
|
SQL Oracle 关系型数据库
Oracle SQL:了解执行计划和性能调优
Oracle SQL:了解执行计划和性能调优
51 1
|
2月前
|
开发框架 监控 前端开发
在 ASP.NET Core Web API 中使用操作筛选器统一处理通用操作
【9月更文挑战第27天】操作筛选器是ASP.NET Core MVC和Web API中的一种过滤器,可在操作方法执行前后运行代码,适用于日志记录、性能监控和验证等场景。通过实现`IActionFilter`接口的`OnActionExecuting`和`OnActionExecuted`方法,可以统一处理日志、验证及异常。创建并注册自定义筛选器类,能提升代码的可维护性和复用性。
|
2月前
|
开发框架 .NET 中间件
ASP.NET Core Web 开发浅谈
本文介绍ASP.NET Core,一个轻量级、开源的跨平台框架,专为构建高性能Web应用设计。通过简单步骤,你将学会创建首个Web应用。文章还深入探讨了路由配置、依赖注入及安全性配置等常见问题,并提供了实用示例代码以助于理解与避免错误,帮助开发者更好地掌握ASP.NET Core的核心概念。
92 3
|
1月前
|
开发框架 JavaScript 前端开发
一个适用于 ASP.NET Core 的轻量级插件框架
一个适用于 ASP.NET Core 的轻量级插件框架
|
2月前
|
开发框架 NoSQL .NET
利用分布式锁在ASP.NET Core中实现防抖
【9月更文挑战第5天】在 ASP.NET Core 中,可通过分布式锁实现防抖功能,仅处理连续相同请求中的首个请求,其余请求返回 204 No Content,直至锁释放。具体步骤包括:安装分布式锁库如 `StackExchange.Redis`;创建分布式锁服务接口及其实现;构建防抖中间件;并在 `Startup.cs` 中注册相关服务和中间件。这一机制有效避免了短时间内重复操作的问题。
|
2月前
|
SQL 存储 关系型数据库
C#一分钟浅谈:使用 ADO.NET 进行数据库访问
【9月更文挑战第3天】在.NET开发中,与数据库交互至关重要。ADO.NET是Microsoft提供的用于访问关系型数据库的类库,包含连接数据库、执行SQL命令等功能。本文从基础入手,介绍如何使用ADO.NET进行数据库访问,并提供示例代码,同时讨论常见问题及其解决方案,如连接字符串错误、SQL注入风险和资源泄露等,帮助开发者更好地利用ADO.NET提升应用的安全性和稳定性。
239 6

推荐镜像

更多