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

本文涉及的产品
RDS Agent(兼容OpenClaw),2核4GB
RDS DuckDB + QuickBI 企业套餐,8核32GB + QuickBI 专业版
RDS MySQL DuckDB 分析主实例,基础系列 4核8GB
简介: 唠嗑一下。都在说去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】,通过后也可以拉你进微信群一起学习。


相关实践学习
每个IT人都想学的“Web应用上云经典架构”实战
本实验从Web应用上云这个最基本的、最普遍的需求出发,帮助IT从业者们通过“阿里云Web应用上云解决方案”,了解一个企业级Web应用上云的常见架构,了解如何构建一个高可用、可扩展的企业级应用架构。
MySQL数据库入门学习
本课程通过最流行的开源数据库MySQL带你了解数据库的世界。 &nbsp; 相关的阿里云产品:云数据库RDS MySQL 版 阿里云关系型数据库RDS(Relational Database Service)是一种稳定可靠、可弹性伸缩的在线数据库服务,提供容灾、备份、恢复、迁移等方面的全套解决方案,彻底解决数据库运维的烦恼。 了解产品详情:&nbsp;https://www.aliyun.com/product/rds/mysql&nbsp;
目录
相关文章
|
9月前
|
缓存 关系型数据库 BI
使用MYSQL Report分析数据库性能(下)
使用MYSQL Report分析数据库性能
570 158
|
9月前
|
缓存 监控 关系型数据库
使用MYSQL Report分析数据库性能(中)
使用MYSQL Report分析数据库性能
610 156
|
9月前
|
缓存 监控 关系型数据库
使用MYSQL Report分析数据库性能(上)
最终建议:当前系统是完美的读密集型负载模型,优化重点应放在减少行读取量和提高数据定位效率。通过索引优化、分区策略和内存缓存,预期可降低30%的CPU负载,同时保持100%的缓冲池命中率。建议每百万次查询后刷新统计信息以持续优化
715 161
|
负载均衡 算法 关系型数据库
大数据大厂之MySQL数据库课程设计:揭秘MySQL集群架构负载均衡核心算法:从理论到Java代码实战,让你的数据库性能飙升!
本文聚焦 MySQL 集群架构中的负载均衡算法,阐述其重要性。详细介绍轮询、加权轮询、最少连接、加权最少连接、随机、源地址哈希等常用算法,分析各自优缺点及适用场景。并提供 Java 语言代码实现示例,助力直观理解。文章结构清晰,语言通俗易懂,对理解和应用负载均衡算法具有实用价值和参考价值。
大数据大厂之MySQL数据库课程设计:揭秘MySQL集群架构负载均衡核心算法:从理论到Java代码实战,让你的数据库性能飙升!
|
8月前
|
开发框架 .NET C#
ASP.NET Core Blazor 路由配置和导航
大家好,我是码农刚子。本文系统介绍Blazor单页应用的路由机制,涵盖基础配置、路由参数、编程式导航及高级功能。通过@page指令定义路由,支持参数约束、可选参数与通配符捕获,结合NavigationManager实现页面跳转与参数传递,并演示用户管理、产品展示等典型场景,全面掌握Blazor路由从入门到实战的完整方案。
647 6
|
12月前
|
关系型数据库 MySQL 分布式数据库
Super MySQL|揭秘PolarDB全异步执行架构,高并发场景性能利器
阿里云瑶池旗下的云原生数据库PolarDB MySQL版设计了基于协程的全异步执行架构,实现鉴权、事务提交、锁等待等核心逻辑的异步化执行,这是业界首个真正意义上实现全异步执行架构的MySQL数据库产品,显著提升了PolarDB MySQL的高并发处理能力,其中通用写入性能提升超过70%,长尾延迟降低60%以上。
|
存储 SQL 关系型数据库
京东面试:mysql深度分页 严重影响性能?根本原因是什么?如何优化?
京东面试:mysql深度分页 严重影响性能?根本原因是什么?如何优化?
京东面试:mysql深度分页 严重影响性能?根本原因是什么?如何优化?
|
10月前
|
缓存 关系型数据库 MySQL
MySQL数据库性能调优:实用技术与策略
通过秉持以上的策略实施具体的优化措施,可以确保MySQL数据库的高效稳定运行。务必结合具体情况,动态调整优化策略,才能充分发挥数据库的性能潜力。
452 0
|
关系型数据库 MySQL OLAP
无缝集成 MySQL,解锁秒级 OLAP 分析性能极限,完成任务可领取三合一数据线!
通过 AnalyticDB MySQL 版、DMS、DTS 和 RDS MySQL 版协同工作,解决大规模业务数据统计难题,参与活动完成任务即可领取三合一数据线(限量200个),还有机会抽取蓝牙音箱大奖!
|
监控 前端开发 API
一款基于 .NET MVC 框架开发、功能全面的MES系统
一款基于 .NET MVC 框架开发、功能全面的MES系统
727 5

热门文章

最新文章

推荐镜像

更多