AI 助理
备案控制台
开发者社区 数据库 文章 正文

DataAccess通用数据库访问类，简单易用，功能强悍

2017-11-16 997
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

以下是我编写的DataAccess通用数据库访问类，简单易用，支持：内联式创建多个参数、支持多事务提交、支持参数复用、支持更换数据库类型，希望能帮到大家，若需支持查出来后转换成实体，可以自行扩展datarow转实体类，也可以搭配dapper.net实现更强大的功能。

复制代码 
    /// <summary>
    /// 通用数据库访问类，支持多种数据库，无直接依赖某个数据库组件
    /// 作者：左文俊
    /// 日期：2016-6-3(修订：2017-6-1)
    /// </summary>
    public class DataAccess : IDisposable
    {
        [ThreadStatic]
        private static DbProviderFactory _dbProviderFactory = null;

        [ThreadStatic]
        private static string _connectionString = string.Empty;

        [ThreadStatic]
        public static string ConnectionStringName = string.Empty;

        private DbProviderFactory dbProviderFactory = null;
        private string connectionString = string.Empty;

        private DbConnection dbConnection = null;
        private DbTransaction dbTransaction = null;
        private bool useTransaction = false;
        private bool disposed = false;
        private bool committed = false;

        private ParameterHelperClass paramHelper = null;

        public DataAccess()
            : this("default")
        { }

        public DataAccess(string cnnStringName, Func<string, string> DecryptCnnStringFunc = null)
        {
            if (!string.Equals(ConnectionStringName, cnnStringName, StringComparison.OrdinalIgnoreCase) ||
                _dbProviderFactory == null || _connectionString == null)
            {
                ConnectionStringName = cnnStringName;
                var cnnStringSection = ConfigurationManager.ConnectionStrings[cnnStringName];
                _dbProviderFactory = DbProviderFactories.GetFactory(cnnStringSection.ProviderName);
                _connectionString = cnnStringSection.ConnectionString;
                if (DecryptCnnStringFunc != null)
                {
                    _connectionString = DecryptCnnStringFunc(_connectionString);
                }
            }
            dbProviderFactory = _dbProviderFactory;
            connectionString = _connectionString;

            paramHelper = new ParameterHelperClass(this);
        }

        public DataAccess(string cnnString, string providerName)
        {
            if (!string.Equals(_connectionString, cnnString, StringComparison.OrdinalIgnoreCase) || _dbProviderFactory == null)
            {
                ConnectionStringName = string.Empty;
                _connectionString = cnnString;
                _dbProviderFactory = DbProviderFactories.GetFactory(providerName);
            }
            dbProviderFactory = _dbProviderFactory;
            connectionString = _connectionString;

            paramHelper = new ParameterHelperClass(this);
        }


        #region 私有方法

        private DbConnection GetDbConnection()
        {

            if (dbConnection == null)
            {
                dbConnection = dbProviderFactory.CreateConnection();
                dbConnection.ConnectionString = connectionString;
            }

            if (dbConnection.State == ConnectionState.Closed)
            {
                dbConnection.Open();
            }

            if (useTransaction && dbTransaction == null)
            {
                dbTransaction = dbConnection.BeginTransaction();
                committed = false;
            }

            return dbConnection;
        }



        private DbCommand BuildDbCommand(string sqlCmdText, CommandType cmdType = CommandType.Text, DbParameter[] parameters = null)
        {
            var dbCmd = dbProviderFactory.CreateCommand();
            var dbConn = GetDbConnection();
            dbCmd.Connection = dbConn;
            dbCmd.CommandText = sqlCmdText;
            dbCmd.CommandType = cmdType;
            dbCmd.CommandTimeout = 30 * 60;
            if (useTransaction)
            {
                dbCmd.Transaction = dbTransaction;
            }

            if (parameters != null)
            {
                dbCmd.Parameters.AddRange(parameters);
            }

            return dbCmd;
        }

        private DbCommand BuildDbCommand(string sqlCmdText, CommandType cmdType = CommandType.Text, IDictionary<string, object> paramNameValues = null)
        {
            List<DbParameter> parameters = new List<DbParameter>();
            if (paramNameValues != null)
            {
                foreach (var item in paramNameValues)
                {
                    parameters.Add(BuildDbParameter(item.Key, item.Value));
                }
            }
            return BuildDbCommand(sqlCmdText, cmdType, parameters.ToArray());
        }




        private DbCommand BuildDbCommand(string sqlCmdText, CommandType cmdType = CommandType.Text, params object[] paramObjs)
        {
            if (paramObjs != null && paramObjs.Length > 0)
            {
                if (paramObjs[0] is IDictionary<string, object>)
                {
                    return BuildDbCommand(sqlCmdText, cmdType, paramObjs[0] as IDictionary<string, object>);
                }
                else if (paramObjs is DbParameter[])
                {
                    return BuildDbCommand(sqlCmdText, cmdType, paramObjs as DbParameter[]);
                }
                else
                {
                    List<DbParameter> parameters = new List<DbParameter>();
                    for (int i = 0; i < paramObjs.Length; i++)
                    {
                        parameters.Add(BuildDbParameter("@p" + i.ToString(), paramObjs[i]));
                    }
                    return BuildDbCommand(sqlCmdText, cmdType, parameters.ToArray());
                }
            }
            else
            {
                return BuildDbCommand(sqlCmdText, cmdType, parameters: null);
            }
        }


        private void ClearCommandParameters(DbCommand cmd)
        {
            bool canClear = true;
            if (cmd.Connection != null && cmd.Connection.State != ConnectionState.Open)
            {
                foreach (DbParameter commandParameter in cmd.Parameters)
                {
                    if (commandParameter.Direction != ParameterDirection.Input)
                    {
                        canClear = false;
                        break;
                    }
                }
            }
            if (canClear)
            {
                cmd.Parameters.Clear();
            }
        }


        #endregion

        #region 公共方法

        public void UseTransaction()
        {
            useTransaction = true;
        }


        public void Commit()
        {
            if (dbTransaction != null && useTransaction)
            {
                dbTransaction.Commit();
                dbTransaction.Dispose();
                dbTransaction = null;
                committed = true;
                useTransaction = false;
            }
        }


        public DbParameter BuildDbParameter(string name, object value)
        {
            DbParameter parameter = dbProviderFactory.CreateParameter();
            parameter.ParameterName = name;
            parameter.Value = value != null ? value : DBNull.Value;
            return parameter;
        }

        public DbParameter BuildDbParameter(string name, object value, DbType dbType, int size = -1, ParameterDirection direction = ParameterDirection.Input)
        {
            DbParameter parameter = dbProviderFactory.CreateParameter();
            parameter.ParameterName = name;
            parameter.Value = value != null ? value : DBNull.Value;
            parameter.DbType = dbType;
            parameter.Direction = direction;
            if (size != -1)
            {
                parameter.Size = size;
            }
            return parameter;
        }

        public DbParameter BuildDbParameter(string name, DbType dbType, string srcColumn, int size = -1, bool srcColumnNullMapping = true, ParameterDirection direction = ParameterDirection.Input)
        {
            DbParameter parameter = dbProviderFactory.CreateParameter();
            parameter.ParameterName = name;
            parameter.SourceColumn = srcColumn;
            parameter.SourceColumnNullMapping = srcColumnNullMapping;
            parameter.DbType = dbType;
            parameter.Direction = direction;
            if (size != -1)
            {
                parameter.Size = size;
            }
            return parameter;
        }

        public DbDataReader ExecuteReader(string sqlCmdText, CommandType cmdType = CommandType.Text, params object[] paramObjs)
        {
            var dbCmd = BuildDbCommand(sqlCmdText, cmdType, paramObjs);
            var dr = dbCmd.ExecuteReader();
            ClearCommandParameters(dbCmd);
            return dr;
        }


        public T ExecuteScalar<T>(string sqlCmdText, CommandType cmdType = CommandType.Text, params object[] paramObjs)
        {
            T returnValue = default(T);
            var dbCmd = BuildDbCommand(sqlCmdText, cmdType, paramObjs);
            object result = dbCmd.ExecuteScalar();
            try
            {
                returnValue = (T)Convert.ChangeType(result, typeof(T));
            }
            catch
            { }
            ClearCommandParameters(dbCmd);
            return returnValue;
        }

        public DataSet ExecuteDataSet(string sqlCmdText, CommandType cmdType = CommandType.Text, params object[] paramObjs)
        {
            var dbCmd = BuildDbCommand(sqlCmdText, cmdType, paramObjs);
            var dbAdapter = dbProviderFactory.CreateDataAdapter();
            dbAdapter.SelectCommand = dbCmd;
            DataSet returnDataSet = new DataSet();
            dbAdapter.Fill(returnDataSet);
            ClearCommandParameters(dbCmd);
            return returnDataSet;
        }

        public DataTable ExecuteDataTable(string sqlCmdText, CommandType cmdType = CommandType.Text, params object[] paramObjs)
        {
            DataTable returnTable = new DataTable();
            DataSet resultDataSet = ExecuteDataSet(sqlCmdText, cmdType, paramObjs);
            if (resultDataSet != null && resultDataSet.Tables.Count > 0)
            {
                returnTable = resultDataSet.Tables[0];
            }
            return returnTable;
        }

        public int ExecuteCommand(string sqlCmdText, CommandType cmdType = CommandType.Text, params object[] paramObjs)
        {
            var dbCmd = BuildDbCommand(sqlCmdText, cmdType, paramObjs);
            int execResult = dbCmd.ExecuteNonQuery();
            ClearCommandParameters(dbCmd);
            return execResult;
        }

        public int BatchExecuteCommand(string sqlCmdText, DbParameter[] sqlParams, DataTable srcTable, int batchSize = 0, bool needAllReChange = true)
        {
            var dbCmd = BuildDbCommand(sqlCmdText, CommandType.Text, sqlParams);
            dbCmd.UpdatedRowSource = System.Data.UpdateRowSource.None;
            var dbAdapter = dbProviderFactory.CreateDataAdapter();
            dbAdapter.AcceptChangesDuringUpdate = false;
            sqlCmdText = sqlCmdText.Trim();
            string bathExecType = System.Text.RegularExpressions.Regex.Match(sqlCmdText, @"^\w+\b").Value.ToUpper();
            if (needAllReChange)
            {
                srcTable.AcceptChanges();
            }

            switch (bathExecType)
            {
                case "INSERT":
                    {
                        dbAdapter.InsertCommand = dbCmd;
                        if (needAllReChange)
                        {
                            foreach (DataRow row in srcTable.Rows) row.SetAdded();
                        }
                        break;
                    }
                case "UPDATE":
                    {
                        dbAdapter.UpdateCommand = dbCmd;
                        if (needAllReChange)
                        {
                            foreach (DataRow row in srcTable.Rows) row.SetModified();
                        }
                        break;
                    }
                case "DELETE":
                    {
                        dbAdapter.DeleteCommand = dbCmd;
                        if (needAllReChange)
                        {
                            for (int r = srcTable.Rows.Count - 1; r >= 0; r--) srcTable.Rows[r].Delete();
                        }
                        break;
                    }
                default:
                    {
                        throw new ArgumentException("无效的SQL命令！", "sqlCmdText");
                    }
            }

            dbAdapter.UpdateBatchSize = batchSize;
            int execResult = dbAdapter.Update(srcTable); ;
            ClearCommandParameters(dbCmd);
            return execResult;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }


        #endregion


        private void Dispose(bool disposing)
        {
            if (!disposed)
            {
                try
                {
                    if (disposing)
                    {
                        //释放托管资源
                    }

                    if (dbTransaction != null)
                    {
                        if (!committed)
                        {
                            dbTransaction.Rollback();
                        }
                        dbTransaction.Dispose();
                    }

                    if (dbConnection != null)
                    {
                        if (dbConnection.State != ConnectionState.Closed)
                        {
                            dbConnection.Close();
                        }
                        dbConnection.Dispose();
                    }
                }
                catch
                { }

                disposed = true;
            }
        }

        ~DataAccess()
        {
            Dispose(false);
        }



        public ParameterHelperClass ParameterHelper
        {
            get
            {
                return paramHelper;
            }
        }


        public class ParameterHelperClass
        {
            private List<DbParameter> parameterList = null;
            private DataAccess parent = null;

            public ParameterHelperClass(DataAccess da)
            {
                parent = da;
                parameterList = new List<DbParameter>();
            }

            public ParameterHelperClass AddParameter(string name, object value)
            {
                parameterList.Add(parent.BuildDbParameter(name, value));
                return this;
            }

            public ParameterHelperClass AddParameter(string name, object value, DbType dbType, int size = -1, ParameterDirection direction = ParameterDirection.Input)
            {
                parameterList.Add(parent.BuildDbParameter(name, value, dbType, size, direction));
                return this;
            }

            public ParameterHelperClass AddParameter(string name, DbType dbType, string srcColumn, int size = -1, bool srcColumnNullMapping = true, ParameterDirection direction = ParameterDirection.Input)
            {
                parameterList.Add(parent.BuildDbParameter(name, dbType, srcColumn, size, srcColumnNullMapping, direction));
                return this;
            }

            public ParameterHelperClass AddParametersWithValue(params object[] paramValues)
            {
                for (int i = 0; i < paramValues.Length; i++)
                {
                    parameterList.Add(parent.BuildDbParameter("@p" + i.ToString(), paramValues[i]));
                }
                return this;
            }

            public DbParameter[] ToParameterArray()
            {
                var paramList = parameterList;
                parameterList = new List<DbParameter>();
                return paramList.ToArray();
            }

        }


    }
