达梦数据库操作教程

基础

一、 了解DM数据库

DM 数据库是中国的一个关系型数据库产品，由中国国内的公司发展。DM 数据库支持 SQL 语言、存储过程、触发器、视图等关系型数据库的标准特性，并且具有高并发、高可用、高安全性等特点。

以下是关于 DM 数据库的一些特点和功能：

高性能：DM 数据库经过了优化，以支持高并发、大数据量的操作。它采用了先进的查询优化技术、索引技术等，以确保查询和事务的高效执行。

高可用性：DM 数据库支持多种高可用解决方案，如数据复制、热备份、故障切换等，以确保业务的连续性。

安全性：DM 数据库提供了多种安全特性，如访问控制、加密、审计等，以确保数据的安全。

兼容性：DM 数据库支持 SQL 标准，并且与多种编程语言和开发工具有良好的兼容性。

易于管理：DM 数据库提供了图形化的管理工具和命令行工具，使得数据库的管理和维护变得更加简单。

支持分布式：DM 数据库支持分布式部署和查询，可以满足大规模、分布式的业务需求。

国产化：作为国内自主研发的数据库产品，DM 数据库在国内市场有着很好的口碑和应用案例。

总的来说，DM 数据库是一个功能齐全、性能高、安全可靠的关系型数据库产品，特别适合在国内环境下使用。

二、安装

1、  安装DM数据库前，先检查当前操作系统相关信息，确认 DM 数据库安装程序与当前操作系统匹配，以保证 DM 数据库能够正确安装和运行。

2、  用户可以在终端通过 Win+R 打开运行窗口，输入 cmd，打开命令行工具，输入 systeminfo 命令进行查询，如下图所示：

3、 下载安装包

下载好后解压iso文件

点击exe文件下载

直接下一步

下一步

接受，下一步

下一步

选择典型安装下一步

● 典型安装包括：服务器、客户端、驱动、用户手册、数据库服务。

● 服务器安装包括：服务器、驱动、用户手册、数据库服务。

● 客户端安装包括：客户端、驱动、用户手册。

● 自定义安装包括：用户根据需求勾选组件，可以是服务器、客户端、驱动、用户手册、数据库服务中的任意组合。

DM 默认安装在 C:\dmdbms 目录下，不建议使用默认目录，改为其他任意盘符即可

三、创建数据库实例

打开DM数据库配置助手

选择创建，点击开始

然后一直下一步

到口令管理，口令就是密码 尽量是默认

这个随便勾选一个即可，建议勾选可以不勾选

然后直接安装即可

四、 启动、停止数据库

1、  执行dmservice.exe文件

找到该exe文件双击

可以查看对应的服务，可选择启动或停止

五、 在.Net中使用DM数据库

输入命令：gacutil /if D:\dmdbms\drivers\dotNet\DmProvider\net60\DmProvider.dll该命令是将对应目录下的dll文件注册到.Net驱动中，注册完后全局可用。

地址是对应DM下载的地址路径下的net60\DmProvider.dll包如果出现提示

改为自己的路径即可

点击添加项目引用

浏览

找到对应的dll文件在Dm数据库文件夹下的Dmprovider中我这里创建的项目是.Net6所以用的是net60根据对应的项目选择不同的dll文件

选择完成后勾选点击确定即可

我在控制器里写了个基本的创建表方法测试是否可用，Server是

最后创建成功在MAIN下查看，一般创建的表和做的操作都在该目录下

进阶

一、 SqlSugar使用DM数据库

1、了解DM数据库

SqlSugar是一款国产的ORM轻量级框架用于在 .NET 平台上简化与数据库的交互操作。它支持主流的关系型数据库，如 DM, SQL Server、MySQL、Oracle 等，并提供了一系列强大的功能和特性，使数据库的操作更加简便和高效。

2、  配置上下文以及注册Progrom

在appsettings里面配置连接字符串

在WebApi中下载对应的包

登录后复制

