AQO.NET实现数据操作封装

最新推荐文章于 2024-08-22 09:32:09 发布
最新推荐文章于 2024-08-22 09:32:09 发布
阅读量88 收藏
点赞数
原文链接：http://www.cnblogs.com/fqzhong2007/p/8336594.html
版权

经过个人学习和项目经验，总结关于ADO.NET实现数据查询操作的方法做简单封装，希望喜欢的朋友点赞并收藏。话不多说，直接上代码：

/// <summary>
        /// 数据库连接字符串
        /// </summary>
        protected static string ConnectionString
        {
            get
            {
                return ConfigurationManager.ConnectionStrings["FTRTPContext"].ConnectionString;
            }
        }

        /// <summary>
        /// 数据库实例工厂
        /// </summary>
        protected static DbProviderFactory DbProvider
        {
            get
            {
                string providerName = ConfigurationManager.ConnectionStrings["FTRTPContext"].ProviderName;
                return DbProviderFactories.GetFactory(providerName);
            }
        }

        /// <summary>
        /// 创建一个DbParameter参数对象
        /// </summary>
        /// <param name="parameterName">参数名称</param>
        /// <param name="val">参数值</param>
        /// <returns>DbParameter对象</returns>
        public virtual DbParameter CreateDbParameter(string parameterName, object val)
        {
            var parame = DbProvider.CreateParameter();
            parame.ParameterName = parameterName;
            parame.Value = val;
            return parame;
        }

        /// <summary>
        /// 创建一个DbParameter参数对象
        /// </summary>
        /// <param name="parameterName">参数名称</param>
        /// <param name="dbType">参数类型</param>
        /// <param name="dbSize">参数大小(字节),short/Int16=2;float/int/Int32=4;double/long/Int64=8;decimal=16;string类型按照字符长度而定</param>
        /// <param name="val">参数值</param>
        /// <returns>DbParameter对象</returns>
        public virtual DbParameter CreateDbParameter(string parameterName, DbType dbType, int dbSize, object val)
        {
            var parame = DbProvider.CreateParameter();
            parame.ParameterName = parameterName;
            parame.DbType = dbType;
            parame.Size = dbSize;
            parame.Value = val;
            return parame;
        }

        /// <summary>
        /// 执行非查询操作(添加/修改/删除)
        /// </summary>
        /// <param name="sqlString">参数化sql语句</param>
        /// <param name="cmdParms">参数数组</param>
        /// <returns>操作影响行数</returns>
        public virtual int ExecuteNonQuery(string sqlString, params DbParameter[] cmdParms)
        {
            using (var conn = DbProvider.CreateConnection())
            {
                conn.ConnectionString = ConnectionString;
                using (var cmd = PrepareCommand(conn, sqlString, cmdParms))
                {
                    int rows = cmd.ExecuteNonQuery();
                    cmd.Parameters.Clear();
                    return rows;
                }
            }
        }

        /// <summary>
        /// 执行sql查询，返回第一行第一列
        /// </summary>
        /// <param name="sqlString">参数化sql语句</param>
        /// <param name="cmdParms">参数数组</param>
        /// <returns>第一行第一列的值</returns>
        public virtual object ExecuteScalar(string sqlString, params DbParameter[] cmdParms)
        {
            using (DbConnection conn = DbProvider.CreateConnection())
            {
                conn.ConnectionString = ConnectionString;
                using (DbCommand cmd = PrepareCommand(conn, sqlString, cmdParms))
                {
                    object obj = cmd.ExecuteScalar();
                    cmd.Parameters.Clear();
                    conn.Close();
                    return obj;
                }
            }
        }

        /// <summary>
        /// 执行sql查询，返回第一行第一列(泛型)
        /// </summary>
        /// <typeparam name="TSource">返回的值类型</typeparam>
        /// <param name="sqlString">参数化sql语句</param>
        /// <param name="cmdParms">参数数组</param>
        /// <returns>第一行第一列的值</returns>
        public virtual TSource ExecuteScalar<TSource>(string sqlString, params DbParameter[] cmdParms) where TSource : struct
        {
            object obj = ExecuteScalar(sqlString, cmdParms);
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, DBNull.Value)))
            {
                return default(TSource);
            }
            return typeof(TSource) == obj.GetType() ? (TSource)obj : (TSource)Convert.ChangeType(obj, typeof(TSource));
        }

        /// <summary>
        /// 执行sql查询，返回DataReader
        /// </summary>
        /// <param name="sqlString">参数化sql语句</param>
        /// <param name="cmdParms">参数数组</param>
        /// <returns>DbDataReader对象</returns>
        public virtual DbDataReader ExecuteReader(string sqlString, params DbParameter[] cmdParms)
        {
            var conn = DbProvider.CreateConnection();
            try
            {
                conn.ConnectionString = ConnectionString;
                var cmd = PrepareCommand(conn, sqlString, cmdParms);
                var myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                cmd.Parameters.Clear();
               
                return myReader;
            }
            catch (DbException ex)
            {
                conn.Close();
                throw ex;
            }
        }

        /// <summary>
        /// 执行sql查询，返回DataReader
        /// </summary>
        /// <param name="dataReaderCallback">委托方法，读取DataReader</param>
        /// <param name="sqlString">参数化sql语句</param>
        /// <param name="cmdParms">参数数组</param>
        public virtual void ExecuteReader(Action<DbDataReader> dataReaderCallback, string sqlString, params DbParameter[] cmdParms)
        {
            using (var conn = DbProvider.CreateConnection())
            {
                conn.ConnectionString = ConnectionString;
                var cmd = PrepareCommand(conn, sqlString, cmdParms);
                var myReader = cmd.ExecuteReader();
                cmd.Parameters.Clear();
                dataReaderCallback(myReader);
                myReader.Dispose();
            }
        }

        /// <summary>
        /// 执行sql查询，返回DataSet
        /// </summary>
        /// <param name="sqlString">参数化sql语句</param>
        /// <param name="cmdParms">参数数组</param>
        /// <returns>DataSet对象</returns>
        public virtual DataSet ExecuteDataSet(string sqlString, params DbParameter[] cmdParms)
        {
            using (var conn = DbProvider.CreateConnection())
            {
                conn.ConnectionString = ConnectionString;
                using (var cmd = PrepareCommand(conn, sqlString, cmdParms))
                {
                    using (var adapter = DbProvider.CreateDataAdapter())
                    {
                        adapter.SelectCommand = cmd;
                        var ds = new DataSet();
                        adapter.Fill(ds);
                        return ds;
                    }
                }
            }
        }

        /// <summary>
        /// 以事务形式执行多条语句的批量新增或修改操作
        /// </summary>
        /// <param name="sqlStringList">sql语句</param>
        /// <returns>事务是否执行成功</returns>
        public virtual bool ExecuteSqlTran(List<string> sqlStringList)
        {
            var cmd = DbProvider.CreateCommand();
            try
            {
                cmd.Connection = DbProvider.CreateConnection();
                cmd.Connection.ConnectionString = ConnectionString;
                cmd.Connection.Open();
                cmd.CommandType = CommandType.Text;
                cmd.Transaction = cmd.Connection.BeginTransaction();
                foreach (var sqlString in sqlStringList)
                {
                    cmd.CommandText = sqlString;
                    cmd.ExecuteNonQuery();
                }
                cmd.Transaction.Commit();
                return true;
            }
            catch
            {
                cmd.Transaction.Rollback();
                return false;
            }
            finally
            {
                cmd.Connection.Close();
            }
        }

        /// <summary>
        /// 以事务形式执行同一个语句的批量新增或修改操作
        /// </summary>
        /// <param name="sqlString">参数化sql语句</param>
        /// <param name="cmdParams">参数数组</param>
        /// <returns>事务是否执行成功</returns>
        public virtual bool ExecuteSqlTran(string sqlString, List<DbParameter[]> cmdParams)
        {
            var cmd = DbProvider.CreateCommand();
            try
            {
                cmd.Connection = DbProvider.CreateConnection();
                cmd.Connection.ConnectionString = ConnectionString;
                cmd.Connection.Open();
                cmd.CommandText = sqlString;
                cmd.CommandType = CommandType.Text;
                cmd.Transaction = cmd.Connection.BeginTransaction();
                foreach (DbParameter[] parames in cmdParams)
                {
                    cmd.Parameters.AddRange(parames);
                    cmd.ExecuteNonQuery();
                    cmd.Parameters.Clear();
                }
                cmd.Transaction.Commit();
                return true;
            }
            catch
            {
                cmd.Transaction.Rollback();
                return false;
            }
            finally
            {
                cmd.Connection.Close();
            }
        }

        /// <summary>
        /// 以事务形式执行同一个语句的批量新增或修改操作
        /// </summary>
        /// <param name="sqlStringWithParames">参数化sql语句以及参数数组</param>
        /// <returns>事务是否执行成功</returns>
        public virtual bool ExecuteSqlTran(Dictionary<string, List<DbParameter[]>> sqlStringWithParames)
        {
            var cmd = DbProvider.CreateCommand();
            try
            {
                cmd.Connection = DbProvider.CreateConnection();
                cmd.Connection.ConnectionString = ConnectionString;
                cmd.Connection.Open();
                cmd.CommandType = CommandType.Text;
                cmd.Transaction = cmd.Connection.BeginTransaction();
                foreach (var sqlString in sqlStringWithParames.Keys)
                {
                    cmd.CommandText = sqlString;
                    List<DbParameter[]> paramesList = sqlStringWithParames[sqlString];
                    cmd.Parameters.AddRange(paramesList[0]);
                    cmd.ExecuteNonQuery();
                    for (var i = 1; i < paramesList.Count; i++)
                    {
                        DbParameter[] parames = paramesList[i];
                        for (var j = 0; j < parames.Length; j++)
                        {
                            cmd.Parameters[j].Value = parames[j].Value;
                        }
                        cmd.ExecuteNonQuery();
                    }
                    cmd.Parameters.Clear();
                }
                cmd.Transaction.Commit();
                return true;
            }
            catch
            {
                cmd.Transaction.Rollback();
                return false;
            }
            finally
            {
                cmd.Connection.Close();
            }
        }

        /// <summary>
        /// 表值参数保存数据
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="sqlStatement"></param>
        /// <param name="tableName"></param>
        /// <returns></returns>
        public virtual bool ExecuteSqlBulk(DataTable dt, string sqlStatement, string tableName)
        {
            var sqlConn = new SqlConnection(ConfigurationManager.ConnectionStrings["FTRTPContext"].ConnectionString);
            var cmd = new SqlCommand(sqlStatement, sqlConn);
            var catParam = cmd.Parameters.AddWithValue("@NewBulkTestTvp", dt);
            catParam.SqlDbType = SqlDbType.Structured;
            //表值参数的名字叫BulkUdt，在上面的建立测试环境的SQL中有。  
            catParam.TypeName = tableName;// "dbo.BulkUdt";

            try
            {
                sqlConn.Open();
                if (dt != null && dt.Rows.Count != 0)
                {
                    cmd.ExecuteNonQuery();
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                sqlConn.Close();
            }
            return true;
        }

        /// <summary>
        /// 初始化DbCommand对象
        /// </summary>
        /// <param name="conn">数据库连接</param>
        /// <param name="sqlString">参数化sql语句</param>
        /// <param name="cmdParms">参数数组</param>
        /// <returns>DbCommand对象</returns>
        protected DbCommand PrepareCommand(DbConnection conn, string sqlString, params DbParameter[] cmdParms)
        {
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }
            DbCommand cmd = DbProvider.CreateCommand();
            cmd.Connection = conn;
            cmd.CommandText = sqlString;
            cmd.CommandType = CommandType.Text;
            if (cmdParms != null)
            {
                foreach (DbParameter parm in cmdParms)
                {
                    cmd.Parameters.Add(parm);
                }
            }
            return cmd;
        }

        /// <summary>
        /// 分页查询数据(公共)
        /// </summary>
        /// <param name="strSql">查询语句</param>
        /// <param name="order">分页排序</param>
        /// <param name="pageSize">每页显示记录数</param>
        /// <param name="pageIndex">当前第几页</param>
        /// <param name="record">总记录数</param>
        /// <returns>DbDataReader对象</returns>
        public abstract DataSet SelectPageingPublic(string strSql, string order, int pageSize, int pageIndex, out int record);