复制代码

 

　　

多种灵活用法，使用示例代码如下：

用法一：采用内联式创建参数数组对象，然后执行SQL命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
using  (DataAccess da =  new  DataAccess())
{
     var  programInfo =  new  ProgramInfo() { Name= "test" , Version= "1.0" , InstalledLocation=AppDomain.CurrentDomain.BaseDirectory };
 
     var  parameters = da.ParameterHelper.AddParameter( "@Mbno" ,  "188231670**" )
               .AddParameter( "@Msg" ,  string .Format( "程序名：{0}，版本：{1}，安装路径：{2}，已停止运行了，请尽快处理！" ,
                             programInfo.Name, programInfo.Version, programInfo.InstalledLocation))
               .AddParameter( "@SendTime" , DateTime.Now)
               .AddParameter( "@KndType" ,  "监控异常通知" )
               .ToParameterArray();
 
     da.ExecuteCommand( "insert into OutBox(Mbno,Msg,SendTime,KndType) values(@Mbno,@Msg,@SendTime,@KndType)" , paramObjs: parameters);
 
}

用法二：在用法一基础上使用事务来进行提交

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
using  (DataAccess da =  new  DataAccess())
{
     var  programInfo =  new  ProgramInfo() { Name =  "test" , Version =  "1.0" , InstalledLocation = AppDomain.CurrentDomain.BaseDirectory };
 
     var  parameters = da.ParameterHelper.AddParameter( "@Mbno" ,  "188231670**" )
               .AddParameter( "@Msg" ,  string .Format( "程序名：{0}，版本：{1}，安装路径：{2}，已停止运行了，请尽快处理！" ,
                             programInfo.Name, programInfo.Version, programInfo.InstalledLocation))
               .AddParameter( "@SendTime" , DateTime.Now)
               .AddParameter( "@KndType" ,  "监控异常通知" )
               .ToParameterArray();
 
     da.UseTransaction();
 
     da.ExecuteCommand( "insert into OutBox(Mbno,Msg,SendTime,KndType) values(@Mbno,@Msg,@SendTime,@KndType)" , paramObjs: parameters);
 
     da.Commit();
}