/// <summary>
        /// SqlSugar配置
        /// </summary>
        /// <param name="builder"></param>
        public static void DapperSignIn(this WebApplicationBuilder builder)
        {
            builder.Services.AddScoped(m =>
            {
                var sqlConnString = builder.Configuration.GetConnectionString("DbSet");
                return new SqlSugarClient(new SqlSugar.ConnectionConfig()
                {
                    ConnectionString = sqlConnString,
                    DbType = DbType.Dm,
                    IsAutoCloseConnection = true,
                    InitKeyType = InitKeyType.Attribute
                });
            });
            builder.Services.AddDbContext<DMDbContext>(m => m.UseDm(builder.Configuration.GetConnectionString("DbSet")));
        }

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.

在扩展方法写配置调用或在Progrom中直接写配置

在仓储类库中下载对应的包

在Model中创建实体类因为在DM数据库中只能识别大写所以要加一个[Column("BID")]这样迁移后的数据就都是大写了

登录后复制

/// <summary>
    /// 上下文类
    /// </summary>
    public class DMDbContext : DbContext
    {
        private readonly IConfiguration configuration;

        public DMDbContext(DbContextOptions options, IConfiguration configuration)
            : base(options)
        {
            this.configuration = configuration;
        }

        /// <summary>
        /// 用户
        /// </summary>
        public DbSet<UserInfor> USERINFOR { get; set; }
        /// <summary>
        /// Bool
        /// </summary>
        public DbSet<Bool> BOOL { get; set; }
        /// <summary>
        /// 用户Bool关系表
        /// </summary>
        public DbSet<UserBoolModel> USERBOOLMODEL { get; set; }
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<UserInfor>().HasKey(m => m.UserId);
            modelBuilder.Entity<Bool>().HasKey(m => m.BId);
            modelBuilder.Entity<UserBoolModel>().HasKey(m => m.UBId);
            base.OnModelCreating(modelBuilder);
        }
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            string connectionString = configuration.GetConnectionString("DbSet");
            optionsBuilder.UseDm(connectionString);
        }
    }

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.
• 31.
• 32.
• 33.
• 34.
• 35.
• 36.
• 37.
• 38.

最后在上下文类中写对应的配置即可，注意表名要大写！

迁移的命令：add-migration 创建数据库和表，Update-Database

2、 在仓储层中写对应的通用扩展接口和实现方法类

结构

登录后复制

/// <summary>
    /// 定义通用仓储接口
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IRepository<T>
    {
        #region 同步接口

        /// <summary>
        /// 显示
        /// </summary>
        /// <returns></returns>
        IEnumerable<T> GetAll();
        /// <summary>
        /// 通过Id获取对应的数据
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        T GetById(object id);
        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="entity"></param>
        bool Insert(T entity);
        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="entity"></param>
        bool Update(T entity);
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="id"></param>
        bool Delete(object id);

        #endregion

        #region 异步接口

        /// <summary>
        /// 显示
        /// </summary>
        /// <returns></returns>
        Task<IEnumerable<T>> GetAllAsync();
        /// <summary>
        /// 通过Id获取对应的数据
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        Task<T> GetByIdAsync(object id);
        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="entity"></param>
        Task<bool> InsertAsync(T entity);
        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="entity"></param>
        Task<bool> UpdateAsync(T entity);
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="id"></param>
        Task<bool> DeleteAsync(object id);

        #endregion

        #region 批量操作异步方法

        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="entity"></param>
        Task<int> BulkInsertAsync(IEnumerable<T> entity);
        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="entity"></param>
        Task<int> BulkUpdateAsync(IEnumerable<T> entity);
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="id"></param>
        Task<int> BulkDeleteAsync(IEnumerable<object> id);

        #endregion
    }
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.
• 31.
• 32.
• 33.
• 34.
• 35.
• 36.
• 37.
• 38.
• 39.
• 40.
• 41.
• 42.
• 43.
• 44.
• 45.
• 46.
• 47.
• 48.
• 49.
• 50.
• 51.
• 52.
• 53.
• 54.
• 55.
• 56.
• 57.
• 58.
• 59.
• 60.
• 61.
• 62.
• 63.
• 64.
• 65.
• 66.
• 67.
• 68.
• 69.
• 70.
• 71.
• 72.
• 73.
• 74.
• 75.
• 76.
• 77.
• 78.
• 79.
• 80.
• 81.
• 82.
• 83.
• 84.
• 85.
• 86.
• 87.
• 88.
• 89.

