?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bump corlib version for MonoIO coop handle changes.
[mono-project.git] / mcs / class / System.Data / System.Data.SqlClient / SqlDataReader.cs
blob9cb4b8a6eeae73078ce759004903398213075241
1 //
2 // System.Data.SqlClient.SqlDataReader.cs
3 //
4 // Author:
5 // Rodrigo Moya (rodrigo@ximian.com)
6 // Daniel Morgan (danmorg@sc.rr.com)
7 // Tim Coleman (tim@timcoleman.com)
8 //
9 // (C) Ximian, Inc 2002
10 // (C) Daniel Morgan 2002
11 // Copyright (C) Tim Coleman, 2002
12 //
13
14 //
15 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
16 //
17 // Permission is hereby granted, free of charge, to any person obtaining
18 // a copy of this software and associated documentation files (the
19 // "Software"), to deal in the Software without restriction, including
20 // without limitation the rights to use, copy, modify, merge, publish,
21 // distribute, sublicense, and/or sell copies of the Software, and to
22 // permit persons to whom the Software is furnished to do so, subject to
23 // the following conditions:
24 //
25 // The above copyright notice and this permission notice shall be
26 // included in all copies or substantial portions of the Software.
27 //
28 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
29 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
30 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
31 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
32 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
33 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
34 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
35 //
36
37 using Mono.Data.Tds.Protocol;
38 using System;
39 using System.IO;
40 using System.Text;
41 using System.Threading;
42 using System.Threading.Tasks;
43 using System.Collections;
44 using System.ComponentModel;
45 using System.Data;
46 using System.Data.Common;
47 using System.Data.SqlTypes;
48 using System.Globalization;
49 using System.Xml;
50
51 namespace System.Data.SqlClient
52 {
53 public class SqlDataReader : DbDataReader, IDataReader, IDisposable, IDataRecord
54 {
55 #region Fields
56
57 SqlCommand command;
58 bool disposed;
59 bool isClosed;
60 bool moreResults;
61 int resultsRead;
62 int rowsRead;
63 DataTable schemaTable;
64 bool haveRead;
65 bool readResult;
66 bool readResultUsed;
67 int visibleFieldCount;
68
69 #endregion // Fields
70
71 const int COLUMN_NAME_IDX = 0;
72 const int COLUMN_ORDINAL_IDX = 1;
73 const int COLUMN_SIZE_IDX = 2;
74 const int NUMERIC_PRECISION_IDX = 3;
75 const int NUMERIC_SCALE_IDX = 4;
76 const int IS_UNIQUE_IDX = 5;
77 const int IS_KEY_IDX = 6;
78 const int BASE_SERVER_NAME_IDX = 7;
79 const int BASE_CATALOG_NAME_IDX = 8;
80 const int BASE_COLUMN_NAME_IDX = 9;
81 const int BASE_SCHEMA_NAME_IDX = 10;
82 const int BASE_TABLE_NAME_IDX = 11;
83 const int DATA_TYPE_IDX = 12;
84 const int ALLOW_DBNULL_IDX = 13;
85 const int PROVIDER_TYPE_IDX = 14;
86 const int IS_ALIASED_IDX = 15;
87 const int IS_EXPRESSION_IDX = 16;
88 const int IS_IDENTITY_IDX = 17;
89 const int IS_AUTO_INCREMENT_IDX = 18;
90 const int IS_ROW_VERSION_IDX = 19;
91 const int IS_HIDDEN_IDX = 20;
92 const int IS_LONG_IDX = 21;
93 const int IS_READ_ONLY_IDX = 22;
94 const int PROVIDER_SPECIFIC_TYPE_IDX = 23;
95 const int DATA_TYPE_NAME_IDX = 24;
96 const int XML_SCHEMA_COLLCTN_DB_IDX = 25;
97 const int XML_SCHEMA_COLLCTN_OWN_SCHEMA_IDX = 26;
98 const int XML_SCHEMA_COLLCTN_NAME_IDX = 27;
99 const int UDT_ASMBLY_QUALIFIED_NAME_IDX = 28;
100 const int NON_VER_PROVIDER_TYPE_IDX = 29;
101 const int IS_COLUMN_SET = 30;
102
103 #region Constructors
104
105 internal SqlDataReader (SqlCommand command)
106 {
107 this.command = command;
108 command.Tds.RecordsAffected = -1;
109 NextResult ();
110 }
111
112 #endregion // Constructors
113
114 #region Properties
115
116 public
117 override
118 int Depth {
119 get { return 0; }
120 }
121
122 public
123 override
124 int FieldCount {
125 get {
126 ValidateState ();
127 return command.Tds.Columns.Count;
128 }
129 }
130
131 public
132 override
133 bool IsClosed {
134 get { return isClosed; }
135 }
136
137 public
138 override
139 object this [int i] {
140 get { return GetValue (i); }
141 }
142
143 public
144 override
145 object this [string name] {
146 get { return GetValue (GetOrdinal (name)); }
147 }
148
149 public
150 override
151 int RecordsAffected {
152 get {
153 return command.Tds.RecordsAffected;
154 }
155 }
156
157 public
158 override
159 bool HasRows {
160 get {
161 ValidateState ();
162
163 if (rowsRead > 0)
164 return true;
165 if (!haveRead)
166 readResult = ReadRecord ();
167 return readResult;
168 }
169 }
170 public override int VisibleFieldCount {
171 get { return visibleFieldCount; }
172 }
173
174 protected SqlConnection Connection {
175 get { return command.Connection; }
176 }
177
178 protected bool IsCommandBehavior (CommandBehavior condition) {
179 return condition == command.CommandBehavior;
180 }
181
182 #endregion // Properties
183
184 #region Methods
185
186 public
187 override
188 void Close ()
189 {
190 if (IsClosed)
191 return;
192 // skip to end & read output parameters.
193 while (NextResult ())
194 ;
195 isClosed = true;
196 command.CloseDataReader ();
197 }
198
199 private static DataTable ConstructSchemaTable ()
200 {
201 Type booleanType = typeof (bool);
202 Type stringType = typeof (string);
203 Type intType = typeof (int);
204 Type typeType = typeof (Type);
205 Type shortType = typeof (short);
206
207 DataTable schemaTable = new DataTable ("SchemaTable");
208 schemaTable.Columns.Add ("ColumnName", stringType);
209 schemaTable.Columns.Add ("ColumnOrdinal", intType);
210 schemaTable.Columns.Add ("ColumnSize", intType);
211 schemaTable.Columns.Add ("NumericPrecision", shortType);
212 schemaTable.Columns.Add ("NumericScale", shortType);
213 schemaTable.Columns.Add ("IsUnique", booleanType);
214 schemaTable.Columns.Add ("IsKey", booleanType);
215 schemaTable.Columns.Add ("BaseServerName", stringType);
216 schemaTable.Columns.Add ("BaseCatalogName", stringType);
217 schemaTable.Columns.Add ("BaseColumnName", stringType);
218 schemaTable.Columns.Add ("BaseSchemaName", stringType);
219 schemaTable.Columns.Add ("BaseTableName", stringType);
220 schemaTable.Columns.Add ("DataType", typeType);
221 schemaTable.Columns.Add ("AllowDBNull", booleanType);
222 schemaTable.Columns.Add ("ProviderType", intType);
223 schemaTable.Columns.Add ("IsAliased", booleanType);
224 schemaTable.Columns.Add ("IsExpression", booleanType);
225 schemaTable.Columns.Add ("IsIdentity", booleanType);
226 schemaTable.Columns.Add ("IsAutoIncrement", booleanType);
227 schemaTable.Columns.Add ("IsRowVersion", booleanType);
228 schemaTable.Columns.Add ("IsHidden", booleanType);
229 schemaTable.Columns.Add ("IsLong", booleanType);
230 schemaTable.Columns.Add ("IsReadOnly", booleanType);
231 schemaTable.Columns.Add ("ProviderSpecificDataType", typeType);
232 schemaTable.Columns.Add ("DataTypeName", stringType);
233 schemaTable.Columns.Add ("XmlSchemaCollectionDatabase", stringType);
234 schemaTable.Columns.Add ("XmlSchemaCollectionOwningSchema", stringType);
235 schemaTable.Columns.Add ("XmlSchemaCollectionName", stringType);
236 schemaTable.Columns.Add ("UdtAssemblyQualifiedName", stringType);
237 schemaTable.Columns.Add ("NonVersionedProviderType", intType);
238 schemaTable.Columns.Add ("IsColumnSet", booleanType);
239
240 return schemaTable;
241 }
242
243 private string GetSchemaRowTypeName (TdsColumnType ctype, int csize, short precision, short scale)
244 {
245 int dbType;
246 bool isLong;
247 Type fieldType;
248
249 string typeName;
250 GetSchemaRowType (ctype, csize, precision, scale,
251 out dbType, out fieldType, out isLong,
252 out typeName);
253 return typeName;
254 }
255
256 private Type GetSchemaRowFieldType (TdsColumnType ctype, int csize, short precision, short scale)
257 {
258 int dbType;
259 bool isLong;
260 Type fieldType;
261 string typeName;
262
263 GetSchemaRowType (ctype, csize, precision, scale,
264 out dbType, out fieldType, out isLong,
265 out typeName);
266 return fieldType;
267 }
268
269 SqlDbType GetSchemaRowDbType (int ordinal)
270 {
271 int csize;
272 short precision, scale;
273 TdsColumnType ctype;
274 TdsDataColumn column;
275
276 if (ordinal < 0 || ordinal >= command.Tds.Columns.Count)
277 throw new IndexOutOfRangeException ();
278
279 column = command.Tds.Columns [ordinal];
280 ctype = (TdsColumnType) column.ColumnType;
281 csize = (int) column.ColumnSize;
282 precision = (short) (column.NumericPrecision ?? 0);
283 scale = (short) (column.NumericScale ?? 0);
284 return GetSchemaRowDbType (ctype, csize, precision, scale);
285 }
286
287 private SqlDbType GetSchemaRowDbType (TdsColumnType ctype, int csize, short precision, short scale)
288 {
289 Type fieldType;
290 bool isLong;
291 string typeName;
292 int dbType;
293
294 GetSchemaRowType (ctype, csize, precision, scale,
295 out dbType, out fieldType, out isLong,
296 out typeName);
297 return (SqlDbType) dbType;
298 }
299
300 private void GetSchemaRowType (TdsColumnType ctype, int csize,
301 short precision, short scale,
302 out int dbType, out Type fieldType,
303 out bool isLong, out string typeName)
304 {
305 dbType = -1;
306 typeName = string.Empty;
307 isLong = false;
308 fieldType = typeof (Type);
309
310 switch (ctype) {
311 case TdsColumnType.Int1:
312 case TdsColumnType.Int2:
313 case TdsColumnType.Int4:
314 case TdsColumnType.IntN:
315 case TdsColumnType.BigInt:
316 switch (csize) {
317 case 1:
318 typeName = "tinyint";
319 dbType = (int) SqlDbType.TinyInt;
320 fieldType = typeof (byte);
321 isLong = false;
322 break;
323 case 2:
324 typeName = "smallint";
325 dbType = (int) SqlDbType.SmallInt;
326 fieldType = typeof (short);
327 isLong = false;
328 break;
329 case 4:
330 typeName = "int";
331 dbType = (int) SqlDbType.Int;
332 fieldType = typeof (int);
333 isLong = false;
334 break;
335 case 8:
336 typeName = "bigint";
337 dbType = (int) SqlDbType.BigInt;
338 fieldType = typeof (long);
339 isLong = false;
340 break;
341 }
342 break;
343 case TdsColumnType.Real:
344 case TdsColumnType.Float8:
345 case TdsColumnType.FloatN:
346 switch (csize) {
347 case 4:
348 typeName = "real";
349 dbType = (int) SqlDbType.Real;
350 fieldType = typeof (float);
351 isLong = false;
352 break;
353 case 8:
354 typeName = "float";
355 dbType = (int) SqlDbType.Float;
356 fieldType = typeof (double);
357 isLong = false;
358 break;
359 }
360 break;
361 case TdsColumnType.Image :
362 typeName = "image";
363 dbType = (int) SqlDbType.Image;
364 fieldType = typeof (byte[]);
365 isLong = true;
366 break;
367 case TdsColumnType.Text :
368 typeName = "text";
369 dbType = (int) SqlDbType.Text;
370 fieldType = typeof (string);
371 isLong = true;
372 break;
373 case TdsColumnType.UniqueIdentifier :
374 typeName = "uniqueidentifier";
375 dbType = (int) SqlDbType.UniqueIdentifier;
376 fieldType = typeof (Guid);
377 isLong = false;
378 break;
379 case TdsColumnType.VarBinary :
380 case TdsColumnType.BigVarBinary :
381 typeName = "varbinary";
382 dbType = (int) SqlDbType.VarBinary;
383 fieldType = typeof (byte[]);
384 isLong = false;
385 break;
386 case TdsColumnType.VarChar :
387 case TdsColumnType.BigVarChar :
388 typeName = "varchar";
389 dbType = (int) SqlDbType.VarChar;
390 fieldType = typeof (string);
391 isLong = false;
392 break;
393 case TdsColumnType.Binary :
394 case TdsColumnType.BigBinary :
395 typeName = "binary";
396 dbType = (int) SqlDbType.Binary;
397 fieldType = typeof (byte[]);
398 isLong = false;
399 break;
400 case TdsColumnType.Char :
401 case TdsColumnType.BigChar :
402 typeName = "char";
403 dbType = (int) SqlDbType.Char;
404 fieldType = typeof (string);
405 isLong = false;
406 break;
407 case TdsColumnType.Bit :
408 case TdsColumnType.BitN :
409 typeName = "bit";
410 dbType = (int) SqlDbType.Bit;
411 fieldType = typeof (bool);
412 isLong = false;
413 break;
414 case TdsColumnType.DateTime4 :
415 case TdsColumnType.DateTime :
416 case TdsColumnType.DateTimeN :
417 switch (csize) {
418 case 4:
419 typeName = "smalldatetime";
420 dbType = (int) SqlDbType.SmallDateTime;
421 fieldType = typeof (DateTime);
422 isLong = false;
423 break;
424 case 8:
425 typeName = "datetime";
426 dbType = (int) SqlDbType.DateTime;
427 fieldType = typeof (DateTime);
428 isLong = false;
429 break;
430 }
431 break;
432 case TdsColumnType.Money :
433 case TdsColumnType.MoneyN :
434 case TdsColumnType.Money4 :
435 switch (csize) {
436 case 4:
437 typeName = "smallmoney";
438 dbType = (int) SqlDbType.SmallMoney;
439 fieldType = typeof (decimal);
440 isLong = false;
441 break;
442 case 8:
443 typeName = "money";
444 dbType = (int) SqlDbType.Money;
445 fieldType = typeof (decimal);
446 isLong = false;
447 break;
448 }
449 break;
450 case TdsColumnType.NText :
451 typeName = "ntext";
452 dbType = (int) SqlDbType.NText;
453 fieldType = typeof (string);
454 isLong = true;
455 break;
456 case TdsColumnType.NVarChar :
457 typeName = "nvarchar";
458 dbType = (int) SqlDbType.NVarChar;
459 fieldType = typeof (string);
460 isLong = false;
461 break;
462 case TdsColumnType.Decimal :
463 case TdsColumnType.Numeric :
464 // TDS 7.0 returns bigint as decimal(19,0)
465 if (precision == 19 && scale == 0) {
466 typeName = "bigint";
467 dbType = (int) SqlDbType.BigInt;
468 fieldType = typeof (long);
469 } else {
470 typeName = "decimal";
471 dbType = (int) SqlDbType.Decimal;
472 fieldType = typeof (decimal);
473 }
474 isLong = false;
475 break;
476 case TdsColumnType.NChar :
477 typeName = "nchar";
478 dbType = (int) SqlDbType.NChar;
479 fieldType = typeof (string);
480 isLong = false;
481 break;
482 case TdsColumnType.SmallMoney :
483 typeName = "smallmoney";
484 dbType = (int) SqlDbType.SmallMoney;
485 fieldType = typeof (decimal);
486 isLong = false;
487 break;
488 default :
489 typeName = "variant";
490 dbType = (int) SqlDbType.Variant;
491 fieldType = typeof (object);
492 isLong = false;
493 break;
494 }
495 }
496
497 new
498 void Dispose (bool disposing)
499 {
500 if (!disposed) {
501 if (disposing) {
502 if (schemaTable != null)
503 schemaTable.Dispose ();
504 Close ();
505 command = null;
506 }
507 disposed = true;
508 }
509 }
510
511 public
512 override
513 bool GetBoolean (int i)
514 {
515 object value = GetValue (i);
516 if (!(value is bool)) {
517 if (value is DBNull) throw new SqlNullValueException ();
518 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
519 }
520 return (bool) value;
521 }
522
523 public
524 override
525 byte GetByte (int i)
526 {
527 object value = GetValue (i);
528 if (!(value is byte)) {
529 if (value is DBNull) throw new SqlNullValueException ();
530 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
531 }
532 return (byte) value;
533 }
534
535 public
536 override
537 long GetBytes (int i, long dataIndex, byte[] buffer, int bufferIndex, int length)
538 {
539 if ((command.CommandBehavior & CommandBehavior.SequentialAccess) != 0) {
540 ValidateState ();
541 EnsureDataAvailable ();
542
543 try {
544 long len = ((Tds)command.Tds).GetSequentialColumnValue (i, dataIndex, buffer, bufferIndex, length);
545 if (len == -1)
546 throw CreateGetBytesOnInvalidColumnTypeException (i);
547 if (len == -2)
548 throw new SqlNullValueException ();
549 return len;
550 } catch (TdsInternalException ex) {
551 command.Connection.Close ();
552 throw SqlException.FromTdsInternalException ((TdsInternalException) ex);
553 }
554 }
555
556 object value = GetValue (i);
557 if (!(value is byte [])) {
558 SqlDbType type = GetSchemaRowDbType (i);
559 switch (type) {
560 case SqlDbType.Image:
561 if (value is DBNull)
562 throw new SqlNullValueException ();
563 break;
564 case SqlDbType.Text:
565 string text = value as string;
566 if (text != null)
567 value = Encoding.Default.GetBytes (text);
568 else
569 value = null;
570 break;
571 case SqlDbType.NText:
572 string ntext = value as string;
573 if (ntext != null)
574 value = Encoding.Unicode.GetBytes (ntext);
575 else
576 value = null;
577 break;
578 default:
579 throw CreateGetBytesOnInvalidColumnTypeException (i);
580 }
581 }
582
583 if (buffer == null)
584 return ((byte []) value).Length; // Return length of data
585
586 // Copy data into buffer
587 int availLen = (int) ( ( (byte []) value).Length - dataIndex);
588 if (availLen < length)
589 length = availLen;
590 if (dataIndex < 0)
591 return 0;
592
593 Array.Copy ((byte []) value, (int) dataIndex, buffer, bufferIndex, length);
594 return length; // return actual read count
595 }
596
597 [EditorBrowsableAttribute (EditorBrowsableState.Never)]
598 public
599 override
600 char GetChar (int i)
601 {
602 throw new NotSupportedException ();
603 }
604
605 public
606 override
607 long GetChars (int i, long dataIndex, char[] buffer, int bufferIndex, int length)
608 {
609 if ((command.CommandBehavior & CommandBehavior.SequentialAccess) != 0) {
610 ValidateState ();
611 EnsureDataAvailable ();
612
613 if (i < 0 || i >= command.Tds.Columns.Count)
614 throw new IndexOutOfRangeException ();
615
616 Encoding encoding = null;
617 byte mul = 1;
618 TdsColumnType colType = (TdsColumnType) command.Tds.Columns[i]["ColumnType"];
619 switch (colType) {
620 case TdsColumnType.Text :
621 case TdsColumnType.VarChar:
622 case TdsColumnType.Char:
623 case TdsColumnType.BigVarChar:
624 encoding = Encoding.ASCII;
625 break;
626 case TdsColumnType.NText :
627 case TdsColumnType.NVarChar:
628 case TdsColumnType.NChar:
629 encoding = Encoding.Unicode;
630 mul = 2;
631 break;
632 default :
633 return -1;
634 }
635
636 long count = 0;
637 if (buffer == null) {
638 count = GetBytes (i,0,(byte[]) null,0,0);
639 return (count/mul);
640 }
641
642 length *= mul;
643 byte[] arr = new byte [length];
644 count = GetBytes (i, dataIndex, arr, 0, length);
645 if (count == -1)
646 throw new InvalidCastException ("Specified cast is not valid");
647
648 Char[] val = encoding.GetChars (arr, 0, (int)count);
649 val.CopyTo (buffer, bufferIndex);
650 return val.Length;
651 }
652
653 char [] valueBuffer;
654 object value = GetValue (i);
655
656 if (value is char[])
657 valueBuffer = (char[])value;
658 else if (value is string)
659 valueBuffer = ((string)value).ToCharArray();
660 else {
661 if (value is DBNull) throw new SqlNullValueException ();
662 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
663 }
664
665 if ( buffer == null ) {
666 // Return length of data
667 return valueBuffer.Length;
668 }
669 else {
670 // Copy data into buffer
671 Array.Copy (valueBuffer, (int) dataIndex, buffer, bufferIndex, length);
672 return valueBuffer.Length - dataIndex;
673 }
674 }
675
676
677 public
678 override
679 string GetDataTypeName (int i)
680 {
681 TdsDataColumn column;
682 TdsColumnType ctype;
683 int csize;
684 short precision;
685 short scale;
686
687 ValidateState ();
688
689 if (i < 0 || i >= command.Tds.Columns.Count)
690 throw new IndexOutOfRangeException ();
691
692 column = command.Tds.Columns [i];
693 ctype = (TdsColumnType) column.ColumnType;
694 csize = (int) column.ColumnSize;
695 precision = (short) (column.NumericPrecision ?? 0);
696 scale = (short) (column.NumericScale ?? 0);
697 return GetSchemaRowTypeName (ctype, csize, precision, scale);
698 }
699
700 public
701 override
702 DateTime GetDateTime (int i)
703 {
704 object value = GetValue (i);
705 if (!(value is DateTime)) {
706 if (value is DBNull) throw new SqlNullValueException ();
707 else throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
708 }
709 return (DateTime) value;
710 }
711
712 [MonoTODO]
713 public virtual DateTimeOffset GetDateTimeOffset (int i)
714 {
715 throw new NotImplementedException ();
716 }
717
718 [MonoTODO]
719 public virtual TimeSpan GetTimeSpan (int i)
720 {
721 throw new NotImplementedException ();
722 }
723
724 [MonoTODO]
725 public virtual SqlChars GetSqlChars (int i)
726 {
727 throw new NotImplementedException ();
728 }
729
730 public
731 override
732 decimal GetDecimal (int i)
733 {
734 object value = GetValue (i);
735 if (!(value is decimal)) {
736 if (value is DBNull) throw new SqlNullValueException ();
737 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
738 }
739 return (decimal) value;
740 }
741
742 public
743 override
744 double GetDouble (int i)
745 {
746 object value = GetValue (i);
747 if (!(value is double)) {
748 if (value is DBNull) throw new SqlNullValueException ();
749 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
750 }
751 return (double) value;
752 }
753
754 public
755 override
756 Type GetFieldType (int i)
757 {
758 TdsDataColumn column;
759 TdsColumnType ctype;
760 int csize;
761 short precision;
762 short scale;
763
764 ValidateState ();
765
766 if (i < 0 || i >= command.Tds.Columns.Count)
767 throw new IndexOutOfRangeException ();
768
769 column = command.Tds.Columns [i];
770 ctype = (TdsColumnType) column.ColumnType;
771 csize = (int) column.ColumnSize;
772 precision = (short) (column.NumericPrecision ?? 0);
773 scale = (short) (column.NumericScale ?? 0);
774 return GetSchemaRowFieldType (ctype, csize, precision,
775 scale);
776 }
777
778 public
779 override
780 float GetFloat (int i)
781 {
782 object value = GetValue (i);
783 if (!(value is float)) {
784 if (value is DBNull) throw new SqlNullValueException ();
785 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
786 }
787 return (float) value;
788 }
789
790 public
791 override
792 Guid GetGuid (int i)
793 {
794 object value = GetValue (i);
795 if (!(value is Guid)) {
796 if (value is DBNull) throw new SqlNullValueException ();
797 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
798 }
799 return (Guid) value;
800 }
801
802 public
803 override
804 short GetInt16 (int i)
805 {
806 object value = GetValue (i);
807 if (!(value is short)) {
808 if (value is DBNull) throw new SqlNullValueException ();
809 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
810 }
811 return (short) value;
812 }
813
814 public
815 override
816 int GetInt32 (int i)
817 {
818 object value = GetValue (i);
819 if (!(value is int)) {
820 if (value is DBNull) throw new SqlNullValueException ();
821 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
822 }
823 return (int) value;
824 }
825
826 public
827 override
828 long GetInt64 (int i)
829 {
830 object value = GetValue (i);
831 if (!(value is long)) {
832 if (value is DBNull) throw new SqlNullValueException ();
833 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
834 }
835 return (long) value;
836 }
837
838 public
839 override
840 string GetName (int i)
841 {
842 ValidateState ();
843
844 if (i < 0 || i >= command.Tds.Columns.Count)
845 throw new IndexOutOfRangeException ();
846 return (string) command.Tds.Columns[i].ColumnName;
847 }
848
849 public
850 override
851 int GetOrdinal (string name)
852 {
853 ValidateState ();
854
855 if (name == null)
856 throw new ArgumentNullException ("fieldName");
857
858 string colName;
859 foreach (TdsDataColumn schema in command.Tds.Columns) {
860 colName = schema.ColumnName;
861 if (colName.Equals (name) || String.Compare (colName, name, true) == 0)
862 return (int) schema.ColumnOrdinal;
863 }
864 throw new IndexOutOfRangeException ();
865 }
866
867 public
868 override
869 DataTable GetSchemaTable ()
870 {
871 ValidateState ();
872
873 if (schemaTable == null)
874 schemaTable = ConstructSchemaTable ();
875
876 if (schemaTable.Rows != null && schemaTable.Rows.Count > 0)
877 return schemaTable;
878
879 if (!moreResults)
880 return null;
881
882 foreach (TdsDataColumn schema in command.Tds.Columns) {
883 DataRow row = schemaTable.NewRow ();
884
885 row [COLUMN_NAME_IDX] = GetSchemaValue (schema.ColumnName);
886 row [COLUMN_ORDINAL_IDX] = GetSchemaValue (schema.ColumnOrdinal);
887 row [IS_UNIQUE_IDX] = GetSchemaValue (schema.IsUnique);
888 row [IS_AUTO_INCREMENT_IDX] = GetSchemaValue (schema.IsAutoIncrement);
889 row [IS_ROW_VERSION_IDX] = GetSchemaValue (schema.IsRowVersion);
890 row [IS_HIDDEN_IDX] = GetSchemaValue (schema.IsHidden);
891 row [IS_IDENTITY_IDX] = GetSchemaValue (schema.IsIdentity);
892 row [NUMERIC_PRECISION_IDX] = GetSchemaValue (schema.NumericPrecision);
893 row [IS_KEY_IDX] = GetSchemaValue (schema.IsKey);
894 row [IS_ALIASED_IDX] = GetSchemaValue (schema.IsAliased);
895 row [IS_EXPRESSION_IDX] = GetSchemaValue (schema.IsExpression);
896 row [IS_READ_ONLY_IDX] = GetSchemaValue (schema.IsReadOnly);
897 row [BASE_SERVER_NAME_IDX] = GetSchemaValue (schema.BaseServerName);
898 row [BASE_CATALOG_NAME_IDX] = GetSchemaValue (schema.BaseCatalogName);
899 row [BASE_COLUMN_NAME_IDX] = GetSchemaValue (schema.BaseColumnName);
900 row [BASE_SCHEMA_NAME_IDX] = GetSchemaValue (schema.BaseSchemaName);
901 row [BASE_TABLE_NAME_IDX] = GetSchemaValue (schema.BaseTableName);
902 row [ALLOW_DBNULL_IDX] = GetSchemaValue (schema.AllowDBNull);
903 row [PROVIDER_SPECIFIC_TYPE_IDX] = DBNull.Value;
904 row [DATA_TYPE_NAME_IDX] = GetSchemaValue (schema.DataTypeName);
905 row [XML_SCHEMA_COLLCTN_DB_IDX] = DBNull.Value;
906 row [XML_SCHEMA_COLLCTN_OWN_SCHEMA_IDX] = DBNull.Value;
907 row [XML_SCHEMA_COLLCTN_NAME_IDX] = DBNull.Value;
908 row [UDT_ASMBLY_QUALIFIED_NAME_IDX] = DBNull.Value;
909 row [NON_VER_PROVIDER_TYPE_IDX] = DBNull.Value;
910 row [IS_COLUMN_SET] = DBNull.Value;
911 // We don't always get the base column name.
912 if (row [BASE_COLUMN_NAME_IDX] == DBNull.Value)
913 row [BASE_COLUMN_NAME_IDX] = row [COLUMN_NAME_IDX];
914
915 TdsColumnType ctype;
916 int csize, dbType;
917 Type fieldType;
918 bool isLong;
919 string typeName;
920 short precision;
921 short scale;
922 ctype = (TdsColumnType) schema.ColumnType;
923 csize = (int) schema.ColumnSize;
924 precision = (short) GetSchemaValue (schema.NumericPrecision);
925 scale = (short) GetSchemaValue (schema.NumericScale);
926
927 GetSchemaRowType (ctype, csize, precision, scale,
928 out dbType, out fieldType, out isLong,
929 out typeName);
930
931 row [COLUMN_SIZE_IDX] = csize;
932 row [NUMERIC_PRECISION_IDX] = precision;
933 row [NUMERIC_SCALE_IDX] = scale;
934 row [PROVIDER_TYPE_IDX] = dbType;
935 row [DATA_TYPE_IDX] = fieldType;
936 row [IS_LONG_IDX] = isLong;
937 if ((bool)row [IS_HIDDEN_IDX] == false)
938 visibleFieldCount += 1;
939
940 schemaTable.Rows.Add (row);
941 }
942 return schemaTable;
943 }
944
945 private static object GetSchemaValue (TdsDataColumn schema, string key)
946 {
947 object val = schema [key];
948 if (val != null)
949 return val;
950 else
951 return DBNull.Value;
952 }
953
954 static object GetSchemaValue (object value)
955 {
956 if (value == null)
957 return DBNull.Value;
958
959 return value;
960 }
961
962 public
963 virtual
964 SqlBinary GetSqlBinary (int i)
965 {
966 object value = GetSqlValue (i);
967 if (!(value is SqlBinary))
968 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
969 return (SqlBinary) value;
970 }
971
972 public
973 virtual
974 SqlBoolean GetSqlBoolean (int i)
975 {
976 object value = GetSqlValue (i);
977 if (!(value is SqlBoolean))
978 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
979 return (SqlBoolean) value;
980 }
981
982 public
983 virtual
984 SqlByte GetSqlByte (int i)
985 {
986 object value = GetSqlValue (i);
987 if (!(value is SqlByte))
988 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
989 return (SqlByte) value;
990 }
991
992 public
993 virtual
994 SqlDateTime GetSqlDateTime (int i)
995 {
996 object value = GetSqlValue (i);
997 if (!(value is SqlDateTime))
998 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
999 return (SqlDateTime) value;
1000 }
1001
1002 public
1003 virtual
1004 SqlDecimal GetSqlDecimal (int i)
1005 {
1006 object value = GetSqlValue (i);
1007 if (!(value is SqlDecimal))
1008 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
1009 return (SqlDecimal) value;
1010 }
1011
1012 public
1013 virtual
1014 SqlDouble GetSqlDouble (int i)
1015 {
1016 object value = GetSqlValue (i);
1017 if (!(value is SqlDouble))
1018 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
1019 return (SqlDouble) value;
1020 }
1021
1022 public
1023 virtual
1024 SqlGuid GetSqlGuid (int i)
1025 {
1026 object value = GetSqlValue (i);
1027 if (!(value is SqlGuid))
1028 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
1029 return (SqlGuid) value;
1030 }
1031
1032 public
1033 virtual
1034 SqlInt16 GetSqlInt16 (int i)
1035 {
1036 object value = GetSqlValue (i);
1037 if (!(value is SqlInt16))
1038 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
1039 return (SqlInt16) value;
1040 }
1041
1042 public
1043 virtual
1044 SqlInt32 GetSqlInt32 (int i)
1045 {
1046 object value = GetSqlValue (i);
1047 if (!(value is SqlInt32))
1048 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
1049 return (SqlInt32) value;
1050 }
1051
1052 public
1053 virtual
1054 SqlInt64 GetSqlInt64 (int i)
1055 {
1056 object value = GetSqlValue (i);
1057 if (!(value is SqlInt64))
1058 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
1059 return (SqlInt64) value;
1060 }
1061
1062 public
1063 virtual
1064 SqlMoney GetSqlMoney (int i)
1065 {
1066 object value = GetSqlValue (i);
1067 if (!(value is SqlMoney))
1068 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
1069 return (SqlMoney) value;
1070 }
1071
1072 public
1073 virtual
1074 SqlSingle GetSqlSingle (int i)
1075 {
1076 object value = GetSqlValue (i);
1077 if (!(value is SqlSingle))
1078 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
1079 return (SqlSingle) value;
1080 }
1081
1082 public
1083 virtual
1084 SqlString GetSqlString (int i)
1085 {
1086 object value = GetSqlValue (i);
1087 if (!(value is SqlString))
1088 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
1089 return (SqlString) value;
1090 }
1091
1092 public virtual SqlXml GetSqlXml (int i)
1093 {
1094 object value = GetSqlValue (i);
1095 if (!(value is SqlXml)) {
1096 if (value is DBNull) {
1097 throw new SqlNullValueException ();
1098 } else if (command.Tds.TdsVersion <= TdsVersion.tds80 && value is SqlString) {
1099 // Workaround for TDS 7/8/8.1 clients
1100 // Xml column types are supported only from Sql Server 2005 / TDS 9, however
1101 // when a TDS 7/8/8.1 client requests for Xml column data, Sql Server 2005 returns
1102 // it as NTEXT
1103 MemoryStream stream = null;
1104 if (!((SqlString) value).IsNull)
1105 stream = new MemoryStream (Encoding.Unicode.GetBytes (value.ToString()));
1106 value = new SqlXml (stream);
1107 } else {
1108 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
1109 }
1110 }
1111 return (SqlXml) value;
1112 }
1113
1114 public
1115 virtual
1116 object GetSqlValue (int i)
1117 {
1118 object value = GetValue (i);
1119 //Console.WriteLine ("Type of value: {0}", value.GetType ());
1120
1121 SqlDbType type = GetSchemaRowDbType (i);
1122 switch (type) {
1123 case SqlDbType.BigInt:
1124 if (value == DBNull.Value)
1125 return SqlInt64.Null;
1126 return (SqlInt64) ((long) value);
1127 case SqlDbType.Binary:
1128 case SqlDbType.Image:
1129 case SqlDbType.VarBinary:
1130 case SqlDbType.Timestamp:
1131 if (value == DBNull.Value)
1132 return SqlBinary.Null;
1133 return (SqlBinary) ((byte[]) value);
1134 case SqlDbType.Bit:
1135 if (value == DBNull.Value)
1136 return SqlBoolean.Null;
1137 return (SqlBoolean) ((bool) value);
1138 case SqlDbType.Char:
1139 case SqlDbType.NChar:
1140 case SqlDbType.NText:
1141 case SqlDbType.NVarChar:
1142 case SqlDbType.Text:
1143 case SqlDbType.VarChar:
1144 if (value == DBNull.Value)
1145 return SqlString.Null;
1146 return (SqlString) ((string) value);
1147 case SqlDbType.DateTime:
1148 case SqlDbType.SmallDateTime:
1149 if (value == DBNull.Value)
1150 return SqlDateTime.Null;
1151 return (SqlDateTime) ((DateTime) value);
1152 case SqlDbType.Decimal:
1153 if (value == DBNull.Value)
1154 return SqlDecimal.Null;
1155 if (value is TdsBigDecimal)
1156 return SqlDecimalExtensions.FromTdsBigDecimal ((TdsBigDecimal) value);
1157 if (value is Int64)
1158 return (SqlDecimal)((long) value);
1159 return (SqlDecimal) ((decimal) value);
1160 case SqlDbType.Float:
1161 if (value == DBNull.Value)
1162 return SqlDouble.Null;
1163 return (SqlDouble) ((double) value);
1164 case SqlDbType.Int:
1165 if (value == DBNull.Value)
1166 return SqlInt32.Null;
1167 return (SqlInt32) ((int) value);
1168 case SqlDbType.Money:
1169 case SqlDbType.SmallMoney:
1170 if (value == DBNull.Value)
1171 return SqlMoney.Null;
1172 return (SqlMoney) ((decimal) value);
1173 case SqlDbType.Real:
1174 if (value == DBNull.Value)
1175 return SqlSingle.Null;
1176 return (SqlSingle) ((float) value);
1177 case SqlDbType.UniqueIdentifier:
1178 if (value == DBNull.Value)
1179 return SqlGuid.Null;
1180 return (SqlGuid) ((Guid) value);
1181 case SqlDbType.SmallInt:
1182 if (value == DBNull.Value)
1183 return SqlInt16.Null;
1184 return (SqlInt16) ((short) value);
1185 case SqlDbType.TinyInt:
1186 if (value == DBNull.Value)
1187 return SqlByte.Null;
1188 return (SqlByte) ((byte) value);
1189 case SqlDbType.Xml:
1190 if (value == DBNull.Value)
1191 return SqlByte.Null;
1192 return (SqlXml) value;
1193 }
1194
1195 throw new InvalidOperationException ("The type of this column is unknown.");
1196 }
1197
1198 public
1199 virtual
1200 int GetSqlValues (object[] values)
1201 {
1202 ValidateState ();
1203 EnsureDataAvailable ();
1204
1205 if (values == null)
1206 throw new ArgumentNullException ("values");
1207
1208 int count = 0;
1209 int columnCount = command.Tds.Columns.Count;
1210 int arrayCount = values.Length;
1211
1212 if (arrayCount > columnCount)
1213 count = columnCount;
1214 else
1215 count = arrayCount;
1216
1217 for (int i = 0; i < count; i += 1)
1218 values [i] = GetSqlValue (i);
1219
1220 return count;
1221 }
1222
1223 public
1224 override
1225 string GetString (int i)
1226 {
1227 object value = GetValue (i);
1228 if (!(value is string)) {
1229 if (value is DBNull) throw new SqlNullValueException ();
1230 throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
1231 }
1232 return (string) value;
1233 }
1234
1235 public
1236 override
1237 object GetValue (int i)
1238 {
1239 ValidateState ();
1240 EnsureDataAvailable ();
1241
1242 if (i < 0 || i >= command.Tds.Columns.Count)
1243 throw new IndexOutOfRangeException ();
1244
1245 try {
1246 if ((command.CommandBehavior & CommandBehavior.SequentialAccess) != 0) {
1247 return ((Tds)command.Tds).GetSequentialColumnValue (i);
1248 }
1249 } catch (TdsInternalException ex) {
1250 command.Connection.Close ();
1251 throw SqlException.FromTdsInternalException ((TdsInternalException) ex);
1252 }
1253
1254 return command.Tds.ColumnValues [i];
1255 }
1256
1257 public
1258 override
1259 int GetValues (object[] values)
1260 {
1261 ValidateState ();
1262 EnsureDataAvailable ();
1263
1264 if (values == null)
1265 throw new ArgumentNullException ("values");
1266
1267 int len = values.Length;
1268 var tds = command.Tds;
1269 int columns = Math.Min (len, tds.Columns.Count);
1270
1271 if ((command.CommandBehavior & CommandBehavior.SequentialAccess) != 0) {
1272 for (int i = 0; i < columns; ++i) {
1273 values [i] = tds.GetSequentialColumnValue (i);
1274 }
1275 } else {
1276 int bigDecimalIndex = tds.ColumnValues.BigDecimalIndex;
1277
1278 // If a four-byte decimal is stored, then we can't convert to
1279 // a native type. Throw an OverflowException.
1280 if (bigDecimalIndex >= 0 && bigDecimalIndex < len)
1281 throw new OverflowException ();
1282 try {
1283 tds.ColumnValues.CopyTo (0, values, 0, columns);
1284 } catch (TdsInternalException ex) {
1285 command.Connection.Close ();
1286 throw SqlException.FromTdsInternalException ((TdsInternalException)ex);
1287 }
1288 }
1289
1290 return columns;
1291 }
1292
1293
1294 public override IEnumerator GetEnumerator ()
1295 {
1296 return new DbEnumerator (this);
1297 }
1298
1299 public
1300 override
1301 bool IsDBNull (int i)
1302 {
1303 return GetValue (i) == DBNull.Value;
1304 }
1305
1306 public
1307 override
1308 bool NextResult ()
1309 {
1310 ValidateState ();
1311
1312 if ((command.CommandBehavior & CommandBehavior.SingleResult) != 0 && resultsRead > 0) {
1313 moreResults = false;
1314 rowsRead = 0;
1315 haveRead = false;
1316 return false;
1317 }
1318
1319 try {
1320 moreResults = command.Tds.NextResult ();
1321 } catch (TdsInternalException ex) {
1322 command.Connection.Close ();
1323 throw SqlException.FromTdsInternalException ((TdsInternalException) ex);
1324 }
1325 if (!moreResults)
1326 command.GetOutputParameters ();
1327 else {
1328 // new schema - don't do anything except reset schemaTable as command.Tds.Columns is already updated
1329 schemaTable = null;
1330 }
1331
1332 rowsRead = 0;
1333 haveRead = false;
1334 resultsRead += 1;
1335 return moreResults;
1336 }
1337
1338 public
1339 override
1340 bool Read ()
1341 {
1342 ValidateState ();
1343
1344 if (!haveRead || readResultUsed)
1345 readResult = ReadRecord ();
1346 readResultUsed = true;
1347 return readResult;
1348 }
1349
1350 internal bool ReadRecord ()
1351 {
1352 readResultUsed = false;
1353
1354 if ((command.CommandBehavior & CommandBehavior.SingleRow) != 0 && haveRead)
1355 return false;
1356 if ((command.CommandBehavior & CommandBehavior.SchemaOnly) != 0)
1357 return false;
1358 if (!moreResults)
1359 return false;
1360
1361 try {
1362 bool result = command.Tds.NextRow ();
1363 if (result)
1364 rowsRead++;
1365 haveRead = true;
1366 return result;
1367 } catch (TdsInternalException ex) {
1368 command.Connection.Close ();
1369 throw SqlException.FromTdsInternalException ((TdsInternalException) ex);
1370 }
1371 }
1372
1373 void ValidateState ()
1374 {
1375 if (IsClosed)
1376 throw new InvalidOperationException ("Invalid attempt to read data when reader is closed");
1377 }
1378
1379 void EnsureDataAvailable ()
1380 {
1381 if (!readResult || !haveRead || !readResultUsed)
1382 throw new InvalidOperationException ("No data available.");
1383 }
1384
1385 InvalidCastException CreateGetBytesOnInvalidColumnTypeException (int ordinal)
1386 {
1387 string message = string.Format (CultureInfo.InvariantCulture,
1388 "Invalid attempt to GetBytes on column '{0}'." +
1389 "The GetBytes function can only be used on " +
1390 "columns of type Text, NText, or Image.",
1391 GetName (ordinal));
1392 return new InvalidCastException (message);
1393 }
1394
1395 public override Type GetProviderSpecificFieldType (int i)
1396 {
1397 return (GetSqlValue (i).GetType());
1398 }
1399
1400 public override object GetProviderSpecificValue (int i)
1401 {
1402 return (GetSqlValue (i));
1403 }
1404
1405 public override int GetProviderSpecificValues (object [] values)
1406 {
1407 return (GetSqlValues (values));
1408 }
1409
1410 public virtual SqlBytes GetSqlBytes (int i)
1411 {
1412 //object value = GetSqlValue (i);
1413 //if (!(value is SqlBinary))
1414 // throw new InvalidCastException ("Type is " + value.GetType ().ToString ());
1415 Byte[] val = (byte[])GetValue(i);
1416 SqlBytes sb = new SqlBytes (val);
1417 return (sb);
1418 }
1419
1420 public override T GetFieldValue<T> (int i)
1421 {
1422 return (T)GetValue(i);
1423 }
1424
1425 [MonoTODO]
1426 public virtual XmlReader GetXmlReader (int i)
1427 {
1428 throw new NotImplementedException ();
1429 }
1430
1431 override public Task<T> GetFieldValueAsync<T> (int i, CancellationToken cancellationToken)
1432 {
1433 return base.GetFieldValueAsync<T> (i, cancellationToken);
1434 }
1435
1436 override public Stream GetStream (int i)
1437 {
1438 return base.GetStream (i);
1439 }
1440 override public TextReader GetTextReader (int i)
1441 {
1442 return base.GetTextReader (i);
1443 }
1444
1445 override public Task<bool> IsDBNullAsync (int i, CancellationToken cancellationToken)
1446 {
1447 return base.IsDBNullAsync (i, cancellationToken);
1448 }
1449
1450 #endregion // Methods
1451 }
1452 }
Mirror of the official Mono project git repository