用法三：在用法二基础上使用事务一次性执行多个SQL命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
using  (DataAccess da =  new  DataAccess())
{
     var  programInfo =  new  ProgramInfo() { Name =  "test" , Version =  "1.0" , InstalledLocation = AppDomain.CurrentDomain.BaseDirectory };
 
     var  parameters = da.ParameterHelper.AddParameter( "@Mbno" ,  "188231670**" )
               .AddParameter( "@Msg" ,  string .Format( "程序名：{0}，版本：{1}，安装路径：{2}，已停止运行了，请尽快处理！" ,
                             programInfo.Name, programInfo.Version, programInfo.InstalledLocation))
               .AddParameter( "@SendTime" , DateTime.Now)
               .AddParameter( "@KndType" ,  "监控异常通知" )
               .ToParameterArray();
 
     da.UseTransaction();
 
     da.ExecuteCommand( "insert into OutBox(Mbno,Msg,SendTime,KndType) values(@Mbno,@Msg,@SendTime,@KndType)" , paramObjs: parameters);
 
     da.ExecuteCommand( "insert into OutBox(Mbno,Msg,SendTime,KndType) values(@Mbno,@Msg,@SendTime,@KndType)" , paramObjs: parameters);
 
     da.Commit();
}

用法四：在用法一基础上使用多个事务来执行多个SQL并进行多次提交

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
using  (DataAccess da =  new  DataAccess())
{
     var  programInfo =  new  ProgramInfo() { Name =  "test" , Version =  "1.0" , InstalledLocation = AppDomain.CurrentDomain.BaseDirectory };
 
     var  parameters = da.ParameterHelper.AddParameter( "@Mbno" ,  "188231670**" )
               .AddParameter( "@Msg" ,  string .Format( "程序名：{0}，版本：{1}，安装路径：{2}，已停止运行了，请尽快处理！" ,
                             programInfo.Name, programInfo.Version, programInfo.InstalledLocation))
               .AddParameter( "@SendTime" , DateTime.Now)
               .AddParameter( "@KndType" ,  "监控异常通知" )
               .ToParameterArray();
 
     da.UseTransaction();
 
     da.ExecuteCommand( "insert into OutBox(Mbno,Msg,SendTime,KndType) values(@Mbno,@Msg,@SendTime,@KndType)" , paramObjs: parameters);
 
     da.Commit();
 
     da.UseTransaction();
 
     da.ExecuteCommand( "insert into OutBox(Mbno,Msg,SendTime,KndType) values(@Mbno,@Msg,@SendTime,@KndType)" , paramObjs: parameters);
 
     da.Commit();
}