主要分为三大类：同步，异步和批量操作

登录后复制

/// <summary>
    /// Sugar通用仓储实现
    /// </summary>
    public class SugarRepository<T> : IRepository<T> where T : class, new()
    {
        private readonly SqlSugarClient _db;

        /// <summary>
        /// 构造函数，初始化SqlSugarClient
        /// </summary>
        /// <param name="db">SqlSugarClient实例</param>
        public SugarRepository(SqlSugarClient db)
        {
            _db = db ?? throw new ArgumentNullException(nameof(db));
        }

        #region 同步方法

        /// <summary>
        /// 根据ID删除实体
        /// </summary>
        /// <param name="id">实体的ID</param>
        /// <returns>如果删除成功返回true，否则返回false</returns>
        public bool Delete(object id)
        {
            return _db.Deleteable<T>().In(id).ExecuteCommand() > 0;
        }

        /// <summary>
        /// 获取所有实体
        /// </summary>
        /// <returns>实体的集合</returns>
        public IEnumerable<T> GetAll()
        {
            return _db.Queryable<T>().ToList();
        }

        /// <summary>
        /// 根据ID获取实体
        /// </summary>
        /// <param name="id">实体的ID</param>
        /// <returns>找到的实体，如果没有找到则返回null</returns>
        public T GetById(object id)
        {
            return _db.Queryable<T>().InSingle(id);
        }

        /// <summary>
        /// 插入一个新的实体
        /// </summary>
        /// <param name="entity">要插入的实体</param>
        /// <returns>如果插入成功返回true，否则返回false</returns>
        public bool Insert(T entity)
        {
            if (entity == null)
            {
                throw new ArgumentNullException(nameof(entity));
            }

            return _db.Insertable(entity).ExecuteCommand() > 0;
        }

        /// <summary>
        /// 更新一个已存在的实体
        /// </summary>
        /// <param name="entity">要更新的实体</param>
        /// <returns>如果更新成功返回true，否则返回false</returns>
        public bool Update(T entity)
        {
            if (entity == null)
            {
                throw new ArgumentNullException(nameof(entity));
            }

            return _db.Updateable(entity).ExecuteCommand() > 0;
        }

        #endregion

        #region 异步方法

        /// <summary>
        /// 根据ID异步删除实体
        /// </summary>
        /// <param name="id">实体的ID</param>
        /// <returns>如果删除成功返回true，否则返回false</returns>
        public async Task<bool> DeleteAsync(object id)
        {
            return await _db.Deleteable<T>().In(id).ExecuteCommandAsync() > 0;
        }

        /// <summary>
        /// 异步获取所有实体
        /// </summary>
        /// <returns>实体的集合</returns>
        public async Task<IEnumerable<T>> GetAllAsync()
        {
            return await _db.Queryable<T>().ToListAsync();
        }

        /// <summary>
        /// 根据ID异步获取实体
        /// </summary>
        /// <param name="id">实体的ID</param>
        /// <returns>找到的实体，如果没有找到则返回null</returns>
        public async Task<T> GetByIdAsync(object id)
        {
            return await _db.Queryable<T>().InSingleAsync(id);
        }

        /// <summary>
        /// 异步插入一个新的实体
        /// </summary>
        /// <param name="entity">要插入的实体</param>
        /// <returns>如果插入成功返回true，否则返回false</returns>
        public async Task<bool> InsertAsync(T entity)
        {
            if (entity == null)
            {
                throw new ArgumentNullException(nameof(entity));
            }

            return await _db.Insertable(entity).ExecuteCommandAsync() > 0;
        }

        /// <summary>
        /// 异步更新一个已存在的实体
        /// </summary>
        /// <param name="entity">要更新的实体</param>
        /// <returns>如果更新成功返回true，否则返回false</returns>
        public async Task<bool> UpdateAsync(T entity)
        {
            if (entity == null)
            {
                throw new ArgumentNullException(nameof(entity));
            }

            return await _db.Updateable(entity).ExecuteCommandAsync() > 0;
        }

        #endregion

        #region 批量操作异步方法

        /// <summary>
        /// 批量插入实体（异步）
        /// </summary>
        /// <param name="entities">要插入的实体集合</param>
        /// <returns>插入的记录数</returns>
        public async Task<int> BulkInsertAsync(IEnumerable<T> entities)
        {
            if (entities == null)
            {
                throw new ArgumentNullException(nameof(entities));
            }

            return await _db.Insertable(entities.ToArray()).ExecuteCommandAsync();
        }

        /// <summary>
        /// 批量更新实体（异步）
        /// </summary>
        /// <param name="entities">要更新的实体集合</param>
        /// <returns>更新的记录数</returns>
        public async Task<int> BulkUpdateAsync(IEnumerable<T> entities)
        {
            if (entities == null)
            {
                throw new ArgumentNullException(nameof(entities));
            }

            return await _db.Updateable(entities.ToArray()).ExecuteCommandAsync();
        }

        /// <summary>
        /// 批量删除实体（异步）
        /// </summary>
        /// <param name="ids">要删除的实体ID集合</param>
        /// <returns>删除的记录数</returns>
        public async Task<int> BulkDeleteAsync(IEnumerable<object> ids)
        {
            if (ids == null)
            {
                throw new ArgumentNullException(nameof(ids));
            }

            return await _db.Deleteable<T>().In(ids).ExecuteCommandAsync();
        }

        #endregion
    }

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.
• 31.
• 32.
• 33.
• 34.
• 35.
• 36.
• 37.
• 38.
• 39.
• 40.
• 41.
• 42.
• 43.
• 44.
• 45.
• 46.
• 47.
• 48.
• 49.
• 50.
• 51.
• 52.
• 53.
• 54.
• 55.
• 56.
• 57.
• 58.
• 59.
• 60.
• 61.
• 62.
• 63.
• 64.
• 65.
• 66.
• 67.
• 68.
• 69.
• 70.
• 71.
• 72.
• 73.
• 74.
• 75.
• 76.
• 77.
• 78.
• 79.
• 80.
• 81.
• 82.
• 83.
• 84.
• 85.
• 86.
• 87.
• 88.
• 89.
• 90.
• 91.
• 92.
• 93.
• 94.
• 95.
• 96.
• 97.
• 98.
• 99.
• 100.
• 101.
• 102.
• 103.
• 104.
• 105.
• 106.
• 107.
• 108.
• 109.
• 110.
• 111.
• 112.
• 113.
• 114.
• 115.
• 116.
• 117.
• 118.
• 119.
• 120.
• 121.
• 122.
• 123.
• 124.
• 125.
• 126.
• 127.
• 128.
• 129.
• 130.
• 131.
• 132.
• 133.
• 134.
• 135.
• 136.
• 137.
• 138.
• 139.
• 140.
• 141.
• 142.
• 143.
• 144.
• 145.
• 146.
• 147.
• 148.
• 149.
• 150.
• 151.
• 152.
• 153.
• 154.
• 155.
• 156.
• 157.
• 158.
• 159.
• 160.
• 161.
• 162.
• 163.
• 164.
• 165.
• 166.
• 167.
• 168.
• 169.
• 170.
• 171.
• 172.
• 173.
• 174.
• 175.
• 176.
• 177.
• 178.
• 179.
• 180.
• 181.
• 182.
• 183.
• 184.
• 185.
• 186.
• 187.
• 188.
• 189.
• 190.
• 191.