对于目前需要处理的数据库操作基本都在了吧，有不清楚的可以留言探讨。

最后一个抽象方法实现如下所示：

        /// <summary>
        /// 分页查询数据（公用）
        /// </summary>
        /// <param name="strSql">表名称</param>
        /// <param name="order">分页排序</param>
        /// <param name="pageSize">每页显示记录数</param>
        /// <param name="pageIndex">当前第几页</param>
        /// <param name="record">总记录数</param>
        /// <returns>DbDataReader对象</returns>
        public override DataSet SelectPageingPublic(string strSql, string order, int pageSize, int pageIndex, out int record)
        {
            if (!string.IsNullOrEmpty(order) && order.IndexOf("order by", StringComparison.Ordinal) < 0)
            {
                order = "order by " + order;
            }
            var countSql = string.Format("select count(1) from ({0}) e", strSql);//查询总数
            record = ExecuteScalar<int>(countSql);
            var offsetCount = (pageIndex - 1) * pageSize;
            const string sqlTemplate = "select * from (select row_number() over({1}) as rowno, * from ({0})e ) f where rowno>{3} and rowno<=({2}+{3}) {1}  ";
            var sqlSelectData = string.Format(sqlTemplate, strSql, order, pageSize, offsetCount);
            return ExecuteDataSet(sqlSelectData);
        }