用法五：事务提交+SQL命令查询

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
using  (DataAccess da =  new  DataAccess())
{
     var  programInfo =  new  ProgramInfo() { Name =  "test" , Version =  "1.0" , InstalledLocation = AppDomain.CurrentDomain.BaseDirectory };
 
     var  parameters = da.ParameterHelper.AddParameter( "@Mbno" ,  "188231670**" )
               .AddParameter( "@Msg" ,  string .Format( "程序名：{0}，版本：{1}，安装路径：{2}，已停止运行了，请尽快处理！" ,
                             programInfo.Name, programInfo.Version, programInfo.InstalledLocation))
               .AddParameter( "@SendTime" , DateTime.Now)
               .AddParameter( "@KndType" ,  "监控异常通知" )
               .ToParameterArray();
 
     da.UseTransaction();
 
     da.ExecuteCommand( "insert into OutBox(Mbno,Msg,SendTime,KndType) values(@Mbno,@Msg,@SendTime,@KndType)" , paramObjs: parameters);
 
     da.Commit();
 
     parameters = da.ParameterHelper.AddParameter( "@Mbno" ,  "188231670**" ).ToParameterArray();
     var  table = da.ExecuteDataTable( "select Mbno,Msg,SendTime,KndType from OutBox where Mbno=@Mbno" , paramObjs: parameters);
     System.Windows.Forms.MessageBox.Show(table.Rows.Count.ToString());
}

