当前位置：Gxlcms > 数据库问题 > 『片段』OracleHelper (支持 多条SQL语句)

『片段』OracleHelper (支持 多条SQL语句)

时间：2021-07-01 10:21:17 帮助过：15人阅读

 调用 Oracle 是如此尴尬

>System.Data.OracleClient.dll —— .Net 自带的 已经 过时作废。

>要链接 Oracle 服务器，必须在 本机安装 Oracle 客户端 —— 而 SQLServer 不需要安装客户端。 

      win32_11gR2_client.zip（652M）

      win64_11gR2_client.zip（587M） 

>Oracle.DataAccess.dll—— Oracle 官方 提供的.Net 程序集【在安装目录 ODP.NET 中】。

      Oracle.DataAccess.dll  严格区分 x32、x64 —— 程序集 不是 AnyCPU。

      x32 客户端 只包括 x32 的 Oracle.DataAccess.dll。

      x64 客户端 只包括 x64 的 Oracle.DataAccess.dll。

       发布程序的时候，就很容易在这个地方 出现问题。

  

C# 调用 Oracle 语法限制

      >Oracle 不支持 自增主键 —— 自增主键 需要使用 触发器。

      >Oracle 表名，字段名 不能超过30个字符。

      >脚本 参数化，    关键符为 : —— SQLServer 关键符为 @

      >脚本 名称区域， 关键符为 "表名"."字段名" —— SQLServer 关键符为 [表名].[字段名]

           警告：脚本中 不建议 将 数据库名、表名、字段名 用 引号括起来 —— 后果很严重。

 

      >支持 多条 修改语句 同时执行：

          BEGIN

             UPDATE TB_Test SET Name=‘INK‘;

             DELETE TB_Test WHERE Name=‘INK‘;

             INSERT INTO TB_Test(Name) VALUES(‘INK‘);

          END;

 

       >不支持 多条 查询语句，得到 DataSet —— 支持 单一查询得到 DataSet。

       >支持 ExecuteScalar —— 但是 执行脚本 必须是 单条脚本。

       >不支持 插入&查询 自增列—— SQLServer 支持 INSERT INTO…. SELECT@@IDENTITY

           警告：即使使用 触发器 实现 自增ID，以下语法也 无法执行：

          BEGIN

             INSERT INTO TB_Test(Name) VALUES(‘INK‘);   --先执行 插入

             SELECT MAX(ID) FROMTB_Test;                --再执行 查询 最大ID

          END

 

 

C# 调用 Oracle 的死结 在于：不支持 多条 非影响SQL脚本同时执行。

 

有鉴于此，自己随手写了一个OracleHelper.cs

       >之前 Oracle 脚本, 自然是 支持的。

       >多条 Oracle 脚本，用 ; 分割 —— 即能支持 多条SQL脚本。

          >多条SQL脚本将自动开启 数据库事务，确保 绝对正确。

          >支持 多条SELECT返回 多DataTable的 DataSet。

          >支持 插入&查询自增列（触发器实现的 自增列） 

 

代码如下：

 