对应的实现方法

2、控制器实现方法

登录后复制

/// <summary>
    /// Sugar写DM方法控制器
    /// </summary>
    [Route("api/[controller]/[action]")]
    [ApiController]
    public class SugarDMController : ControllerBase
    {
        private readonly IUserInforRepository user;
        private readonly IBoolRepository boolRepository;
        private readonly IUserBoolModelRepository ub;

        public SugarDMController(IUserInforRepository user, IBoolRepository boolRepository, IUserBoolModelRepository ub)
        {
            this.user = user;
            this.boolRepository = boolRepository;
            this.ub = ub;
        }

        #region 显示

        /// <summary>
        /// 显示用户信息
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public async Task<IActionResult> GetUser()
        {
            return Ok(await user.GetAllAsync());
        }
        /// <summary>
        /// 显示Bool信息
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public async Task<IActionResult> GetBools()
        {
            return Ok(await boolRepository.GetAllAsync());
        }
        /// <summary>
        /// 查询全部信息
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public async Task<IActionResult> GetAlls()
        {
            var users = (await user.GetAllAsync()).ToList();
            var ubs = (await ub.GetAllAsync()).ToList();
            var bools = (await ub.GetAllAsync()).ToList();
            var list = (from a in users
                        join b in ubs on a.UserId equals b.UserId
                       join c in bools on b.BId equals c.BId
                       select new { a, b, c }).ToList();
            return Ok(list);
        }

        #endregion

        #region 添加

        /// <summary>
        /// 添加用户信息
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> AddUser(UserInfor? users)
        {
            return Ok(await user.InsertAsync(users));
        }
        /// <summary>
        /// 批量添加用户信息
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> AddsUser(List<UserInfor> users)
        {
            return Ok(await user.BulkInsertAsync(users));
        }
        /// <summary>
        /// 添加Bool信息
        /// </summary>
        /// <param name="bools"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> AddBool (Bool bools)
        {
            return Ok(await boolRepository.InsertAsync(bools));
        }
        /// <summary>
        /// 添加关系表数据
        /// </summary>
        /// <param name="ubs"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> AddUBModel(UserBoolModel ubs)
        {
            return Ok(await ub.InsertAsync(ubs));
        }

        #endregion

        #region 删除

        /// <summary>
        /// 批量删除用户信息
        /// </summary>
        /// <returns></returns>
        [HttpDelete]
        public async Task<IActionResult> DelsUser(string ids)
        {
            string[] idsz = ids.Split(',');
            return Ok(await user.BulkDeleteAsync(idsz));
        }

        #endregion

        #region 修改

        /// <summary>
        /// 修改用户信息
        /// </summary>
        /// <returns></returns>
        [HttpPut]
        public async Task<IActionResult> UpdUser(UserInfor users)
        {
            return Ok(await user.UpdateAsync(users));
        }

        #endregion
    }

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.
• 31.
• 32.
• 33.
• 34.
• 35.
• 36.
• 37.
• 38.
• 39.
• 40.
• 41.
• 42.
• 43.
• 44.
• 45.
• 46.
• 47.
• 48.
• 49.
• 50.
• 51.
• 52.
• 53.
• 54.
• 55.
• 56.
• 57.
• 58.
• 59.
• 60.
• 61.
• 62.
• 63.
• 64.
• 65.
• 66.
• 67.
• 68.
• 69.
• 70.
• 71.
• 72.
• 73.
• 74.
• 75.
• 76.
• 77.
• 78.
• 79.
• 80.
• 81.
• 82.
• 83.
• 84.
• 85.
• 86.
• 87.
• 88.
• 89.
• 90.
• 91.
• 92.
• 93.
• 94.
• 95.
• 96.
• 97.
• 98.
• 99.
• 100.
• 101.
• 102.
• 103.
• 104.
• 105.
• 106.
• 107.
• 108.
• 109.
• 110.
• 111.
• 112.
• 113.
• 114.
• 115.
• 116.
• 117.
• 118.
• 119.
• 120.
• 121.
• 122.
• 123.
• 124.
• 125.
• 126.
• 127.
• 128.
• 129.

写了一些方法实现的模版

二、  使用DM高级语法

1、  索引

虚索引和实索引：

虚索引是指在创建表的时候如果Id是主键自增的情况自动创建的索引，SqlServer不 支持虚索引

实索引就是除了虚索引之外的所有索引

聚集索引和非聚集索引：

使用DM数据库创建聚集索引的语句是CREATE CLUSTER INDEX C1 on T1(ID);

非聚集索引是CREATE INDEX S1 on T1(NAME);并且如果该表有主键自增的情况下无法 创建索引。

而SqlServer创建聚集索引的语句是CREATE CLUSTERED INDEX index_name ON table_name (column_name);非聚集索引的语句是CREATE NONCLUSTERED INDEXindex_name ON table_name (column_name);并且因为SqlServer没有虚索引所以 表id不管是不是主键都可以创建索引

优化

一、 解决名称必须全部大写的问题

创建数据库的时候取消字符串比较大小写敏感即可

原创作者: u_16904191 转载于: https://blog.51cto.com/u_16904191/11480747