用法六：不采用内联方式创建参数，而是执行SQL命令时直接传入各类型的参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using  (DataAccess da =  new  DataAccess())
{
     var  programInfo =  new  ProgramInfo() { Name =  "test" , Version =  "1.0" , InstalledLocation = AppDomain.CurrentDomain.BaseDirectory };
 
 
     da.ExecuteCommand( "insert into OutBox(Mbno,Msg,SendTime,KndType) values(@Mbno,@Msg,@SendTime,@KndType)" ,
                         System.Data.CommandType.Text,
                      new  Dictionary< string ,  object > {
                         { "@Mbno" ,  "188231670**" },
                         { "@Msg" ,  string .Format( "程序名：{0}，版本：{1}，安装路径：{2}，已停止运行了，请尽快处理！" ,
                             programInfo.Name, programInfo.Version, programInfo.InstalledLocation)},
                         { "@SendTime" , DateTime.Now},
                         { "@KndType" ,  "监控异常通知" }
                      });
 
 
     var  table = da.ExecuteDataTable( "select Mbno,Msg,SendTime,KndType from OutBox where Mbno=@p0" ,
                                     System.Data.CommandType.Text,
                                     "188231670**" //若采用直接是输入值数组，那么SQL命令中的参数占位符必需定义成：@p0,@p1...
                                 );
     System.Windows.Forms.MessageBox.Show(table.Rows.Count.ToString());
}