技术分享 
  1     public static class OracleHelper
  2     {
  3 
  4 
  5 
  6         public static List<T> ExecuteReaderList<T>(string connString, string cmdText, Func<OracleDataReader, T> funcReader) where T : new()
  7         {
  8             return ExecuteReaderList(connString, cmdText, null, funcReader);
  9         }
 10         public static T ExecuteReaderEntity<T>(string connString, string cmdText, Func<OracleDataReader, T> funcReader) where T : new()
 11         {
 12             return ExecuteReaderEntity(connString, cmdText, null, funcReader);
 13         }
 14         public static int ExecuteNonQuery(string connString, string cmdText)
 15         {
 16             return ExecuteNonQuery(connString, cmdText, null);
 17         }
 18         public static object ExecuteScalar(string connString, string cmdText)
 19         {
 20             return ExecuteScalar(connString, cmdText, null);
 21         }
 22         public static DataSet ExecuteFillDataSet(string connString, string cmdText)
 23         {
 24             return ExecuteFillDataSet(connString, cmdText, null);
 25         }
 26 
 27 
 28         public static List<T> ExecuteReaderList<T>(string connString, string cmdText, Action<OracleCommand> cmdAction, Func<OracleDataReader, T> funcReader) where T : new()
 29         {
 30             using (OracleConnection conn = new OracleConnection(connString))
 31             {
 32                 TryOpenSqlConnection(conn);
 33                 return ExecuteReaderList<T>(conn, null, cmdText, cmdAction, funcReader);
 34             }
 35         }
 36         public static T ExecuteReaderEntity<T>(string connString, string cmdText, Action<OracleCommand> cmdAction, Func<OracleDataReader, T> funcReader) where T : new()
 37         {
 38             using (OracleConnection conn = new OracleConnection(connString))
 39             {
 40                 TryOpenSqlConnection(conn);
 41                 return ExecuteReaderEntity<T>(conn, null, cmdText, cmdAction, funcReader);
 42             }
 43         }
 44         public static int ExecuteNonQuery(string connString, string cmdText, Action<OracleCommand> cmdAction)
 45         {
 46             using (OracleConnection conn = new OracleConnection(connString))
 47             {
 48                 TryOpenSqlConnection(conn);
 49                 return ExecuteNonQuery(conn, null, cmdText, cmdAction);
 50             }
 51         }
 52         public static object ExecuteScalar(string connString, string cmdText, Action<OracleCommand> cmdAction)
 53         {
 54             using (OracleConnection conn = new OracleConnection(connString))
 55             {
 56                 TryOpenSqlConnection(conn);
 57                 return ExecuteScalar(conn, null, cmdText, cmdAction);
 58             }
 59         }
 60         public static DataSet ExecuteFillDataSet(string connString, string cmdText, Action<OracleCommand> cmdAction)
 61         {
 62             using (OracleConnection conn = new OracleConnection(connString))
 63             {
 64                 TryOpenSqlConnection(conn);
 65                 return ExecuteFillDataSet(conn, null, cmdText, cmdAction);
 66             }
 67         }
 68 
 69 
 70         public static List<T> ExecuteReaderList<T>(OracleConnection conn, OracleTransaction tran, string cmdText, Action<OracleCommand> cmdAction, Func<OracleDataReader, T> funcReader) where T : new()
 71         {
 72             List<OracleSingleScript> listScript = SplitOracleScript(cmdText);
 73             if (listScript == null || listScript.Count <= 0 || listScript.Count == 1)
 74             {
 75                 return SingleExecuteReaderList<T>(conn, tran, cmdText, cmdAction, funcReader);
 76             }
 77             else
 78             {
 79                 OracleBatchResult<T> result = ExecuteBatchScript<T>(conn, tran, listScript, false, cmdAction, funcReader);
 80                 return result.ExecuteReaderList();
 81             }
 82         }
 83         public static T ExecuteReaderEntity<T>(OracleConnection conn, OracleTransaction tran, string cmdText, Action<OracleCommand> cmdAction, Func<OracleDataReader, T> funcReader) where T : new()
 84         {
 85             List<OracleSingleScript> listScript = SplitOracleScript(cmdText);
 86             if (listScript == null || listScript.Count <= 0 || listScript.Count == 1)
 87             {
 88                 return SingleExecuteReaderEntity<T>(conn, tran, cmdText, cmdAction, funcReader);
 89             }
 90             else
 91             {
 92                 OracleBatchResult<T> result = ExecuteBatchScript<T>(conn, tran, listScript, false, cmdAction, funcReader);
 93                 return result.ExecuteReaderEntity();
 94             }
 95         }
 96         public static int ExecuteNonQuery(OracleConnection conn, OracleTransaction tran, string cmdText, Action<OracleCommand> cmdAction)
 97         {
 98             List<OracleSingleScript> listScript = SplitOracleScript(cmdText);
 99             if (listScript == null || listScript.Count <= 0 || listScript.Count == 1)
100             {
101                 return SingleExecuteNonQuery(conn, tran, cmdText, cmdAction);
102             }
103             else
104             {
105                 OracleBatchResult<object> result = ExecuteBatchScript<object>(conn, tran, listScript, false, cmdAction, null);
106                 return result.ExecuteNonQuery();
107             }
108         }
109         public static object ExecuteScalar(OracleConnection conn, OracleTransaction tran, string cmdText, Action<OracleCommand> cmdAction)
110         {
111             List<OracleSingleScript> listScript = SplitOracleScript(cmdText);
112             if (listScript == null || listScript.Count <= 0 || listScript.Count == 1)
113             {
114                 return SingleExecuteScalar(conn, tran, cmdText, cmdAction);
115             }
116             else
117             {
118                 OracleBatchResult<object> result = ExecuteBatchScript<object>(conn, tran, listScript, false, cmdAction, null);
119                 return result.ExecuteScalar();
120             }
121         }
122         public static DataSet ExecuteFillDataSet(OracleConnection conn, OracleTransaction tran, string cmdText, Action<OracleCommand> cmdAction)
123         {
124             List<OracleSingleScript> listScript = SplitOracleScript(cmdText);
125             if (listScript == null || listScript.Count <= 0 || listScript.Count == 1)
126             {
127                 DataTable dataTable = SingleExecuteFillDataTable(conn, tran, cmdText, cmdAction);
128                 DataSet dataSet = new DataSet();
129                 if (dataTable != null) dataSet.Tables.Add(dataTable);
130                 return dataSet;
131             }
132             else
133             {
134                 OracleBatchResult<object> result = ExecuteBatchScript<object>(conn, tran, listScript, true, cmdAction, null);
135                 return result.ExecuteFillDataSet();
136             }
137         }
138 
139 
140 
141         private static OracleBatchResult<T> ExecuteBatchScript<T>(string connString, IEnumerable<OracleSingleScript> listScript, bool isSelectDataSet, Action<OracleCommand> cmdAction, Func<OracleDataReader, T> funcReader) where T : new()
142         {
143             using (OracleConnection conn = new OracleConnection(connString))
144             {
145                 TryOpenSqlConnection(conn);
146                 using (OracleTransaction tran = conn.BeginTransaction())
147                 {
148                     OracleBatchResult<T> result = ExecuteBatchScript(conn, tran, listScript, isSelectDataSet, cmdAction, funcReader);
149                     return result;
150                 }
151             }
152         }
153         private static OracleBatchResult<T> ExecuteBatchScript<T>(OracleConnection conn, OracleTransaction tran, IEnumerable<OracleSingleScript> listScript, bool isSelectDataSet, Action<OracleCommand> cmdAction, Func<OracleDataReader, T> funcReader) where T : new()
154         {
155             OracleBatchResult<T> result = new OracleBatchResult<T>();
156 
157             bool tranIsNull = tran == null;
158             if (tranIsNull) tran = conn.BeginTransaction();
159             try
160             {
161                 foreach (OracleSingleScript script in listScript)
162                 {
163                     #region  执行查询实体
164 
165                     if (script.IsSelect)
166                     {
167                         if (isSelectDataSet)
168                         {
169                             DataTable dataTable = SingleExecuteFillDataTable(conn, tran, script.SqlScript, cmdAction);
170                             result.AddDataTable(dataTable);
171                         }
172                         else if (typeof(T) == typeof(object) && funcReader == null)
173                         {
174                             object scalar = SingleExecuteScalar(conn, tran, script.SqlScript, cmdAction);
175                             result.AddScalar(scalar);
176                         }
177                         else
178                         {
179                             List<T> list = SingleExecuteReaderList<T>(conn, tran, script.SqlScript, cmdAction, funcReader);
180                             result.AddList(list);
181                         }
182                     }
183 
184                     #endregion
185                     #region  执行增加修改删除
186 
187                     if (script.IsInsert || script.IsUpdate || script.IsDelete)
188                     {
189                         int effect = SingleExecuteNonQuery(conn, tran, script.SqlScript, cmdAction);
190                         result.AddEffect(effect);
191                     }
192 
193                     #endregion
194                 }
195                 if (tranIsNull && tran != null) tran.Commit();
196             }
197             finally
198             {
199                 if (tranIsNull && tran != null) tran.Dispose();
200             }
201 
202             return result;
203         }
204 
205 
206         #region  执行单条脚本
207 
208         //private static List<T> SingleExecuteReaderList<T>(string connString, string cmdText, Action<OracleCommand> cmdAction, Func<OracleDataReader, T> funcReader) where T : new()
209         //{
210         //    using (OracleConnection conn = new OracleConnection(connString))
211         //    {
212         //        TryOpenSqlConnection(conn);
213         //        return SingleExecuteReaderList(conn, null, cmdText, cmdAction, funcReader);
214         //    }
215         //}
216         //private static T SingleExecuteReaderEntity<T>(string connString, string cmdText, Action<OracleCommand> cmdAction, Func<OracleDataReader, T> funcReader) where T : new()
217         //{
218         //    using (OracleConnection conn = new OracleConnection(connString))
219         //    {
220         //        TryOpenSqlConnection(conn);
221         //        return SingleExecuteReaderEntity(conn, null, cmdText, cmdAction, funcReader);
222         //    }
223         //}
224         //private static int SingleExecuteNonQuery(string connString, string cmdText, Action<OracleCommand> cmdAction)
225         //{
226         //    using (OracleConnection conn = new OracleConnection(connString))
227         //    {
228         //        TryOpenSqlConnection(conn);
229         //        return SingleExecuteNonQuery(conn, null, cmdText, cmdAction);
230         //    }
231         //}
232         //private static object SingleExecuteScalar(string connString, string cmdText, Action<OracleCommand> cmdAction)
233         //{
234         //    using (OracleConnection conn = new OracleConnection(connString))
235         //    {
236         //        TryOpenSqlConnection(conn);
237         //        return SingleExecuteScalar(conn, null, cmdText, cmdAction);
238         //    }
239         //}
240         //private static DataTable SingleExecuteFillDataTable(string connString, string cmdText, Action<OracleCommand> cmdAction)
241         //{
242         //    using (OracleConnection conn = new OracleConnection(connString))
243         //    {
244         //        TryOpenSqlConnection(conn);
245         //        return SingleExecuteFillDataTable(conn, null, cmdText, cmdAction);
246         //    }
247         //}
248 
249 
250         private static List<T> SingleExecuteReaderList<T>(OracleConnection conn, OracleTransaction tran, string cmdText, Action<OracleCommand> cmdAction, Func<OracleDataReader, T> funcReader) where T : new()
251         {
252             List<T> list = new List<T>();
253             //需要查询的是否是 原生值类型
254             bool isMetaValue = typeof(T).IsValueType && typeof(T).GetProperties().Length <= 0 && typeof(T).GetFields().Length <= 0;
255 
256             using (OracleCommand cmd = conn.CreateCommand())
257             {
258                 cmd.CommandText = cmdText;
259                 cmd.CommandTimeout = int.MaxValue;
260                 //cmd.Transaction = tran;
261                 if (cmdAction != null) cmdAction(cmd);
262 
263                 using (OracleDataReader reader = cmd.ExecuteReader())
264                 {
265                     List<

人气教程排行

本站所有资源全部来源于网络，若本站发布的内容侵害到您的隐私或者利益，请联系我们删除！