|
0
|
1 // Odp.Net Data Provider.
|
|
|
2 // http://www.oracle.com/technology/tech/windows/odpnet/index.html
|
|
|
3 //
|
|
|
4 using System;
|
|
|
5 using System.Collections;
|
|
|
6 using System.Collections.Generic;
|
|
|
7 using System.Data;
|
|
|
8 using System.Data.Common;
|
|
|
9 using System.Globalization;
|
|
|
10 using System.IO;
|
|
|
11 using System.Linq;
|
|
|
12 using System.Reflection;
|
|
|
13 using System.Text;
|
|
|
14 using System.Xml;
|
|
|
15
|
|
|
16 using BLToolkit.Aspects;
|
|
|
17 using BLToolkit.Common;
|
|
|
18 using BLToolkit.Mapping;
|
|
|
19 using BLToolkit.Reflection;
|
|
|
20
|
|
|
21 #if MANAGED
|
|
|
22 using Oracle.ManagedDataAccess.Client;
|
|
|
23 using Oracle.ManagedDataAccess.Types;
|
|
|
24 #else
|
|
|
25 using Oracle.DataAccess.Client;
|
|
|
26 using Oracle.DataAccess.Types;
|
|
|
27 #endif
|
|
|
28
|
|
|
29 namespace BLToolkit.Data.DataProvider
|
|
|
30 {
|
|
|
31 using Sql.SqlProvider;
|
|
|
32 using BLToolkit.Data.Sql;
|
|
|
33
|
|
|
34 /// <summary>
|
|
|
35 /// Implements access to the Data Provider for Oracle.
|
|
|
36 /// </summary>
|
|
|
37 /// <remarks>
|
|
|
38 /// See the <see cref="DbManager.AddDataProvider(DataProviderBase)"/> method to find an example.
|
|
|
39 /// </remarks>
|
|
|
40 /// <seealso cref="DbManager.AddDataProvider(DataProviderBase)">AddDataManager Method</seealso>
|
|
|
41 #if !MANAGED
|
|
|
42 public class OdpDataProvider : DataProviderBase
|
|
|
43 {
|
|
|
44 public OdpDataProvider()
|
|
|
45 {
|
|
|
46 MappingSchema = new OdpMappingSchema();
|
|
|
47 }
|
|
|
48
|
|
|
49 public const string NameString = DataProvider.ProviderName.Oracle;
|
|
|
50
|
|
|
51 private const string DbTypeTableName = "Oracle.DataAccess.Client.OraDb_DbTypeTable";
|
|
|
52
|
|
|
53 static OdpDataProvider()
|
|
|
54 {
|
|
|
55 #else
|
|
|
56 public class OdpManagedDataProvider : DataProviderBase
|
|
|
57 {
|
|
|
58 public OdpManagedDataProvider()
|
|
|
59 {
|
|
|
60 MappingSchema = new OdpMappingSchema();
|
|
|
61 }
|
|
|
62
|
|
|
63 public const string NameString = DataProvider.ProviderName.OracleManaged;
|
|
|
64
|
|
|
65 private const string DbTypeTableName = "Oracle.ManagedDataAccess.Client.OraDb_DbTypeTable";
|
|
|
66
|
|
|
67 static OdpManagedDataProvider()
|
|
|
68 {
|
|
|
69 #endif
|
|
|
70 // Fix Oracle.Net bug #1: Array types are not handled.
|
|
|
71 //
|
|
|
72 var oraDbDbTypeTableType = typeof(OracleParameter).Assembly.GetType(DbTypeTableName);
|
|
|
73
|
|
|
74 if (null != oraDbDbTypeTableType)
|
|
|
75 {
|
|
|
76 var typeTable = (Hashtable)oraDbDbTypeTableType.InvokeMember(
|
|
|
77 "s_table", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.GetField,
|
|
|
78 null, null, Type.EmptyTypes);
|
|
|
79
|
|
|
80 if (null != typeTable)
|
|
|
81 {
|
|
|
82 typeTable[typeof(DateTime[])] = OracleDbType.TimeStamp;
|
|
|
83 typeTable[typeof(Int16[])] = OracleDbType.Int16;
|
|
|
84 typeTable[typeof(Int32[])] = OracleDbType.Int32;
|
|
|
85 typeTable[typeof(Int64[])] = OracleDbType.Int64;
|
|
|
86 typeTable[typeof(Single[])] = OracleDbType.Single;
|
|
|
87 typeTable[typeof(Double[])] = OracleDbType.Double;
|
|
|
88 typeTable[typeof(Decimal[])] = OracleDbType.Decimal;
|
|
|
89 typeTable[typeof(TimeSpan[])] = OracleDbType.IntervalDS;
|
|
|
90 typeTable[typeof(String[])] = OracleDbType.Varchar2;
|
|
|
91 typeTable[typeof(OracleBFile[])] = OracleDbType.BFile;
|
|
|
92 typeTable[typeof(OracleBinary[])] = OracleDbType.Raw;
|
|
|
93 typeTable[typeof(OracleBlob[])] = OracleDbType.Blob;
|
|
|
94 typeTable[typeof(OracleClob[])] = OracleDbType.Clob;
|
|
|
95 typeTable[typeof(OracleDate[])] = OracleDbType.Date;
|
|
|
96 typeTable[typeof(OracleDecimal[])] = OracleDbType.Decimal;
|
|
|
97 typeTable[typeof(OracleIntervalDS[])] = OracleDbType.IntervalDS;
|
|
|
98 typeTable[typeof(OracleIntervalYM[])] = OracleDbType.IntervalYM;
|
|
|
99 typeTable[typeof(OracleRefCursor[])] = OracleDbType.RefCursor;
|
|
|
100 typeTable[typeof(OracleString[])] = OracleDbType.Varchar2;
|
|
|
101 typeTable[typeof(OracleTimeStamp[])] = OracleDbType.TimeStamp;
|
|
|
102 typeTable[typeof(OracleTimeStampLTZ[])]= OracleDbType.TimeStampLTZ;
|
|
|
103 typeTable[typeof(OracleTimeStampTZ[])] = OracleDbType.TimeStampTZ;
|
|
|
104 #if !MANAGED
|
|
|
105 typeTable[typeof(OracleXmlType[])] = OracleDbType.XmlType;
|
|
|
106 #endif
|
|
|
107
|
|
|
108 typeTable[typeof(Boolean)] = OracleDbType.Byte;
|
|
|
109 typeTable[typeof(Guid)] = OracleDbType.Raw;
|
|
|
110 typeTable[typeof(SByte)] = OracleDbType.Decimal;
|
|
|
111 typeTable[typeof(UInt16)] = OracleDbType.Decimal;
|
|
|
112 typeTable[typeof(UInt32)] = OracleDbType.Decimal;
|
|
|
113 typeTable[typeof(UInt64)] = OracleDbType.Decimal;
|
|
|
114
|
|
|
115 typeTable[typeof(Boolean[])] = OracleDbType.Byte;
|
|
|
116 typeTable[typeof(Guid[])] = OracleDbType.Raw;
|
|
|
117 typeTable[typeof(SByte[])] = OracleDbType.Decimal;
|
|
|
118 typeTable[typeof(UInt16[])] = OracleDbType.Decimal;
|
|
|
119 typeTable[typeof(UInt32[])] = OracleDbType.Decimal;
|
|
|
120 typeTable[typeof(UInt64[])] = OracleDbType.Decimal;
|
|
|
121
|
|
|
122 typeTable[typeof(Boolean?)] = OracleDbType.Byte;
|
|
|
123 typeTable[typeof(Guid?)] = OracleDbType.Raw;
|
|
|
124 typeTable[typeof(SByte?)] = OracleDbType.Decimal;
|
|
|
125 typeTable[typeof(UInt16?)] = OracleDbType.Decimal;
|
|
|
126 typeTable[typeof(UInt32?)] = OracleDbType.Decimal;
|
|
|
127 typeTable[typeof(UInt64?)] = OracleDbType.Decimal;
|
|
|
128 typeTable[typeof(DateTime?[])] = OracleDbType.TimeStamp;
|
|
|
129 typeTable[typeof(Int16?[])] = OracleDbType.Int16;
|
|
|
130 typeTable[typeof(Int32?[])] = OracleDbType.Int32;
|
|
|
131 typeTable[typeof(Int64?[])] = OracleDbType.Int64;
|
|
|
132 typeTable[typeof(Single?[])] = OracleDbType.Single;
|
|
|
133 typeTable[typeof(Double?[])] = OracleDbType.Double;
|
|
|
134 typeTable[typeof(Decimal?[])] = OracleDbType.Decimal;
|
|
|
135 typeTable[typeof(TimeSpan?[])] = OracleDbType.IntervalDS;
|
|
|
136 typeTable[typeof(Boolean?[])] = OracleDbType.Byte;
|
|
|
137 typeTable[typeof(Guid?[])] = OracleDbType.Raw;
|
|
|
138 typeTable[typeof(SByte?[])] = OracleDbType.Decimal;
|
|
|
139 typeTable[typeof(UInt16?[])] = OracleDbType.Decimal;
|
|
|
140 typeTable[typeof(UInt32?[])] = OracleDbType.Decimal;
|
|
|
141 typeTable[typeof(UInt64?[])] = OracleDbType.Decimal;
|
|
|
142
|
|
|
143 typeTable[typeof(XmlReader)] = OracleDbType.XmlType;
|
|
|
144 typeTable[typeof(XmlDocument)] = OracleDbType.XmlType;
|
|
|
145 typeTable[typeof(MemoryStream)] = OracleDbType.Blob;
|
|
|
146 typeTable[typeof(XmlReader[])] = OracleDbType.XmlType;
|
|
|
147 typeTable[typeof(XmlDocument[])] = OracleDbType.XmlType;
|
|
|
148 typeTable[typeof(MemoryStream[])] = OracleDbType.Blob;
|
|
|
149 }
|
|
|
150 }
|
|
|
151 }
|
|
|
152
|
|
|
153 /// <summary>
|
|
|
154 /// Creates the database connection object.
|
|
|
155 /// </summary>
|
|
|
156 /// <remarks>
|
|
|
157 /// See the <see cref="DbManager.AddDataProvider(DataProviderBase)"/> method to find an example.
|
|
|
158 /// </remarks>
|
|
|
159 /// <seealso cref="DbManager.AddDataProvider(DataProviderBase)">AddDataManager Method</seealso>
|
|
|
160 /// <returns>The database connection object.</returns>
|
|
|
161 public override IDbConnection CreateConnectionObject()
|
|
|
162 {
|
|
|
163 return new OracleConnection();
|
|
|
164 }
|
|
|
165
|
|
|
166 public override IDbCommand CreateCommandObject(IDbConnection connection)
|
|
|
167 {
|
|
|
168 var oraConnection = connection as OracleConnection;
|
|
|
169
|
|
|
170 if (null != oraConnection)
|
|
|
171 {
|
|
|
172 var oraCommand = oraConnection.CreateCommand();
|
|
|
173
|
|
|
174 // Fix Oracle.Net bug #2: Empty arrays can not be sent to the server.
|
|
|
175 //
|
|
|
176 oraCommand.BindByName = true;
|
|
|
177
|
|
|
178 return oraCommand;
|
|
|
179 }
|
|
|
180
|
|
|
181 return base.CreateCommandObject(connection);
|
|
|
182 }
|
|
|
183
|
|
|
184 public override void SetParameterValue(IDbDataParameter parameter, object value)
|
|
|
185 {
|
|
|
186 base.SetParameterValue(parameter, value);
|
|
|
187
|
|
|
188 // strings and byte arrays larger than 4000 bytes may be handled improperly
|
|
|
189 if (parameter is OracleParameterWrap)
|
|
|
190 {
|
|
|
191 const int ThresholdSize = 4000;
|
|
|
192 if (value is string && Encoding.UTF8.GetBytes((string)value).Length > ThresholdSize)
|
|
|
193 {
|
|
|
194 ((OracleParameterWrap)parameter).OracleParameter.OracleDbType = OracleDbType.Clob;
|
|
|
195 }
|
|
|
196 else if (value is byte[] && ((byte[])value).Length > ThresholdSize)
|
|
|
197 {
|
|
|
198 ((OracleParameterWrap)parameter).OracleParameter.OracleDbType = OracleDbType.Blob;
|
|
|
199 }
|
|
|
200 }
|
|
|
201 }
|
|
|
202
|
|
|
203 public override IDbDataParameter CloneParameter(IDbDataParameter parameter)
|
|
|
204 {
|
|
|
205 var oraParameter = (parameter is OracleParameterWrap)?
|
|
|
206 (parameter as OracleParameterWrap).OracleParameter: parameter as OracleParameter;
|
|
|
207
|
|
|
208 if (null != oraParameter)
|
|
|
209 {
|
|
|
210 var oraParameterClone = (OracleParameter)oraParameter.Clone();
|
|
|
211
|
|
|
212 // Fix Oracle.Net bug #3: CollectionType property is not cloned.
|
|
|
213 //
|
|
|
214 oraParameterClone.CollectionType = oraParameter.CollectionType;
|
|
|
215
|
|
|
216 // Fix Oracle.Net bug #8423178
|
|
|
217 // See http://forums.oracle.com/forums/thread.jspa?threadID=975902&tstart=0
|
|
|
218 //
|
|
|
219 if (oraParameterClone.OracleDbType == OracleDbType.RefCursor)
|
|
|
220 {
|
|
|
221 // Set OracleDbType to itself to reset m_bSetDbType and m_bOracleDbTypeExSet
|
|
|
222 //
|
|
|
223 oraParameterClone.OracleDbType = OracleDbType.RefCursor;
|
|
|
224 }
|
|
|
225
|
|
|
226 return OracleParameterWrap.CreateInstance(oraParameterClone);
|
|
|
227 }
|
|
|
228
|
|
|
229 return base.CloneParameter(parameter);
|
|
|
230 }
|
|
|
231
|
|
|
232 public override void SetUserDefinedType(IDbDataParameter parameter, string typeName)
|
|
|
233 {
|
|
|
234 var oraParameter = (parameter is OracleParameterWrap) ?
|
|
|
235 (parameter as OracleParameterWrap).OracleParameter : parameter as OracleParameter;
|
|
|
236
|
|
|
237 if (oraParameter == null)
|
|
|
238 throw new ArgumentException("OracleParameter expected.", "parameter");
|
|
|
239
|
|
|
240 oraParameter.UdtTypeName = typeName;
|
|
|
241 }
|
|
|
242
|
|
|
243 /// <summary>
|
|
|
244 /// Creates the data adapter object.
|
|
|
245 /// </summary>
|
|
|
246 /// <remarks>
|
|
|
247 /// See the <see cref="DbManager.AddDataProvider(DataProviderBase)"/> method to find an example.
|
|
|
248 /// </remarks>
|
|
|
249 /// <seealso cref="DbManager.AddDataProvider(DataProviderBase)">AddDataManager Method</seealso>
|
|
|
250 /// <returns>A data adapter object.</returns>
|
|
|
251 public override DbDataAdapter CreateDataAdapterObject()
|
|
|
252 {
|
|
|
253 return new OracleDataAdapter();
|
|
|
254 }
|
|
|
255
|
|
|
256 /// <summary>
|
|
|
257 /// Populates the specified IDbCommand object's Parameters collection with
|
|
|
258 /// parameter information for the stored procedure specified in the IDbCommand.
|
|
|
259 /// </summary>
|
|
|
260 /// <remarks>
|
|
|
261 /// See the <see cref="DbManager.AddDataProvider(DataProviderBase)"/> method to find an example.
|
|
|
262 /// </remarks>
|
|
|
263 /// <seealso cref="DbManager.AddDataProvider(DataProviderBase)">AddDataManager Method</seealso>
|
|
|
264 /// <param name="command">The IDbCommand referencing the stored procedure for which the parameter
|
|
|
265 /// information is to be derived. The derived parameters will be populated into
|
|
|
266 /// the Parameters of this command.</param>
|
|
|
267 public override bool DeriveParameters(IDbCommand command)
|
|
|
268 {
|
|
|
269 var oraCommand = command as OracleCommand;
|
|
|
270
|
|
|
271 if (null != oraCommand)
|
|
|
272 {
|
|
|
273 try
|
|
|
274 {
|
|
|
275 OracleCommandBuilder.DeriveParameters(oraCommand);
|
|
|
276 }
|
|
|
277 catch (Exception ex)
|
|
|
278 {
|
|
|
279 // Make Oracle less laconic.
|
|
|
280 //
|
|
|
281 throw new DataException(string.Format("{0}\nCommandText: {1}", ex.Message, oraCommand.CommandText), ex);
|
|
|
282 }
|
|
|
283
|
|
|
284 return true;
|
|
|
285 }
|
|
|
286
|
|
|
287 return false;
|
|
|
288 }
|
|
|
289
|
|
|
290 /// <summary>
|
|
|
291 /// Open an <see cref="IDataReader"/> into the given <see cref="OracleRefCursor"/> object
|
|
|
292 /// </summary>
|
|
|
293 /// <param name="refCursor">an <see cref="OracleRefCursor"/> to perform GetDataReader() on</param>
|
|
|
294 /// <returns>The <see cref="IDataReader"/> into the returned by GetDataReader()</returns>
|
|
|
295 public override IDataReader GetRefCursorDataReader(object refCursor)
|
|
|
296 {
|
|
|
297 var oracleRefCursor = refCursor as OracleRefCursor;
|
|
|
298
|
|
|
299 if (oracleRefCursor == null)
|
|
|
300 throw new ArgumentException("Argument must be of type 'OracleRefCursor'", "refCursor");
|
|
|
301
|
|
|
302 return oracleRefCursor.GetDataReader();
|
|
|
303 }
|
|
|
304
|
|
|
305 public override object Convert(object value, ConvertType convertType)
|
|
|
306 {
|
|
|
307 switch (convertType)
|
|
|
308 {
|
|
|
309 case ConvertType.NameToCommandParameter:
|
|
|
310 case ConvertType.NameToSprocParameter:
|
|
|
311 return ParameterPrefix == null? value: ParameterPrefix + value;
|
|
|
312
|
|
|
313 case ConvertType.SprocParameterToName:
|
|
|
314 var name = (string)value;
|
|
|
315
|
|
|
316 if (name.Length > 0)
|
|
|
317 {
|
|
|
318 if (name[0] == ':')
|
|
|
319 return name.Substring(1);
|
|
|
320
|
|
|
321 if (ParameterPrefix != null &&
|
|
|
322 name.ToUpper(CultureInfo.InvariantCulture).StartsWith(ParameterPrefix))
|
|
|
323 {
|
|
|
324 return name.Substring(ParameterPrefix.Length);
|
|
|
325 }
|
|
|
326 }
|
|
|
327
|
|
|
328 break;
|
|
|
329
|
|
|
330 case ConvertType.ExceptionToErrorNumber:
|
|
|
331 if (value is OracleException)
|
|
|
332 return ((OracleException)value).Number;
|
|
|
333 break;
|
|
|
334 }
|
|
|
335
|
|
|
336 return SqlProvider.Convert(value, convertType);
|
|
|
337 }
|
|
|
338
|
|
|
339 public override void PrepareCommand(ref CommandType commandType, ref string commandText, ref IDbDataParameter[] commandParameters)
|
|
|
340 {
|
|
|
341 base.PrepareCommand(ref commandType, ref commandText, ref commandParameters);
|
|
|
342
|
|
|
343 if (commandType == CommandType.Text)
|
|
|
344 {
|
|
|
345 // Fix Oracle bug #11 '\r' is not a valid character!
|
|
|
346 //
|
|
|
347 commandText = commandText.Replace('\r', ' ');
|
|
|
348 }
|
|
|
349 }
|
|
|
350
|
|
|
351 public override void AttachParameter(IDbCommand command, IDbDataParameter parameter)
|
|
|
352 {
|
|
|
353 var oraParameter = (parameter is OracleParameterWrap)?
|
|
|
354 (parameter as OracleParameterWrap).OracleParameter: parameter as OracleParameter;
|
|
|
355
|
|
|
356 if (null != oraParameter)
|
|
|
357 {
|
|
|
358 if (oraParameter.CollectionType == OracleCollectionType.PLSQLAssociativeArray)
|
|
|
359 {
|
|
|
360 if (oraParameter.Direction == ParameterDirection.Input
|
|
|
361 || oraParameter.Direction == ParameterDirection.InputOutput)
|
|
|
362 {
|
|
|
363 var ar = oraParameter.Value as Array;
|
|
|
364
|
|
|
365 if (null != ar && !(ar is byte[] || ar is char[]))
|
|
|
366 {
|
|
|
367 oraParameter.Size = ar.Length;
|
|
|
368
|
|
|
369 if (oraParameter.DbType == DbType.String
|
|
|
370 && oraParameter.Direction == ParameterDirection.InputOutput)
|
|
|
371 {
|
|
|
372 var arrayBindSize = new int[oraParameter.Size];
|
|
|
373
|
|
|
374 for (var i = 0; i < oraParameter.Size; ++i)
|
|
|
375 {
|
|
|
376 arrayBindSize[i] = 1024;
|
|
|
377 }
|
|
|
378
|
|
|
379 oraParameter.ArrayBindSize = arrayBindSize;
|
|
|
380 }
|
|
|
381 }
|
|
|
382
|
|
|
383 if (oraParameter.Size == 0)
|
|
|
384 {
|
|
|
385 // Skip this parameter.
|
|
|
386 // Fix Oracle.Net bug #2: Empty arrays can not be sent to the server.
|
|
|
387 //
|
|
|
388 return;
|
|
|
389 }
|
|
|
390
|
|
|
391 if (oraParameter.Value is Stream[])
|
|
|
392 {
|
|
|
393 var streams = (Stream[]) oraParameter.Value;
|
|
|
394
|
|
|
395 for (var i = 0; i < oraParameter.Size; ++i)
|
|
|
396 {
|
|
|
397 if (streams[i] is OracleBFile || streams[i] is OracleBlob || streams[i] is OracleClob
|
|
|
398 #if !MANAGED
|
|
|
399 || streams[i] is OracleXmlStream
|
|
|
400 #endif
|
|
|
401 )
|
|
|
402 {
|
|
|
403 // Known Oracle type.
|
|
|
404 //
|
|
|
405 continue;
|
|
|
406 }
|
|
|
407
|
|
|
408 streams[i] = CopyStream(streams[i], (OracleCommand)command);
|
|
|
409 }
|
|
|
410 }
|
|
|
411 else if (oraParameter.Value is XmlDocument[])
|
|
|
412 {
|
|
|
413 var xmlDocuments = (XmlDocument[]) oraParameter.Value;
|
|
|
414 var values = new object[oraParameter.Size];
|
|
|
415
|
|
|
416 switch (oraParameter.OracleDbType)
|
|
|
417 {
|
|
|
418 case OracleDbType.XmlType:
|
|
|
419 #if !MANAGED
|
|
|
420 for (var i = 0; i < oraParameter.Size; ++i)
|
|
|
421 {
|
|
|
422 values[i] = xmlDocuments[i].DocumentElement == null?
|
|
|
423 (object) DBNull.Value:
|
|
|
424 new OracleXmlType((OracleConnection)command.Connection, xmlDocuments[i]);
|
|
|
425 }
|
|
|
426
|
|
|
427 oraParameter.Value = values;
|
|
|
428 break;
|
|
|
429 #else
|
|
|
430 throw new NotSupportedException();
|
|
|
431 #endif
|
|
|
432 // Fix Oracle.Net bug #9: XmlDocument.ToString() returns System.Xml.XmlDocument,
|
|
|
433 // so m_value.ToString() is not enought.
|
|
|
434 //
|
|
|
435 case OracleDbType.Clob:
|
|
|
436 case OracleDbType.NClob:
|
|
|
437 case OracleDbType.Varchar2:
|
|
|
438 case OracleDbType.NVarchar2:
|
|
|
439 case OracleDbType.Char:
|
|
|
440 case OracleDbType.NChar:
|
|
|
441 for (var i = 0; i < oraParameter.Size; ++i)
|
|
|
442 {
|
|
|
443 values[i] = xmlDocuments[i].DocumentElement == null?
|
|
|
444 (object) DBNull.Value:
|
|
|
445 xmlDocuments[i].InnerXml;
|
|
|
446 }
|
|
|
447
|
|
|
448 oraParameter.Value = values;
|
|
|
449
|
|
|
450 break;
|
|
|
451
|
|
|
452 // Or convert to bytes if need.
|
|
|
453 //
|
|
|
454 case OracleDbType.Blob:
|
|
|
455 case OracleDbType.BFile:
|
|
|
456 case OracleDbType.Raw:
|
|
|
457 case OracleDbType.Long:
|
|
|
458 case OracleDbType.LongRaw:
|
|
|
459 for (var i = 0; i < oraParameter.Size; ++i)
|
|
|
460 {
|
|
|
461 if (xmlDocuments[i].DocumentElement == null)
|
|
|
462 values[i] = DBNull.Value;
|
|
|
463 else
|
|
|
464 using (var s = new MemoryStream())
|
|
|
465 {
|
|
|
466 xmlDocuments[i].Save(s);
|
|
|
467 values[i] = s.GetBuffer();
|
|
|
468 }
|
|
|
469 }
|
|
|
470
|
|
|
471 oraParameter.Value = values;
|
|
|
472
|
|
|
473 break;
|
|
|
474 }
|
|
|
475 }
|
|
|
476 }
|
|
|
477 else if (oraParameter.Direction == ParameterDirection.Output)
|
|
|
478 {
|
|
|
479 // Fix Oracle.Net bug #4: ArrayBindSize must be explicitly specified.
|
|
|
480 //
|
|
|
481 if (oraParameter.DbType == DbType.String)
|
|
|
482 {
|
|
|
483 oraParameter.Size = 1024;
|
|
|
484 var arrayBindSize = new int[oraParameter.Size];
|
|
|
485 for (var i = 0; i < oraParameter.Size; ++i)
|
|
|
486 {
|
|
|
487 arrayBindSize[i] = 1024;
|
|
|
488 }
|
|
|
489
|
|
|
490 oraParameter.ArrayBindSize = arrayBindSize;
|
|
|
491 }
|
|
|
492 else
|
|
|
493 {
|
|
|
494 oraParameter.Size = 32767;
|
|
|
495 }
|
|
|
496 }
|
|
|
497 }
|
|
|
498 else if (oraParameter.Value is Stream)
|
|
|
499 {
|
|
|
500 var stream = (Stream) oraParameter.Value;
|
|
|
501
|
|
|
502 if (!(stream is OracleBFile) && !(stream is OracleBlob) &&
|
|
|
503 !(stream is OracleClob)
|
|
|
504 #if !MANAGED
|
|
|
505 && !(stream is OracleXmlStream)
|
|
|
506 #endif
|
|
|
507 )
|
|
|
508 {
|
|
|
509 oraParameter.Value = CopyStream(stream, (OracleCommand)command);
|
|
|
510 }
|
|
|
511 }
|
|
|
512 else if (oraParameter.Value is Byte[])
|
|
|
513 {
|
|
|
514 var bytes = (Byte[]) oraParameter.Value;
|
|
|
515
|
|
|
516 if (bytes.Length > 32000)
|
|
|
517 {
|
|
|
518 oraParameter.Value = CopyStream(bytes, (OracleCommand)command);
|
|
|
519 }
|
|
|
520 }
|
|
|
521 else if (oraParameter.Value is XmlDocument)
|
|
|
522 {
|
|
|
523 var xmlDocument = (XmlDocument)oraParameter.Value;
|
|
|
524 if (xmlDocument.DocumentElement == null)
|
|
|
525 oraParameter.Value = DBNull.Value;
|
|
|
526 else
|
|
|
527 {
|
|
|
528
|
|
|
529 switch (oraParameter.OracleDbType)
|
|
|
530 {
|
|
|
531 case OracleDbType.XmlType:
|
|
|
532 #if !MANAGED
|
|
|
533 oraParameter.Value = new OracleXmlType((OracleConnection)command.Connection, xmlDocument);
|
|
|
534 break;
|
|
|
535 #else
|
|
|
536 throw new NotSupportedException();
|
|
|
537 #endif
|
|
|
538
|
|
|
539 // Fix Oracle.Net bug #9: XmlDocument.ToString() returns System.Xml.XmlDocument,
|
|
|
540 // so m_value.ToString() is not enought.
|
|
|
541 //
|
|
|
542 case OracleDbType.Clob:
|
|
|
543 case OracleDbType.NClob:
|
|
|
544 case OracleDbType.Varchar2:
|
|
|
545 case OracleDbType.NVarchar2:
|
|
|
546 case OracleDbType.Char:
|
|
|
547 case OracleDbType.NChar:
|
|
|
548 using (TextWriter w = new StringWriter())
|
|
|
549 {
|
|
|
550 xmlDocument.Save(w);
|
|
|
551 oraParameter.Value = w.ToString();
|
|
|
552 }
|
|
|
553 break;
|
|
|
554
|
|
|
555 // Or convert to bytes if need.
|
|
|
556 //
|
|
|
557 case OracleDbType.Blob:
|
|
|
558 case OracleDbType.BFile:
|
|
|
559 case OracleDbType.Raw:
|
|
|
560 case OracleDbType.Long:
|
|
|
561 case OracleDbType.LongRaw:
|
|
|
562 using (var s = new MemoryStream())
|
|
|
563 {
|
|
|
564 xmlDocument.Save(s);
|
|
|
565 oraParameter.Value = s.GetBuffer();
|
|
|
566 }
|
|
|
567 break;
|
|
|
568 }
|
|
|
569 }
|
|
|
570 }
|
|
|
571
|
|
|
572 parameter = oraParameter;
|
|
|
573 }
|
|
|
574
|
|
|
575 base.AttachParameter(command, parameter);
|
|
|
576 }
|
|
|
577
|
|
|
578 private static Stream CopyStream(Stream stream, OracleCommand cmd)
|
|
|
579 {
|
|
|
580 return CopyStream(Common.Convert.ToByteArray(stream), cmd);
|
|
|
581 }
|
|
|
582
|
|
|
583 private static Stream CopyStream(Byte[] bytes, OracleCommand cmd)
|
|
|
584 {
|
|
|
585 var ret = new OracleBlob(cmd.Connection);
|
|
|
586 ret.Write(bytes, 0, bytes.Length);
|
|
|
587 return ret;
|
|
|
588 }
|
|
|
589
|
|
|
590 public override bool IsValueParameter(IDbDataParameter parameter)
|
|
|
591 {
|
|
|
592 var oraParameter = (parameter is OracleParameterWrap)?
|
|
|
593 (parameter as OracleParameterWrap).OracleParameter: parameter as OracleParameter;
|
|
|
594
|
|
|
595 if (null != oraParameter)
|
|
|
596 {
|
|
|
597 if (oraParameter.OracleDbType == OracleDbType.RefCursor
|
|
|
598 && oraParameter.Direction == ParameterDirection.Output)
|
|
|
599 {
|
|
|
600 // Ignore out ref cursors, while out parameters of other types are o.k.
|
|
|
601 return false;
|
|
|
602 }
|
|
|
603 }
|
|
|
604
|
|
|
605 return base.IsValueParameter(parameter);
|
|
|
606 }
|
|
|
607
|
|
|
608 public override IDbDataParameter CreateParameterObject(IDbCommand command)
|
|
|
609 {
|
|
|
610 var parameter = base.CreateParameterObject(command);
|
|
|
611
|
|
|
612 if (parameter is OracleParameter)
|
|
|
613 parameter = OracleParameterWrap.CreateInstance(parameter as OracleParameter);
|
|
|
614
|
|
|
615 return parameter;
|
|
|
616 }
|
|
|
617
|
|
|
618 public override IDbDataParameter GetParameter(IDbCommand command, NameOrIndexParameter nameOrIndex)
|
|
|
619 {
|
|
|
620 var parameter = base.GetParameter(command, nameOrIndex);
|
|
|
621
|
|
|
622 if (parameter is OracleParameter)
|
|
|
623 parameter = OracleParameterWrap.CreateInstance(parameter as OracleParameter);
|
|
|
624
|
|
|
625 return parameter;
|
|
|
626 }
|
|
|
627
|
|
|
628 /// <summary>
|
|
|
629 /// Returns connection type.
|
|
|
630 /// </summary>
|
|
|
631 /// <remarks>
|
|
|
632 /// See the <see cref="DbManager.AddDataProvider(DataProviderBase)"/> method to find an example.
|
|
|
633 /// </remarks>
|
|
|
634 /// <seealso cref="DbManager.AddDataProvider(DataProviderBase)">AddDataManager Method</seealso>
|
|
|
635 /// <value>An instance of the <see cref="Type"/> class.</value>
|
|
|
636 public override Type ConnectionType
|
|
|
637 {
|
|
|
638 get { return typeof(OracleConnection); }
|
|
|
639 }
|
|
|
640
|
|
|
641 /// <summary>
|
|
|
642 /// Returns the data provider name.
|
|
|
643 /// </summary>
|
|
|
644 /// <remarks>
|
|
|
645 /// See the <see cref="DbManager.AddDataProvider(DataProviderBase)"/> method to find an example.
|
|
|
646 /// </remarks>
|
|
|
647 /// <seealso cref="DbManager.AddDataProvider(DataProviderBase)">AddDataProvider Method</seealso>
|
|
|
648 /// <value>Data provider name.</value>
|
|
|
649 public override string Name
|
|
|
650 {
|
|
|
651 get { return NameString; }
|
|
|
652 }
|
|
|
653
|
|
|
654 public override int MaxBatchSize
|
|
|
655 {
|
|
|
656 get { return 0; }
|
|
|
657 }
|
|
|
658
|
|
|
659 public override int ExecuteArray(IDbCommand command, int iterations)
|
|
|
660 {
|
|
|
661 var cmd = (OracleCommand)command;
|
|
|
662 var oracleParameters = cmd.Parameters.OfType<OracleParameter>().ToArray();
|
|
|
663 var oldCollectionTypes = oracleParameters.Select(p => p.CollectionType).ToArray();
|
|
|
664
|
|
|
665 try
|
|
|
666 {
|
|
|
667 foreach (var p in oracleParameters)
|
|
|
668 {
|
|
|
669 p.CollectionType = OracleCollectionType.None;
|
|
|
670 }
|
|
|
671
|
|
|
672 cmd.ArrayBindCount = iterations;
|
|
|
673 return cmd.ExecuteNonQuery();
|
|
|
674 }
|
|
|
675 finally
|
|
|
676 {
|
|
|
677 foreach (var p in oracleParameters.Zip(oldCollectionTypes, (p, t) => new { Param = p, CollectionType = t }))
|
|
|
678 {
|
|
|
679 p.Param.CollectionType = p.CollectionType;
|
|
|
680 }
|
|
|
681
|
|
|
682 cmd.ArrayBindCount = 0;
|
|
|
683 }
|
|
|
684 }
|
|
|
685
|
|
|
686 public override ISqlProvider CreateSqlProvider()
|
|
|
687 {
|
|
|
688 return new OracleSqlProvider();
|
|
|
689 }
|
|
|
690
|
|
|
691 public override IDataReader GetDataReader(MappingSchema schema, IDataReader dataReader)
|
|
|
692 {
|
|
|
693 return dataReader is OracleDataReader ?
|
|
|
694 new OracleDataReaderEx((OracleDataReader)dataReader) :
|
|
|
695 base.GetDataReader(schema, dataReader);
|
|
|
696 }
|
|
|
697
|
|
|
698 class OracleDataReaderEx: DataReaderEx<OracleDataReader>
|
|
|
699 {
|
|
|
700 public OracleDataReaderEx(OracleDataReader rd)
|
|
|
701 : base(rd)
|
|
|
702 {
|
|
|
703 }
|
|
|
704
|
|
|
705 public override DateTimeOffset GetDateTimeOffset(int i)
|
|
|
706 {
|
|
|
707 var ts = DataReader.GetOracleTimeStampTZ(i);
|
|
|
708 return new DateTimeOffset(ts.Value, ts.GetTimeZoneOffset());
|
|
|
709 }
|
|
|
710 }
|
|
|
711
|
|
|
712 private string _parameterPrefix = "P";
|
|
|
713 public string ParameterPrefix
|
|
|
714 {
|
|
|
715 get { return _parameterPrefix; }
|
|
|
716 set
|
|
|
717 {
|
|
|
718 _parameterPrefix = string.IsNullOrEmpty(value)? null:
|
|
|
719 value.ToUpper(CultureInfo.InvariantCulture);
|
|
|
720 }
|
|
|
721 }
|
|
|
722
|
|
|
723 /// <summary>
|
|
|
724 /// One time initialization from a configuration file.
|
|
|
725 /// </summary>
|
|
|
726 /// <param name="attributes">Provider specific attributes.</param>
|
|
|
727 public override void Configure(System.Collections.Specialized.NameValueCollection attributes)
|
|
|
728 {
|
|
|
729 var val = attributes["ParameterPrefix"];
|
|
|
730 if (val != null)
|
|
|
731 ParameterPrefix = val;
|
|
|
732
|
|
|
733 base.Configure(attributes);
|
|
|
734 }
|
|
|
735
|
|
|
736 #region Inner types
|
|
|
737
|
|
|
738 public class OdpMappingSchema : MappingSchema
|
|
|
739 {
|
|
|
740 public override DataReaderMapper CreateDataReaderMapper(IDataReader dataReader)
|
|
|
741 {
|
|
|
742 return new OracleDataReaderMapper(this, dataReader);
|
|
|
743 }
|
|
|
744
|
|
|
745 public override DataReaderMapper CreateDataReaderMapper(
|
|
|
746 IDataReader dataReader,
|
|
|
747 NameOrIndexParameter nip)
|
|
|
748 {
|
|
|
749 return new OracleScalarDataReaderMapper(this, dataReader, nip);
|
|
|
750 }
|
|
|
751
|
|
|
752 public override Reflection.Extension.ExtensionList Extensions
|
|
|
753 {
|
|
|
754 get { return Map.DefaultSchema.Extensions; }
|
|
|
755 set { Map.DefaultSchema.Extensions = value; }
|
|
|
756 }
|
|
|
757
|
|
|
758 #region Convert
|
|
|
759
|
|
|
760 #region Primitive Types
|
|
|
761
|
|
|
762 [CLSCompliant(false)]
|
|
|
763 public override SByte ConvertToSByte(object value)
|
|
|
764 {
|
|
|
765 if (value is OracleDecimal)
|
|
|
766 {
|
|
|
767 var oraDecimal = (OracleDecimal)value;
|
|
|
768 return oraDecimal.IsNull? DefaultSByteNullValue: (SByte)oraDecimal.Value;
|
|
|
769 }
|
|
|
770
|
|
|
771 return base.ConvertToSByte(value);
|
|
|
772 }
|
|
|
773
|
|
|
774 public override Int16 ConvertToInt16(object value)
|
|
|
775 {
|
|
|
776 if (value is OracleDecimal)
|
|
|
777 {
|
|
|
778 var oraDecimal = (OracleDecimal)value;
|
|
|
779 return oraDecimal.IsNull? DefaultInt16NullValue: oraDecimal.ToInt16();
|
|
|
780 }
|
|
|
781
|
|
|
782 return base.ConvertToInt16(value);
|
|
|
783 }
|
|
|
784
|
|
|
785 public override Int32 ConvertToInt32(object value)
|
|
|
786 {
|
|
|
787 if (value is OracleDecimal)
|
|
|
788 {
|
|
|
789 var oraDecimal = (OracleDecimal)value;
|
|
|
790 return oraDecimal.IsNull? DefaultInt32NullValue: oraDecimal.ToInt32();
|
|
|
791 }
|
|
|
792
|
|
|
793 return base.ConvertToInt32(value);
|
|
|
794 }
|
|
|
795
|
|
|
796 public override Int64 ConvertToInt64(object value)
|
|
|
797 {
|
|
|
798 if (value is OracleDecimal)
|
|
|
799 {
|
|
|
800 var oraDecimal = (OracleDecimal)value;
|
|
|
801 return oraDecimal.IsNull? DefaultInt64NullValue: oraDecimal.ToInt64();
|
|
|
802 }
|
|
|
803
|
|
|
804 return base.ConvertToInt64(value);
|
|
|
805 }
|
|
|
806
|
|
|
807 public override Byte ConvertToByte(object value)
|
|
|
808 {
|
|
|
809 if (value is OracleDecimal)
|
|
|
810 {
|
|
|
811 var oraDecimal = (OracleDecimal)value;
|
|
|
812 return oraDecimal.IsNull? DefaultByteNullValue: oraDecimal.ToByte();
|
|
|
813 }
|
|
|
814
|
|
|
815 return base.ConvertToByte(value);
|
|
|
816 }
|
|
|
817
|
|
|
818 [CLSCompliant(false)]
|
|
|
819 public override UInt16 ConvertToUInt16(object value)
|
|
|
820 {
|
|
|
821 if (value is OracleDecimal)
|
|
|
822 {
|
|
|
823 var oraDecimal = (OracleDecimal)value;
|
|
|
824 return oraDecimal.IsNull? DefaultUInt16NullValue: (UInt16)oraDecimal.Value;
|
|
|
825 }
|
|
|
826
|
|
|
827 return base.ConvertToUInt16(value);
|
|
|
828 }
|
|
|
829
|
|
|
830 [CLSCompliant(false)]
|
|
|
831 public override UInt32 ConvertToUInt32(object value)
|
|
|
832 {
|
|
|
833 if (value is OracleDecimal)
|
|
|
834 {
|
|
|
835 var oraDecimal = (OracleDecimal)value;
|
|
|
836 return oraDecimal.IsNull? DefaultUInt32NullValue: (UInt32)oraDecimal.Value;
|
|
|
837 }
|
|
|
838
|
|
|
839 return base.ConvertToUInt32(value);
|
|
|
840 }
|
|
|
841
|
|
|
842 [CLSCompliant(false)]
|
|
|
843 public override UInt64 ConvertToUInt64(object value)
|
|
|
844 {
|
|
|
845 if (value is OracleDecimal)
|
|
|
846 {
|
|
|
847 var oraDecimal = (OracleDecimal)value;
|
|
|
848 return oraDecimal.IsNull? DefaultUInt64NullValue: (UInt64)oraDecimal.Value;
|
|
|
849 }
|
|
|
850
|
|
|
851 return base.ConvertToUInt64(value);
|
|
|
852 }
|
|
|
853
|
|
|
854 public override Single ConvertToSingle(object value)
|
|
|
855 {
|
|
|
856 if (value is OracleDecimal)
|
|
|
857 {
|
|
|
858 var oraDecimal = (OracleDecimal)value;
|
|
|
859 return oraDecimal.IsNull? DefaultSingleNullValue: oraDecimal.ToSingle();
|
|
|
860 }
|
|
|
861
|
|
|
862 return base.ConvertToSingle(value);
|
|
|
863 }
|
|
|
864
|
|
|
865 public override Double ConvertToDouble(object value)
|
|
|
866 {
|
|
|
867 if (value is OracleDecimal)
|
|
|
868 {
|
|
|
869 var oraDecimal = (OracleDecimal)value;
|
|
|
870 return oraDecimal.IsNull? DefaultDoubleNullValue: oraDecimal.ToDouble();
|
|
|
871 }
|
|
|
872
|
|
|
873 return base.ConvertToDouble(value);
|
|
|
874 }
|
|
|
875
|
|
|
876 public override Boolean ConvertToBoolean(object value)
|
|
|
877 {
|
|
|
878 if (value is OracleDecimal)
|
|
|
879 {
|
|
|
880 var oraDecimal = (OracleDecimal)value;
|
|
|
881 return oraDecimal.IsNull? DefaultBooleanNullValue: (oraDecimal.Value != 0);
|
|
|
882 }
|
|
|
883
|
|
|
884 return base.ConvertToBoolean(value);
|
|
|
885 }
|
|
|
886
|
|
|
887 public override DateTime ConvertToDateTime(object value)
|
|
|
888 {
|
|
|
889 if (value is OracleDate)
|
|
|
890 {
|
|
|
891 var oraDate = (OracleDate)value;
|
|
|
892 return oraDate.IsNull? DefaultDateTimeNullValue: oraDate.Value;
|
|
|
893 }
|
|
|
894
|
|
|
895 return base.ConvertToDateTime(value);
|
|
|
896 }
|
|
|
897
|
|
|
898 public override Decimal ConvertToDecimal(object value)
|
|
|
899 {
|
|
|
900 if (value is OracleDecimal)
|
|
|
901 {
|
|
|
902 var oraDecimal = (OracleDecimal)value;
|
|
|
903 return oraDecimal.IsNull? DefaultDecimalNullValue: oraDecimal.Value;
|
|
|
904 }
|
|
|
905
|
|
|
906 return base.ConvertToDecimal(value);
|
|
|
907 }
|
|
|
908
|
|
|
909 public override Guid ConvertToGuid(object value)
|
|
|
910 {
|
|
|
911 if (value is OracleString)
|
|
|
912 {
|
|
|
913 var oraString = (OracleString)value;
|
|
|
914 return oraString.IsNull? DefaultGuidNullValue: new Guid(oraString.Value);
|
|
|
915 }
|
|
|
916
|
|
|
917 if (value is OracleBlob)
|
|
|
918 {
|
|
|
919 using (var oraBlob = (OracleBlob)value)
|
|
|
920 return oraBlob.IsNull? DefaultGuidNullValue: new Guid(oraBlob.Value);
|
|
|
921 }
|
|
|
922
|
|
|
923 return base.ConvertToGuid(value);
|
|
|
924 }
|
|
|
925
|
|
|
926 public override String ConvertToString(object value)
|
|
|
927 {
|
|
|
928 if (value is OracleString)
|
|
|
929 {
|
|
|
930 var oraString = (OracleString)value;
|
|
|
931 return oraString.IsNull? DefaultStringNullValue: oraString.Value;
|
|
|
932 }
|
|
|
933 #if !MANAGED
|
|
|
934 if (value is OracleXmlType)
|
|
|
935 {
|
|
|
936 var oraXmlType = (OracleXmlType)value;
|
|
|
937 return oraXmlType.IsNull ? DefaultStringNullValue : oraXmlType.Value;
|
|
|
938 }
|
|
|
939 #endif
|
|
|
940 if (value is OracleClob)
|
|
|
941 {
|
|
|
942 using (var oraClob = (OracleClob)value)
|
|
|
943 return oraClob.IsNull? DefaultStringNullValue: oraClob.Value;
|
|
|
944 }
|
|
|
945
|
|
|
946 return base.ConvertToString(value);
|
|
|
947 }
|
|
|
948
|
|
|
949 #if !MANAGED
|
|
|
950 public override Stream ConvertToStream(object value)
|
|
|
951 {
|
|
|
952 if (value is OracleXmlType)
|
|
|
953 {
|
|
|
954 var oraXml = (OracleXmlType)value;
|
|
|
955 return oraXml.IsNull? DefaultStreamNullValue: oraXml.GetStream();
|
|
|
956 }
|
|
|
957
|
|
|
958 return base.ConvertToStream(value);
|
|
|
959 }
|
|
|
960
|
|
|
961 public override XmlReader ConvertToXmlReader(object value)
|
|
|
962 {
|
|
|
963 if (value is OracleXmlType)
|
|
|
964 {
|
|
|
965 var oraXml = (OracleXmlType)value;
|
|
|
966 return oraXml.IsNull? DefaultXmlReaderNullValue: oraXml.GetXmlReader();
|
|
|
967 }
|
|
|
968
|
|
|
969 return base.ConvertToXmlReader(value);
|
|
|
970 }
|
|
|
971
|
|
|
972 public override XmlDocument ConvertToXmlDocument(object value)
|
|
|
973 {
|
|
|
974 if (value is OracleXmlType)
|
|
|
975 {
|
|
|
976 var oraXml = (OracleXmlType)value;
|
|
|
977 return oraXml.IsNull? DefaultXmlDocumentNullValue: oraXml.GetXmlDocument();
|
|
|
978 }
|
|
|
979
|
|
|
980 return base.ConvertToXmlDocument(value);
|
|
|
981 }
|
|
|
982 #endif
|
|
|
983
|
|
|
984 public override Byte[] ConvertToByteArray(object value)
|
|
|
985 {
|
|
|
986 if (value is OracleBlob)
|
|
|
987 {
|
|
|
988 using (var oraBlob = (OracleBlob)value)
|
|
|
989 return oraBlob.IsNull? null: oraBlob.Value;
|
|
|
990 }
|
|
|
991
|
|
|
992 if (value is OracleBinary)
|
|
|
993 {
|
|
|
994 var oraBinary = (OracleBinary)value;
|
|
|
995 return oraBinary.IsNull? null: oraBinary.Value;
|
|
|
996 }
|
|
|
997
|
|
|
998 if (value is OracleBFile)
|
|
|
999 {
|
|
|
1000 var oraBFile = (OracleBFile)value;
|
|
|
1001 return oraBFile.IsNull? null: oraBFile.Value;
|
|
|
1002 }
|
|
|
1003
|
|
|
1004 return base.ConvertToByteArray(value);
|
|
|
1005 }
|
|
|
1006
|
|
|
1007 public override Char[] ConvertToCharArray(object value)
|
|
|
1008 {
|
|
|
1009 if (value is OracleString)
|
|
|
1010 {
|
|
|
1011 var oraString = (OracleString)value;
|
|
|
1012 return oraString.IsNull? null: oraString.Value.ToCharArray();
|
|
|
1013 }
|
|
|
1014
|
|
|
1015 if (value is OracleClob)
|
|
|
1016 {
|
|
|
1017 using (var oraClob = (OracleClob)value)
|
|
|
1018 return oraClob.IsNull? null: oraClob.Value.ToCharArray();
|
|
|
1019 }
|
|
|
1020
|
|
|
1021 return base.ConvertToCharArray(value);
|
|
|
1022 }
|
|
|
1023
|
|
|
1024 #endregion
|
|
|
1025
|
|
|
1026 #region Nullable Types
|
|
|
1027
|
|
|
1028 [CLSCompliant(false)]
|
|
|
1029 public override SByte? ConvertToNullableSByte(object value)
|
|
|
1030 {
|
|
|
1031 if (value is OracleDecimal)
|
|
|
1032 {
|
|
|
1033 var oraDecimal = (OracleDecimal)value;
|
|
|
1034 return oraDecimal.IsNull? null: (SByte?)oraDecimal.Value;
|
|
|
1035 }
|
|
|
1036
|
|
|
1037 return base.ConvertToNullableSByte(value);
|
|
|
1038 }
|
|
|
1039
|
|
|
1040 public override Int16? ConvertToNullableInt16(object value)
|
|
|
1041 {
|
|
|
1042 if (value is OracleDecimal)
|
|
|
1043 {
|
|
|
1044 var oraDecimal = (OracleDecimal)value;
|
|
|
1045 return oraDecimal.IsNull? null: (Int16?)oraDecimal.ToInt16();
|
|
|
1046 }
|
|
|
1047
|
|
|
1048 return base.ConvertToNullableInt16(value);
|
|
|
1049 }
|
|
|
1050
|
|
|
1051 public override Int32? ConvertToNullableInt32(object value)
|
|
|
1052 {
|
|
|
1053 if (value is OracleDecimal)
|
|
|
1054 {
|
|
|
1055 var oraDecimal = (OracleDecimal)value;
|
|
|
1056 return oraDecimal.IsNull? null: (Int32?)oraDecimal.ToInt32();
|
|
|
1057 }
|
|
|
1058
|
|
|
1059 return base.ConvertToNullableInt32(value);
|
|
|
1060 }
|
|
|
1061
|
|
|
1062 public override Int64? ConvertToNullableInt64(object value)
|
|
|
1063 {
|
|
|
1064 if (value is OracleDecimal)
|
|
|
1065 {
|
|
|
1066 var oraDecimal = (OracleDecimal)value;
|
|
|
1067 return oraDecimal.IsNull? null: (Int64?)oraDecimal.ToInt64();
|
|
|
1068 }
|
|
|
1069
|
|
|
1070 return base.ConvertToNullableInt64(value);
|
|
|
1071 }
|
|
|
1072
|
|
|
1073 public override Byte? ConvertToNullableByte(object value)
|
|
|
1074 {
|
|
|
1075 if (value is OracleDecimal)
|
|
|
1076 {
|
|
|
1077 var oraDecimal = (OracleDecimal)value;
|
|
|
1078 return oraDecimal.IsNull? null: (Byte?)oraDecimal.ToByte();
|
|
|
1079 }
|
|
|
1080
|
|
|
1081 return base.ConvertToNullableByte(value);
|
|
|
1082 }
|
|
|
1083
|
|
|
1084 [CLSCompliant(false)]
|
|
|
1085 public override UInt16? ConvertToNullableUInt16(object value)
|
|
|
1086 {
|
|
|
1087 if (value is OracleDecimal)
|
|
|
1088 {
|
|
|
1089 var oraDecimal = (OracleDecimal)value;
|
|
|
1090 return oraDecimal.IsNull? null: (UInt16?)oraDecimal.Value;
|
|
|
1091 }
|
|
|
1092
|
|
|
1093 return base.ConvertToNullableUInt16(value);
|
|
|
1094 }
|
|
|
1095
|
|
|
1096 [CLSCompliant(false)]
|
|
|
1097 public override UInt32? ConvertToNullableUInt32(object value)
|
|
|
1098 {
|
|
|
1099 if (value is OracleDecimal)
|
|
|
1100 {
|
|
|
1101 var oraDecimal = (OracleDecimal)value;
|
|
|
1102 return oraDecimal.IsNull? null: (UInt32?)oraDecimal.Value;
|
|
|
1103 }
|
|
|
1104
|
|
|
1105 return base.ConvertToNullableUInt32(value);
|
|
|
1106 }
|
|
|
1107
|
|
|
1108 [CLSCompliant(false)]
|
|
|
1109 public override UInt64? ConvertToNullableUInt64(object value)
|
|
|
1110 {
|
|
|
1111 if (value is OracleDecimal)
|
|
|
1112 {
|
|
|
1113 var oraDecimal = (OracleDecimal)value;
|
|
|
1114 return oraDecimal.IsNull? null: (UInt64?)oraDecimal.Value;
|
|
|
1115 }
|
|
|
1116
|
|
|
1117 return base.ConvertToNullableUInt64(value);
|
|
|
1118 }
|
|
|
1119
|
|
|
1120 public override Single? ConvertToNullableSingle(object value)
|
|
|
1121 {
|
|
|
1122 if (value is OracleDecimal)
|
|
|
1123 {
|
|
|
1124 var oraDecimal = (OracleDecimal)value;
|
|
|
1125 return oraDecimal.IsNull? null: (Single?)oraDecimal.ToSingle();
|
|
|
1126 }
|
|
|
1127
|
|
|
1128 return base.ConvertToNullableSingle(value);
|
|
|
1129 }
|
|
|
1130
|
|
|
1131 public override Double? ConvertToNullableDouble(object value)
|
|
|
1132 {
|
|
|
1133 if (value is OracleDecimal)
|
|
|
1134 {
|
|
|
1135 var oraDecimal = (OracleDecimal)value;
|
|
|
1136 return oraDecimal.IsNull? null: (Double?)oraDecimal.ToDouble();
|
|
|
1137 }
|
|
|
1138
|
|
|
1139 return base.ConvertToNullableDouble(value);
|
|
|
1140 }
|
|
|
1141
|
|
|
1142 public override Boolean? ConvertToNullableBoolean(object value)
|
|
|
1143 {
|
|
|
1144 if (value is OracleDecimal)
|
|
|
1145 {
|
|
|
1146 var oraDecimal = (OracleDecimal)value;
|
|
|
1147 return oraDecimal.IsNull? null: (Boolean?)(oraDecimal.Value != 0);
|
|
|
1148 }
|
|
|
1149
|
|
|
1150 return base.ConvertToNullableBoolean(value);
|
|
|
1151 }
|
|
|
1152
|
|
|
1153 public override DateTime? ConvertToNullableDateTime(object value)
|
|
|
1154 {
|
|
|
1155 if (value is OracleDate)
|
|
|
1156 {
|
|
|
1157 var oraDate = (OracleDate)value;
|
|
|
1158 return oraDate.IsNull? null: (DateTime?)oraDate.Value;
|
|
|
1159 }
|
|
|
1160
|
|
|
1161 return base.ConvertToNullableDateTime(value);
|
|
|
1162 }
|
|
|
1163
|
|
|
1164 public override Decimal? ConvertToNullableDecimal(object value)
|
|
|
1165 {
|
|
|
1166 if (value is OracleDecimal)
|
|
|
1167 {
|
|
|
1168 var oraDecimal = (OracleDecimal)value;
|
|
|
1169 return oraDecimal.IsNull? null: (Decimal?)oraDecimal.Value;
|
|
|
1170 }
|
|
|
1171
|
|
|
1172 return base.ConvertToNullableDecimal(value);
|
|
|
1173 }
|
|
|
1174
|
|
|
1175 public override Guid? ConvertToNullableGuid(object value)
|
|
|
1176 {
|
|
|
1177 if (value is OracleString)
|
|
|
1178 {
|
|
|
1179 var oraString = (OracleString)value;
|
|
|
1180 return oraString.IsNull? null: (Guid?)new Guid(oraString.Value);
|
|
|
1181 }
|
|
|
1182
|
|
|
1183 if (value is OracleBlob)
|
|
|
1184 {
|
|
|
1185 using (var oraBlob = (OracleBlob)value)
|
|
|
1186 return oraBlob.IsNull? null: (Guid?)new Guid(oraBlob.Value);
|
|
|
1187 }
|
|
|
1188
|
|
|
1189 return base.ConvertToNullableGuid(value);
|
|
|
1190 }
|
|
|
1191
|
|
|
1192 #endregion
|
|
|
1193
|
|
|
1194 #endregion
|
|
|
1195
|
|
|
1196 public override object MapValueToEnum(object value, Type type)
|
|
|
1197 {
|
|
|
1198 if (value is OracleString)
|
|
|
1199 {
|
|
|
1200 var oracleValue = (OracleString)value;
|
|
|
1201 value = oracleValue.IsNull? null: oracleValue.Value;
|
|
|
1202 }
|
|
|
1203 else if (value is OracleDecimal)
|
|
|
1204 {
|
|
|
1205 var oracleValue = (OracleDecimal)value;
|
|
|
1206 if (oracleValue.IsNull)
|
|
|
1207 value = null;
|
|
|
1208 else
|
|
|
1209 value = oracleValue.Value;
|
|
|
1210 }
|
|
|
1211
|
|
|
1212 return base.MapValueToEnum(value, type);
|
|
|
1213 }
|
|
|
1214
|
|
|
1215 public override object MapValueToEnum(object value, MemberAccessor ma)
|
|
|
1216 {
|
|
|
1217 if (value is OracleString)
|
|
|
1218 {
|
|
|
1219 var oracleValue = (OracleString)value;
|
|
|
1220 value = oracleValue.IsNull ? null : oracleValue.Value;
|
|
|
1221 }
|
|
|
1222 else if (value is OracleDecimal)
|
|
|
1223 {
|
|
|
1224 var oracleValue = (OracleDecimal)value;
|
|
|
1225 if (oracleValue.IsNull)
|
|
|
1226 value = null;
|
|
|
1227 else
|
|
|
1228 value = oracleValue.Value;
|
|
|
1229 }
|
|
|
1230
|
|
|
1231 return base.MapValueToEnum(value, ma);
|
|
|
1232 }
|
|
|
1233
|
|
|
1234 public override object ConvertChangeType(object value, Type conversionType)
|
|
|
1235 {
|
|
|
1236 // Handle OracleDecimal with IsNull == true case
|
|
|
1237 //
|
|
|
1238 return base.ConvertChangeType(IsNull(value)? null: value, conversionType);
|
|
|
1239 }
|
|
|
1240
|
|
|
1241 public override bool IsNull(object value)
|
|
|
1242 {
|
|
|
1243 // ODP 10 does not expose this interface to public.
|
|
|
1244 //
|
|
|
1245 // return value is INullable && ((INullable)value).IsNull;
|
|
|
1246
|
|
|
1247 return
|
|
|
1248 value is OracleDecimal? ((OracleDecimal) value).IsNull:
|
|
|
1249 value is OracleString? ((OracleString) value).IsNull:
|
|
|
1250 value is OracleDate? ((OracleDate) value).IsNull:
|
|
|
1251 value is OracleTimeStamp? ((OracleTimeStamp) value).IsNull:
|
|
|
1252 value is OracleTimeStampTZ? ((OracleTimeStampTZ) value).IsNull:
|
|
|
1253 value is OracleTimeStampLTZ? ((OracleTimeStampLTZ)value).IsNull:
|
|
|
1254 #if !MANAGED
|
|
|
1255 value is OracleXmlType? ((OracleXmlType) value).IsNull:
|
|
|
1256 #endif
|
|
|
1257 value is OracleBlob? ((OracleBlob) value).IsNull:
|
|
|
1258 value is OracleClob? ((OracleClob) value).IsNull:
|
|
|
1259 value is OracleBFile? ((OracleBFile) value).IsNull:
|
|
|
1260 value is OracleBinary? ((OracleBinary) value).IsNull:
|
|
|
1261 value is OracleIntervalDS? ((OracleIntervalDS) value).IsNull:
|
|
|
1262 value is OracleIntervalYM? ((OracleIntervalYM) value).IsNull:
|
|
|
1263 base.IsNull(value);
|
|
|
1264 }
|
|
|
1265 }
|
|
|
1266
|
|
|
1267 // TODO: implement via IDataReaderEx / DataReaderEx
|
|
|
1268 //
|
|
|
1269 public class OracleDataReaderMapper : DataReaderMapper
|
|
|
1270 {
|
|
|
1271 public OracleDataReaderMapper(MappingSchema mappingSchema, IDataReader dataReader)
|
|
|
1272 : base(mappingSchema, dataReader)
|
|
|
1273 {
|
|
|
1274 _dataReader = dataReader is OracleDataReaderEx?
|
|
|
1275 ((OracleDataReaderEx)dataReader).DataReader:
|
|
|
1276 (OracleDataReader)dataReader;
|
|
|
1277 }
|
|
|
1278
|
|
|
1279 private readonly OracleDataReader _dataReader;
|
|
|
1280
|
|
|
1281 public override Type GetFieldType(int index)
|
|
|
1282 {
|
|
|
1283 var fieldType = _dataReader.GetProviderSpecificFieldType(index);
|
|
|
1284
|
|
|
1285 if (fieldType != typeof(OracleBlob)
|
|
|
1286 #if !MANAGED
|
|
|
1287 && fieldType != typeof(OracleXmlType)
|
|
|
1288 #endif
|
|
|
1289 )
|
|
|
1290 fieldType = _dataReader.GetFieldType(index);
|
|
|
1291
|
|
|
1292 return fieldType;
|
|
|
1293 }
|
|
|
1294
|
|
|
1295 public override object GetValue(object o, int index)
|
|
|
1296 {
|
|
|
1297 var fieldType = _dataReader.GetProviderSpecificFieldType(index);
|
|
|
1298
|
|
|
1299 #if !MANAGED
|
|
|
1300 if (fieldType == typeof(OracleXmlType))
|
|
|
1301 {
|
|
|
1302 var xml = _dataReader.GetOracleXmlType(index);
|
|
|
1303 return MappingSchema.ConvertToXmlDocument(xml);
|
|
|
1304 }
|
|
|
1305 #endif
|
|
|
1306 if (fieldType == typeof(OracleBlob))
|
|
|
1307 {
|
|
|
1308 var blob = _dataReader.GetOracleBlob(index);
|
|
|
1309 return MappingSchema.ConvertToStream(blob);
|
|
|
1310 }
|
|
|
1311
|
|
|
1312 return _dataReader.IsDBNull(index)? null:
|
|
|
1313 _dataReader.GetValue(index);
|
|
|
1314 }
|
|
|
1315
|
|
|
1316 public override Boolean GetBoolean(object o, int index) { return MappingSchema.ConvertToBoolean(GetValue(o, index)); }
|
|
|
1317 public override Char GetChar (object o, int index) { return MappingSchema.ConvertToChar (GetValue(o, index)); }
|
|
|
1318 public override Guid GetGuid (object o, int index) { return MappingSchema.ConvertToGuid (GetValue(o, index)); }
|
|
|
1319
|
|
|
1320 [CLSCompliant(false)]
|
|
|
1321 public override SByte GetSByte (object o, int index) { return (SByte)_dataReader.GetDecimal(index); }
|
|
|
1322 [CLSCompliant(false)]
|
|
|
1323 public override UInt16 GetUInt16 (object o, int index) { return (UInt16)_dataReader.GetDecimal(index); }
|
|
|
1324 [CLSCompliant(false)]
|
|
|
1325 public override UInt32 GetUInt32 (object o, int index) { return (UInt32)_dataReader.GetDecimal(index); }
|
|
|
1326 [CLSCompliant(false)]
|
|
|
1327 public override UInt64 GetUInt64 (object o, int index) { return (UInt64)_dataReader.GetDecimal(index); }
|
|
|
1328
|
|
|
1329 public override Decimal GetDecimal(object o, int index) { return OracleDecimal.SetPrecision(_dataReader.GetOracleDecimal(index), 28).Value; }
|
|
|
1330
|
|
|
1331 public override Boolean? GetNullableBoolean(object o, int index) { return MappingSchema.ConvertToNullableBoolean(GetValue(o, index)); }
|
|
|
1332 public override Char? GetNullableChar (object o, int index) { return MappingSchema.ConvertToNullableChar (GetValue(o, index)); }
|
|
|
1333 public override Guid? GetNullableGuid (object o, int index) { return MappingSchema.ConvertToNullableGuid (GetValue(o, index)); }
|
|
|
1334
|
|
|
1335 [CLSCompliant(false)]
|
|
|
1336 public override SByte? GetNullableSByte (object o, int index) { return _dataReader.IsDBNull(index)? null: (SByte?)_dataReader.GetDecimal(index); }
|
|
|
1337 [CLSCompliant(false)]
|
|
|
1338 public override UInt16? GetNullableUInt16 (object o, int index) { return _dataReader.IsDBNull(index)? null: (UInt16?)_dataReader.GetDecimal(index); }
|
|
|
1339 [CLSCompliant(false)]
|
|
|
1340 public override UInt32? GetNullableUInt32 (object o, int index) { return _dataReader.IsDBNull(index)? null: (UInt32?)_dataReader.GetDecimal(index); }
|
|
|
1341 [CLSCompliant(false)]
|
|
|
1342 public override UInt64? GetNullableUInt64 (object o, int index) { return _dataReader.IsDBNull(index)? null: (UInt64?)_dataReader.GetDecimal(index); }
|
|
|
1343
|
|
|
1344 public override Decimal? GetNullableDecimal(object o, int index) { return _dataReader.IsDBNull(index)? (decimal?)null: OracleDecimal.SetPrecision(_dataReader.GetOracleDecimal(index), 28).Value; }
|
|
|
1345 }
|
|
|
1346
|
|
|
1347 public class OracleScalarDataReaderMapper : ScalarDataReaderMapper
|
|
|
1348 {
|
|
|
1349 private readonly OracleDataReader _dataReader;
|
|
|
1350
|
|
|
1351 public OracleScalarDataReaderMapper(
|
|
|
1352 MappingSchema mappingSchema,
|
|
|
1353 IDataReader dataReader,
|
|
|
1354 NameOrIndexParameter nameOrIndex)
|
|
|
1355 : base(mappingSchema, dataReader, nameOrIndex)
|
|
|
1356 {
|
|
|
1357 _dataReader = dataReader is OracleDataReaderEx?
|
|
|
1358 ((OracleDataReaderEx)dataReader).DataReader:
|
|
|
1359 (OracleDataReader)dataReader;
|
|
|
1360
|
|
|
1361 _fieldType = _dataReader.GetProviderSpecificFieldType(Index);
|
|
|
1362
|
|
|
1363 if (_fieldType != typeof(OracleBlob)
|
|
|
1364 #if !MANAGED
|
|
|
1365 && _fieldType != typeof(OracleXmlType)
|
|
|
1366 #endif
|
|
|
1367 )
|
|
|
1368 _fieldType = _dataReader.GetFieldType(Index);
|
|
|
1369 }
|
|
|
1370
|
|
|
1371 private readonly Type _fieldType;
|
|
|
1372
|
|
|
1373 public override Type GetFieldType(int index)
|
|
|
1374 {
|
|
|
1375 return _fieldType;
|
|
|
1376 }
|
|
|
1377
|
|
|
1378 public override object GetValue(object o, int index)
|
|
|
1379 {
|
|
|
1380 #if !MANAGED
|
|
|
1381 if (_fieldType == typeof(OracleXmlType))
|
|
|
1382 {
|
|
|
1383 var xml = _dataReader.GetOracleXmlType(Index);
|
|
|
1384 return MappingSchema.ConvertToXmlDocument(xml);
|
|
|
1385 }
|
|
|
1386 #endif
|
|
|
1387 if (_fieldType == typeof(OracleBlob))
|
|
|
1388 {
|
|
|
1389 var blob = _dataReader.GetOracleBlob(Index);
|
|
|
1390 return MappingSchema.ConvertToStream(blob);
|
|
|
1391 }
|
|
|
1392
|
|
|
1393 return _dataReader.IsDBNull(index)? null:
|
|
|
1394 _dataReader.GetValue(Index);
|
|
|
1395 }
|
|
|
1396
|
|
|
1397 public override Boolean GetBoolean(object o, int index) { return MappingSchema.ConvertToBoolean(GetValue(o, Index)); }
|
|
|
1398 public override Char GetChar (object o, int index) { return MappingSchema.ConvertToChar (GetValue(o, Index)); }
|
|
|
1399 public override Guid GetGuid (object o, int index) { return MappingSchema.ConvertToGuid (GetValue(o, Index)); }
|
|
|
1400
|
|
|
1401 [CLSCompliant(false)]
|
|
|
1402 public override SByte GetSByte (object o, int index) { return (SByte)_dataReader.GetDecimal(Index); }
|
|
|
1403 [CLSCompliant(false)]
|
|
|
1404 public override UInt16 GetUInt16 (object o, int index) { return (UInt16)_dataReader.GetDecimal(Index); }
|
|
|
1405 [CLSCompliant(false)]
|
|
|
1406 public override UInt32 GetUInt32 (object o, int index) { return (UInt32)_dataReader.GetDecimal(Index); }
|
|
|
1407 [CLSCompliant(false)]
|
|
|
1408 public override UInt64 GetUInt64 (object o, int index) { return (UInt64)_dataReader.GetDecimal(Index); }
|
|
|
1409
|
|
|
1410 public override Decimal GetDecimal(object o, int index) { return OracleDecimal.SetPrecision(_dataReader.GetOracleDecimal(Index), 28).Value; }
|
|
|
1411
|
|
|
1412 public override Boolean? GetNullableBoolean(object o, int index) { return MappingSchema.ConvertToNullableBoolean(GetValue(o, Index)); }
|
|
|
1413 public override Char? GetNullableChar (object o, int index) { return MappingSchema.ConvertToNullableChar (GetValue(o, Index)); }
|
|
|
1414 public override Guid? GetNullableGuid (object o, int index) { return MappingSchema.ConvertToNullableGuid (GetValue(o, Index)); }
|
|
|
1415
|
|
|
1416 [CLSCompliant(false)]
|
|
|
1417 public override SByte? GetNullableSByte (object o, int index) { return _dataReader.IsDBNull(index)? null: (SByte?)_dataReader.GetDecimal(Index); }
|
|
|
1418 [CLSCompliant(false)]
|
|
|
1419 public override UInt16? GetNullableUInt16 (object o, int index) { return _dataReader.IsDBNull(index)? null: (UInt16?)_dataReader.GetDecimal(Index); }
|
|
|
1420 [CLSCompliant(false)]
|
|
|
1421 public override UInt32? GetNullableUInt32 (object o, int index) { return _dataReader.IsDBNull(index)? null: (UInt32?)_dataReader.GetDecimal(Index); }
|
|
|
1422 [CLSCompliant(false)]
|
|
|
1423 public override UInt64? GetNullableUInt64 (object o, int index) { return _dataReader.IsDBNull(index)? null: (UInt64?)_dataReader.GetDecimal(Index); }
|
|
|
1424
|
|
|
1425 public override Decimal? GetNullableDecimal(object o, int index) { return _dataReader.IsDBNull(index)? (decimal?)null: OracleDecimal.SetPrecision(_dataReader.GetOracleDecimal(Index), 28).Value; }
|
|
|
1426 }
|
|
|
1427
|
|
|
1428 [Mixin(typeof(IDbDataParameter), "_oracleParameter")]
|
|
|
1429 [Mixin(typeof(IDataParameter), "_oracleParameter")]
|
|
|
1430 [Mixin(typeof(IDisposable), "_oracleParameter")]
|
|
|
1431 [Mixin(typeof(ICloneable), "_oracleParameter")]
|
|
|
1432 [CLSCompliant(false)]
|
|
|
1433 public abstract class OracleParameterWrap
|
|
|
1434 {
|
|
|
1435 protected OracleParameter _oracleParameter;
|
|
|
1436 public OracleParameter OracleParameter
|
|
|
1437 {
|
|
|
1438 get { return _oracleParameter; }
|
|
|
1439 }
|
|
|
1440
|
|
|
1441 public static IDbDataParameter CreateInstance(OracleParameter oraParameter)
|
|
|
1442 {
|
|
|
1443 var wrap = TypeAccessor<OracleParameterWrap>.CreateInstanceEx();
|
|
|
1444
|
|
|
1445 wrap._oracleParameter = oraParameter;
|
|
|
1446
|
|
|
1447 return (IDbDataParameter)wrap;
|
|
|
1448 }
|
|
|
1449
|
|
|
1450 public override string ToString()
|
|
|
1451 {
|
|
|
1452 return _oracleParameter.ToString();
|
|
|
1453 }
|
|
|
1454
|
|
|
1455 ///<summary>
|
|
|
1456 ///Gets or sets the value of the parameter.
|
|
|
1457 ///</summary>
|
|
|
1458 ///<returns>
|
|
|
1459 ///An <see cref="T:System.Object"/> that is the value of the parameter.
|
|
|
1460 ///The default value is null.
|
|
|
1461 ///</returns>
|
|
|
1462 protected object Value
|
|
|
1463 {
|
|
|
1464 #if CONVERTORACLETYPES
|
|
|
1465 [MixinOverride]
|
|
|
1466 get
|
|
|
1467 {
|
|
|
1468 object value = _oracleParameter.Value;
|
|
|
1469 if (value is OracleBinary)
|
|
|
1470 {
|
|
|
1471 OracleBinary oracleValue = (OracleBinary)value;
|
|
|
1472 return oracleValue.IsNull? null: oracleValue.Value;
|
|
|
1473 }
|
|
|
1474 if (value is OracleDate)
|
|
|
1475 {
|
|
|
1476 OracleDate oracleValue = (OracleDate)value;
|
|
|
1477 if (oracleValue.IsNull)
|
|
|
1478 return null;
|
|
|
1479 return oracleValue.Value;
|
|
|
1480 }
|
|
|
1481 if (value is OracleDecimal)
|
|
|
1482 {
|
|
|
1483 OracleDecimal oracleValue = (OracleDecimal)value;
|
|
|
1484 if (oracleValue.IsNull)
|
|
|
1485 return null;
|
|
|
1486 return oracleValue.Value;
|
|
|
1487 }
|
|
|
1488 if (value is OracleIntervalDS)
|
|
|
1489 {
|
|
|
1490 OracleIntervalDS oracleValue = (OracleIntervalDS)value;
|
|
|
1491 if (oracleValue.IsNull)
|
|
|
1492 return null;
|
|
|
1493 return oracleValue.Value;
|
|
|
1494 }
|
|
|
1495 if (value is OracleIntervalYM)
|
|
|
1496 {
|
|
|
1497 OracleIntervalYM oracleValue = (OracleIntervalYM)value;
|
|
|
1498 if (oracleValue.IsNull)
|
|
|
1499 return null;
|
|
|
1500 return oracleValue.Value;
|
|
|
1501 }
|
|
|
1502 if (value is OracleString)
|
|
|
1503 {
|
|
|
1504 OracleString oracleValue = (OracleString)value;
|
|
|
1505 return oracleValue.IsNull? null: oracleValue.Value;
|
|
|
1506 }
|
|
|
1507 if (value is OracleTimeStamp)
|
|
|
1508 {
|
|
|
1509 OracleTimeStamp oracleValue = (OracleTimeStamp)value;
|
|
|
1510 if (oracleValue.IsNull)
|
|
|
1511 return null;
|
|
|
1512 return oracleValue.Value;
|
|
|
1513 }
|
|
|
1514 if (value is OracleTimeStampLTZ)
|
|
|
1515 {
|
|
|
1516 OracleTimeStampLTZ oracleValue = (OracleTimeStampLTZ)value;
|
|
|
1517 if (oracleValue.IsNull)
|
|
|
1518 return null;
|
|
|
1519 return oracleValue.Value;
|
|
|
1520 }
|
|
|
1521 if (value is OracleTimeStampTZ)
|
|
|
1522 {
|
|
|
1523 OracleTimeStampTZ oracleValue = (OracleTimeStampTZ)value;
|
|
|
1524 if (oracleValue.IsNull)
|
|
|
1525 return null;
|
|
|
1526 return oracleValue.Value;
|
|
|
1527 }
|
|
|
1528 if (value is OracleXmlType)
|
|
|
1529 {
|
|
|
1530 OracleXmlType oracleValue = (OracleXmlType)value;
|
|
|
1531 return oracleValue.IsNull? null: oracleValue.Value;
|
|
|
1532 }
|
|
|
1533
|
|
|
1534 return value;
|
|
|
1535 }
|
|
|
1536 #endif
|
|
|
1537 [MixinOverride]
|
|
|
1538 set
|
|
|
1539 {
|
|
|
1540 if (null != value)
|
|
|
1541 {
|
|
|
1542 if (value is Guid)
|
|
|
1543 {
|
|
|
1544 // Fix Oracle.Net bug #6: guid type is not handled
|
|
|
1545 //
|
|
|
1546 value = ((Guid)value).ToByteArray();
|
|
|
1547 }
|
|
|
1548 else if (value is Array && !(value is byte[] || value is char[]))
|
|
|
1549 {
|
|
|
1550 _oracleParameter.CollectionType = OracleCollectionType.PLSQLAssociativeArray;
|
|
|
1551 }
|
|
|
1552 else if (value is IConvertible)
|
|
|
1553 {
|
|
|
1554 var convertible = (IConvertible)value;
|
|
|
1555 var typeCode = convertible.GetTypeCode();
|
|
|
1556
|
|
|
1557 switch (typeCode)
|
|
|
1558 {
|
|
|
1559 case TypeCode.Boolean:
|
|
|
1560 // Fix Oracle.Net bug #7: bool type is handled wrong
|
|
|
1561 //
|
|
|
1562 value = convertible.ToByte(null);
|
|
|
1563 break;
|
|
|
1564
|
|
|
1565 case TypeCode.SByte:
|
|
|
1566 case TypeCode.UInt16:
|
|
|
1567 case TypeCode.UInt32:
|
|
|
1568 case TypeCode.UInt64:
|
|
|
1569 // Fix Oracle.Net bug #8: some integer types are handled wrong
|
|
|
1570 //
|
|
|
1571 value = convertible.ToDecimal(null);
|
|
|
1572 break;
|
|
|
1573
|
|
|
1574 // Fix Oracle.Net bug #10: zero-length string can not be converted to
|
|
|
1575 // ORAXML type, but null value can be.
|
|
|
1576 //
|
|
|
1577 case TypeCode.String:
|
|
|
1578 if (((string)value).Length == 0)
|
|
|
1579 value = null;
|
|
|
1580 break;
|
|
|
1581
|
|
|
1582 default:
|
|
|
1583 // Fix Oracle.Net bug #5: Enum type is not handled
|
|
|
1584 //
|
|
|
1585 if (value is Enum)
|
|
|
1586 {
|
|
|
1587 // Convert a Enum value to it's underlying type.
|
|
|
1588 //
|
|
|
1589 value = System.Convert.ChangeType(value, typeCode);
|
|
|
1590 }
|
|
|
1591 break;
|
|
|
1592 }
|
|
|
1593 }
|
|
|
1594 }
|
|
|
1595
|
|
|
1596 _oracleParameter.Value = value;
|
|
|
1597 }
|
|
|
1598 }
|
|
|
1599 }
|
|
|
1600
|
|
|
1601 #endregion
|
|
|
1602
|
|
|
1603 #region InsertBatch
|
|
|
1604
|
|
|
1605 public override int InsertBatch<T>(
|
|
|
1606 DbManager db,
|
|
|
1607 string insertText,
|
|
|
1608 IEnumerable<T> collection,
|
|
|
1609 MemberMapper[] members,
|
|
|
1610 int maxBatchSize,
|
|
|
1611 DbManager.ParameterProvider<T> getParameters)
|
|
|
1612 {
|
|
|
1613 var sb = new StringBuilder();
|
|
|
1614 var sp = new OracleSqlProvider();
|
|
|
1615 var pn = 0;
|
|
|
1616 var n = 0;
|
|
|
1617 var cnt = 0;
|
|
|
1618 var str = "\t" + insertText
|
|
|
1619 .Substring(0, insertText.IndexOf(") VALUES ("))
|
|
|
1620 .Substring(7)
|
|
|
1621 .Replace("\r", "")
|
|
|
1622 .Replace("\n", "")
|
|
|
1623 .Replace("\t", " ")
|
|
|
1624 .Replace("( ", "(")
|
|
|
1625 //.Replace(" ", " ")
|
|
|
1626 + ") VALUES (";
|
|
|
1627
|
|
|
1628 var parameters = new List<IDbDataParameter>();
|
|
|
1629
|
|
|
1630 foreach (var item in collection)
|
|
|
1631 {
|
|
|
1632 if (sb.Length == 0)
|
|
|
1633 sb.AppendLine("INSERT ALL");
|
|
|
1634
|
|
|
1635 sb.Append(str);
|
|
|
1636
|
|
|
1637 foreach (var member in members)
|
|
|
1638 {
|
|
|
1639 var value = member.GetValue(item);
|
|
|
1640
|
|
|
1641 if (value != null && value.GetType().IsEnum)
|
|
|
1642 value = MappingSchema.MapEnumToValue(value, true);
|
|
|
1643
|
|
|
1644 if (value is Nullable<DateTime>)
|
|
|
1645 value = ((DateTime?)value).Value;
|
|
|
1646
|
|
|
1647 if (value is DateTime)
|
|
|
1648 {
|
|
|
1649 var dt = (DateTime)value;
|
|
|
1650 sb.Append(string.Format("to_timestamp('{0:dd.MM.yyyy HH:mm:ss.ffffff}', 'DD.MM.YYYY HH24:MI:SS.FF6')", dt));
|
|
|
1651 }
|
|
|
1652 else if (value is string && ((string)value).Length >= 2000)
|
|
|
1653 {
|
|
|
1654 var par = db.Parameter("p" + ++pn, value);
|
|
|
1655 parameters.Add(par);
|
|
|
1656 sb.Append(":" + par.ParameterName);
|
|
|
1657 }
|
|
|
1658 else
|
|
|
1659 sp.BuildValue(sb, value);
|
|
|
1660
|
|
|
1661 sb.Append(", ");
|
|
|
1662 }
|
|
|
1663
|
|
|
1664 sb.Length -= 2;
|
|
|
1665 sb.AppendLine(")");
|
|
|
1666
|
|
|
1667 n++;
|
|
|
1668
|
|
|
1669 if (n >= maxBatchSize)
|
|
|
1670 {
|
|
|
1671 sb.AppendLine("SELECT * FROM dual");
|
|
|
1672
|
|
|
1673 var sql = sb.ToString();
|
|
|
1674
|
|
|
1675 if (DbManager.TraceSwitch.TraceInfo)
|
|
|
1676 DbManager.WriteTraceLine("\n" + sql.Replace("\r", ""), DbManager.TraceSwitch.DisplayName);
|
|
|
1677
|
|
|
1678 cnt += db
|
|
|
1679 .SetCommand(sql, parameters.Count > 0 ? parameters.ToArray() : null)
|
|
|
1680 .ExecuteNonQuery();
|
|
|
1681
|
|
|
1682 parameters.Clear();
|
|
|
1683 pn = 0;
|
|
|
1684 n = 0;
|
|
|
1685 sb.Length = 0;
|
|
|
1686 }
|
|
|
1687 }
|
|
|
1688
|
|
|
1689 if (n > 0)
|
|
|
1690 {
|
|
|
1691 sb.AppendLine("SELECT * FROM dual");
|
|
|
1692
|
|
|
1693 var sql = sb.ToString();
|
|
|
1694
|
|
|
1695 if (DbManager.TraceSwitch.TraceInfo)
|
|
|
1696 DbManager.WriteTraceLine("\n" + sql.Replace("\r", ""), DbManager.TraceSwitch.DisplayName);
|
|
|
1697
|
|
|
1698 cnt += db
|
|
|
1699 .SetCommand(sql, parameters.Count > 0 ? parameters.ToArray() : null)
|
|
|
1700 .ExecuteNonQuery();
|
|
|
1701 }
|
|
|
1702
|
|
|
1703 return cnt;
|
|
|
1704 }
|
|
|
1705
|
|
|
1706 #endregion
|
|
|
1707 }
|
|
|
1708 }
|