用法七：除了上面使用DataAccess.ParameterHelper属性的AddParameter(string name, object value)方法来创建参数，还可以使用AddParameter(string name, object value, DbType dbType, ParameterDirection direction = ParameterDirection.Input)来创建指定输入输出及类型的参数，还有AddParametersWithValue(params object[] paramValues)来根据值数组创建参数

若需要更换数据库类型，只需要在配置文件的connectionStrings节点加入相关的连接子节点，注意providerName特性，providerName常用的如下：

Aceess数据库：providerName="System.Data.OleDb"

Oracle 数据库：providerName="System.Data.OracleClient"或者providerName="Oracle.DataAccess.Client"

SQLite数据库：providerName="System.Data.SQLite"

SQL SERVER数据库：providerName="System.Data.SqlClient"

MYSQL数据库：providerName="MySql.Data.MySqlClient"

ODBC连接数据库:providerName="System.Data.Odbc"

 

本文转自 梦在旅途 博客园博客，原文链接：http://www.cnblogs.com/zuowj/p/5557193.html  ，如需转载请自行联系原作者

文章标签：
数据库
SQL
监控
关系型数据库
数据库管理
MySQL
Oracle
数据库连接
关键词：
数据库访问
数据库访问类
数据库访问功能
数据库类功能
技术小牛人
目录
相关文章
游客762btuqu5wybw666
|
2月前
|
消息中间件 缓存 监控
优化微服务架构中的数据库访问：策略与最佳实践
在微服务架构中，数据库访问的效率直接影响到系统的性能和可扩展性。本文探讨了优化微服务架构中数据库访问的策略与最佳实践，包括数据分片、缓存策略、异步处理和服务间通信优化。通过具体的技术方案和实例分析，提供了一系列实用的建议，以帮助开发团队提升微服务系统的响应速度和稳定性。
游客762btuqu5wybw666
83 6
刘大猫.
|
2月前
|
XML 数据库 数据格式
数据库 校验名称唯一性，用于新增和修改功能
数据库 校验名称唯一性，用于新增和修改功能
刘大猫.
49 1
游客762btuqu5wybw666
|
2月前
|
消息中间件 缓存 监控
优化微服务架构中的数据库访问：策略与实践
随着微服务架构的普及，如何高效管理和优化数据库访问成为了关键挑战。本文探讨了在微服务环境中优化数据库访问的策略，包括数据库分片、缓存机制、异步处理等技术手段。通过深入分析实际案例和最佳实践，本文旨在为开发者提供实际可行的解决方案，以提升系统性能和可扩展性。
游客762btuqu5wybw666
50 6
土木林森
|
2月前
|
SQL NoSQL Java
彻底革新你的数据库操作体验！Micronaut数据访问技巧让你瞬间爱上代码编写！
【9月更文挑战第10天】Java开发者们一直在寻找简化应用程序与数据库交互的方法。Micronaut作为一个现代框架，提供了多种工具和特性来提升数据访问效率。本文介绍如何使用Micronaut简化数据库操作，并提供具体示例代码。Micronaut支持JPA/Hibernate、SQL及NoSQL（如MongoDB），简化配置并无缝集成。通过定义带有`@Repository`注解的接口，可以实现Spring Data风格的命名查询。
土木林森
55 6
长梦
|
2月前
|
SQL 存储 关系型数据库
C#一分钟浅谈：使用 ADO.NET 进行数据库访问
【9月更文挑战第3天】在.NET开发中，与数据库交互至关重要。ADO.NET是Microsoft提供的用于访问关系型数据库的类库，包含连接数据库、执行SQL命令等功能。本文从基础入手，介绍如何使用ADO.NET进行数据库访问，并提供示例代码，同时讨论常见问题及其解决方案，如连接字符串错误、SQL注入风险和资源泄露等，帮助开发者更好地利用ADO.NET提升应用的安全性和稳定性。
长梦
176 6
众所周知
|
2月前
|
SQL 关系型数据库 分布式数据库
PolarDB Proxy配置与优化：提升数据库访问效率
【9月更文挑战第6天】PolarDB是阿里云推出的高性能分布式关系型数据库，PolarDB Proxy作为其关键组件，位于客户端与PolarDB集群间，负责SQL请求的解析与转发，并支持连接池管理、SQL过滤及路由规则等功能。本文详细介绍了PolarDB Proxy的配置方法，包括连接池、负载均衡和SQL过滤设置，并探讨了监控调优、缓存及网络优化策略，以帮助提升数据库访问效率。
众所周知
41 1
张志凌
|
2月前
|
SQL 安全 Java
探索研究Servlet 数据库访问
【9月更文挑战第28天】
张志凌
26 0
zzy的aly
|
15天前
|
存储 SQL 关系型数据库
Mysql学习笔记(二)：数据库命令行代码总结
这篇文章是关于MySQL数据库命令行操作的总结，包括登录、退出、查看时间与版本、数据库和数据表的基本操作（如创建、删除、查看）、数据的增删改查等。它还涉及了如何通过SQL语句进行条件查询、模糊查询、范围查询和限制查询，以及如何进行表结构的修改。这些内容对于初学者来说非常实用，是学习MySQL数据库管理的基础。
zzy的aly
64 6
m1a6
|
13天前
|
存储 关系型数据库 MySQL
Mysql(4)—数据库索引
数据库索引是用于提高数据检索效率的数据结构，类似于书籍中的索引。它允许用户快速找到数据，而无需扫描整个表。MySQL中的索引可以显著提升查询速度，使数据库操作更加高效。索引的发展经历了从无索引、简单索引到B-树、哈希索引、位图索引、全文索引等多个阶段。
m1a6
48 3
Mysql(4)—数据库索引
众所周知
|
1天前
|
存储 关系型数据库 MySQL
MySQL vs. PostgreSQL：选择适合你的开源数据库
在众多开源数据库中，MySQL和PostgreSQL无疑是最受欢迎的两个。它们都有着强大的功能、广泛的社区支持和丰富的生态系统。然而，它们在设计理念、性能特点、功能特性等方面存在着显著的差异。本文将从这三个方面对MySQL和PostgreSQL进行比较，以帮助您选择更适合您需求的开源数据库。
众所周知
13 4