　　希望对您的学习和工作有帮助，喜欢的点赞哈。

转载于:https://www.cnblogs.com/fqzhong2007/p/8336594.html

weixin_30415113
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
aqo：PostgreSQL自适应查询优化
02-05
1. **运行时统计**：aqo在执行查询时收集关于操作（如扫描、排序、连接等）的实时性能数据，如扫描行数、执行时间等。 2. **学习模式**：在学习模式下，aqo会记录这些运行时统计信息，用于后续决策。 3. **调整策略*...
aqo:空气质量对象，可以精美，被动地显示空气中的二氧化碳水平
05-08
q 空气质量对象，可以精美而被动地显示空气中的二氧化碳水平目录背景 空气质量对象根据空气中的二氧化碳含量改变颜色。 它本来是一个漂亮的物体，但也可以被动地显示有关周围的信息。 它使通常看不见的气流可见，...
AQO 开源项目教程
gitblog_00454的博客
08-22 307
AQO 开源项目教程 aqoAQO是一个开源的PostgreSQL查询优化器扩展，用于自动优化查询性能。 - 功能：PostgreSQL查询优化器扩展；自动查询性能优化。 - 特点：易于使用；轻量级；支持多种编程语言；高性能。项目地址:https://gitcode.com/gh_mirrors/aq/aqo 项目介绍 AQO（Adaptive Query Optimization）是一...
AQO 开源项目使用教程
最新发布
gitblog_00251的博客
08-22 483
AQO 开源项目使用教程 aqoAQO是一个开源的PostgreSQL查询优化器扩展，用于自动优化查询性能。 - 功能：PostgreSQL查询优化器扩展；自动查询性能优化。 - 特点：易于使用；轻量级；支持多种编程语言；高性能。项目地址:https://gitcode.com/gh_mirrors/aq/aqo 1. 项目的目录结构及介绍 AQO（Adaptive Query Opti...
数据链路层以及交换机
HYMajor的博客
07-06 490
文章目录一、前言二、数据链路的主要功能2.1、链路管理2.2、帧同步2.3、流量控制2.4、差错控制2.5、透明传输三、差错的产生原因和解决方法1、差错产生的原因2、解决方法2.1、帧的构成2.2、差错控制2.2.1、检错编码2.2.2、循环冗余检验2.2.3、停止--等待协议（无差错）2.2.4、重传机制2.2.5、确认丢失和确认迟到2.3、后退N帧协议【GBN】四、滑动窗口协议4.1、滑动窗口4.2、发送窗口的规则4.3 接收窗口的大小4.4、累积确认机制五、交换机工作原理六、项目(虚拟局域网通信)6.
js中的数组,数组操作方法,冒泡排序
dust__的博客
07-18 1315
一.数组及数组的方法 1.数组:一组数据的集合,在js中数组里面的数据可以是不同类型 2.数组的初始化 (1)第一种方法: var myScar=new Array(); myScar[0]='Baoma'; myScar[2]='Aodi'; myScar[3]='BenChi'; (2)第二种方法: var myScar=new Array('Baoma','...
cryptography签名数据方法
weixin_41041015的博客
07-23 19
简介在非对称加密(公/私钥)体系中，一般有两种应用场景：公钥加密 ---> 私钥解密私钥签名 ---> 公钥验证签名数字签名数字签名在网络通信中是一种授权和防抵赖技术。RSA私钥签名及验证加密算法：RSA哈希算法：SHA256数据签名方法登录后复制 from cryptography.hazmat.primi...
探索 PostgreSQL Pro 的 Advanced Query Optimizer（AQO）
gitblog_00053的博客
04-26 429
探索 PostgreSQL Pro 的 Advanced Query Optimizer（AQO） aqoAQO是一个开源的PostgreSQL查询优化器扩展，用于自动优化查询性能。 - 功能：PostgreSQL查询优化器扩展；自动查询性能优化。 - 特点：易于使用；轻量级；支持多种编程语言；高性能。项目地址:https://gitcode.com/gh_mirrors/aq/aqo ...
echarts柱状图顶部数据显示气泡
B_cherry的博客
05-11 1202
效果图： 动效 代码： <template> <div ref="mood" style="{width: 1200px;height: 490px}"></div> </template> import * as echarts from "echarts"; <script> methods: { drawnleft() { let mychart = echarts.init(this.$refs.mood);
Kubernetes 通过 Sealed Secrets 实现加密部署
engchina的专栏
01-29 722
Kubernetes 通过 Sealed Secrets 实现加密部署
RSA非对称加密解密实现
chengjiao1230的博客
04-18 810
1、公钥私钥生成工具 参考： http://web.chacuo.net/netrsakeypair 2、python实现 import base64 from Crypto.PublicKey import RSA pub_key = '''-----BEGIN PUBLIC...
cpp-AdaptivequeryoptimizationML来改进Postgres分析查询
08-16
4. **在线学习与更新**：为了保持模型的时效性，系统可能需要实现在线学习功能，允许模型根据新数据持续更新和调整。 5. **性能评估**：项目可能包含一系列基准测试，以验证ML驱动的AQO相对于传统方法的性能提升。...
Oracle 11g 王二暖ppt文件
02-07
通过共享磁盘架构，RAC能够实现故障切换，确保服务连续性。 2. **自动存储管理（ASM）** ASM是Oracle 11g中集成的存储管理系统，能自动处理数据文件、控制文件、重做日志文件等的创建、扩展和备份，简化了数据库...
incubator-hawq-master.zip
02-24
1. `src`：这是Hawq的主要源代码目录，包括C++和SQL解析器的实现。 2. `docs`：包含了Hawq的用户手册、开发者指南和技术文档。 3. `build`：用于存放编译过程中产生的临时文件和构建结果。 4. `scripts`：包含了安装...
数据结构核心知识.pdf
08-21
本资料围绕数据结构的理解、数据的逻辑结构、数据的存储结构、运算、线性表等方面来阐述数据结构核心知识。
HandBrake.deb多媒体格式转换软件
08-21
HandBrake.deb多媒体格式转换软件，可在多个平台上运行，该软件支持将视频文件从一种格式转换为另一种常见的格式，如MP4或MKV；用户可以调整视频编解码器、帧速率、比特率等参数；HandBrake还具有一些预设选项，使用户能够快速选择适合他们设备的设置，例如iPhone、Android手机或游戏机。
211维修保养服务管理系统.zip
08-21
211维修保养服务管理系统.zip
vivado2021.1安装教程.docx
08-21
Vivado 2021.1 的安装教程主要包括以下几个步骤。请注意，以下步骤基于 Windows 系统进行说明，对于其他操作系统（如 Linux），安装过程可能有所不同。 一、下载 Vivado 2021.1 访问官网：首先，你需要访问 Xilinx 的官方网站（Xilinx China），并导航到下载页面。 注册账号：在下载前，你需要在 Xilinx 官网上注册一个账号。注册时可能需要填写一些基本信息，如公司名称、地址等。对于个人用户，这些信息可以随意填写。 下载软件：使用注册的账号登录后，你可以找到 Vivado 2021.1 的下载链接。建议下载 Web Installer 版本，因为它可以自动下载并安装必要的组件，同时减少初始下载量。 二、安装 Vivado 2021.1 关闭防火墙和杀毒软件：在安装前，建议暂时关闭电脑的防火墙和杀毒软件，以避免安装过程中可能出现的干扰。 运行安装程序：双击下载的 Web Installer 或直接运行的安装程序（如 Xilinx_Unified_2021.1_xxxx_Win64.exe），开始安装过程。 输入账号密码：安装程序会要求你输入
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值