热门文章

最新文章

  • 1
    一个免费功能强大的谷歌翻译api
  • 2
    阿里JAVA手册之MySQL数据库 （建表规约、索引规约、SQL语句、ORM映射）
  • 3
    Intellij IDEA 查找接口实现类的快捷键
  • 4
    淘宝 NPM 镜像
  • 5
    阿里Java代码规约插件即将全球首发，邀您来发布仪式现场
  • 6
    数据库中的Schema和Database的区别
  • 7
    RDS入门——Excel文件转存到RDS数据库实践
  • 8
    分布式关系型数据库服务 DRDS 提供全新规格实例
  • 9
    深入分析Oracle数据库中的checkpoint_change#
  • 10
    JBPM5.3入门及SQLServer2008数据库转移
  • 1
    达梦数据库Windows安装教程：从准备到完成
    235
  • 2
    深入了解达梦数据库的增删查改操作：从入门到精通
    383
  • 3
    Java数据库编程实践：连接与操作数据库
    46
  • 4
    C#SQL Server数据库基本操作（增、删、改、查）
    165
  • 5
    ICDE2024 ｜VDTuner：向量数据库自动调优技术
    153
  • 6
    关系型数据库的并发处理能力限制
    77
  • 7
    关系型数据库的单点故障风险
    89
  • 8
    数据库数据恢复—Sql Server数据库文件丢失的数据恢复案例
    63
  • 9
    数据库、OS内核安全等精彩继续！龙蜥大讲堂 5 月直播预告来袭
    620
  • 10
    不要将数据库中的“分库分表”理论盲目应用到 Elasticsearch
    46

    • 相关课程

    更多
  • 数据库的前世今生
  • 数据库核心概念
  • 从传统数据库到云数据库演进
  • 数据库常见问题排查
  • 数据库及SQL/MySQL基础
  • 高校精品课-西安交通大学 -数据库理论与技术

    • 相关电子书

    更多
  • DTCC 2022大会集锦《云原生一站式数据库技术与实践》
  • 阿里云瑶池数据库精要2022版
  • 2022 DTCC-阿里云一站式数据库上云最佳实践

    • 相关实验场景

    更多
  • 数据库实验室挑战任务-高级任务
  • 数据库实验室挑战任务-中级任务
  • 数据库实验室挑战任务-初级任务
  • 阿里云数据库产品实验室
  • MongoDB数据库入门
  • 使用DAS实现数据库自动扩容和回缩
    • 下一篇
    【阿里云OSS】You have no right to access this object because of bucket acl.