2 // SqlDataReaderTest.cs - NUnit Test Cases for testing the
5 // Umadevi S (sumadevi@novell.com)
6 // Kornél Pál <http://www.kornelpal.hu/>
7 // Sureshkumar T (tsureshkumar@novell.com)
8 // Senganal T (tsenganal@novell.com)
9 // Veerapuram Varadhan (vvaradhan@novell.com)
11 // Copyright (c) 2004 Novell Inc., and the individuals listed
12 // on the ChangeLog entries.
14 // Permission is hereby granted, free of charge, to any person obtaining
15 // a copy of this software and associated documentation files (the
16 // "Software"), to deal in the Software without restriction, including
17 // without limitation the rights to use, copy, modify, merge, publish,
18 // distribute, sublicense, and/or sell copies of the Software, and to
19 // permit persons to whom the Software is furnished to do so, subject to
20 // the following conditions:
22 // The above copyright notice and this permission notice shall be
23 // included in all copies or substantial portions of the Software.
25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
29 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
30 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
31 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
36 using System.Data.Common;
37 using System.Data.SqlClient;
38 using System.Data.SqlTypes;
39 using System.Globalization;
42 using NUnit.Framework;
44 namespace MonoTests.System.Data.SqlClient
47 [Category ("sqlserver")]
48 public class SqlDataReaderTest
50 static byte [] long_bytes = new byte [] {
51 0x00, 0x66, 0x06, 0x66, 0x97, 0x00, 0x66, 0x06, 0x66,
52 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
53 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
54 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
55 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
56 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
57 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
58 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
59 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
60 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
61 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
62 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
63 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
64 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
65 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
66 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
67 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
68 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
69 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
70 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
71 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
72 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
73 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
74 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
75 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
76 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
77 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
78 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
79 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
80 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
81 0x06, 0x66, 0x06, 0x66, 0x98};
83 SqlConnection conn = null;
84 SqlCommand cmd = null;
85 SqlDataReader reader = null;
86 String query = "Select type_{0},type_{2},convert({1},null) from numeric_family where id=1";
87 DataSet sqlDataset = null;
90 DataTable numericDataTable =null;
91 DataTable stringDataTable =null;
92 DataTable binaryDataTable =null;
93 DataTable datetimeDataTable =null;
95 DataRow numericRow = null;
96 DataRow stringRow = null;
97 DataRow binaryRow = null;
98 DataRow datetimeRow = null;
103 conn = new SqlConnection (ConnectionManager.Singleton.ConnectionString);
104 cmd = conn.CreateCommand ();
106 sqlDataset = (new DataProvider()).GetDataSet ();
108 numericDataTable = sqlDataset.Tables["numeric_family"];
109 stringDataTable = sqlDataset.Tables["string_family"];
110 binaryDataTable = sqlDataset.Tables["binary_family"];
111 datetimeDataTable = sqlDataset.Tables["datetime_family"];
113 numericRow = numericDataTable.Select ("id=1")[0];
114 stringRow = stringDataTable.Select ("id=1")[0];
115 binaryRow = binaryDataTable.Select ("id=1")[0];
116 datetimeRow = datetimeDataTable.Select ("id=1")[0];
124 engine = ConnectionManager.Singleton.Engine;
128 public void TearDown ()
137 public void ReadEmptyNTextFieldTest ()
140 DBHelper.ExecuteNonQuery (conn, "create table #tmp_monotest (name ntext)");
141 DBHelper.ExecuteNonQuery (conn, "insert into #tmp_monotest values ('')");
143 SqlCommand cmd = (SqlCommand) conn.CreateCommand ();
144 cmd.CommandText = "select * from #tmp_monotest";
145 SqlDataReader dr = cmd.ExecuteReader ();
147 Assert.AreEqual("System.String",dr["NAME"].GetType().FullName);
149 Assert.AreEqual (false, dr.Read (), "#2");
151 ConnectionManager.Singleton.CloseConnection ();
156 public void ReadBigIntTest()
158 if (ClientVersion <= 7)
159 Assert.Ignore ("BigInt data type is not supported.");
162 string query = "SELECT CAST(548967465189498 AS bigint) AS Value";
163 SqlCommand cmd = new SqlCommand();
164 cmd.Connection = conn;
165 cmd.CommandText = query;
166 SqlDataReader r = cmd.ExecuteReader();
168 Assert.AreEqual (true, r.Read(), "#1");
169 long id = r.GetInt64(0);
170 Assert.AreEqual(548967465189498, id, "#2");
171 id = r.GetSqlInt64(0).Value;
172 Assert.AreEqual(548967465189498, id, "#3");
175 ConnectionManager.Singleton.CloseConnection ();
179 // This method just helps in Calling common tests among all the Get* Methods
180 // without replicating code
182 void CallGetMethod (string s, int i)
185 case "Boolean" : reader.GetBoolean (i) ; break;
186 case "SqlBoolean": reader.GetSqlBoolean (i); break;
187 case "Int16" : reader.GetInt16 (i); break;
188 case "SqlInt16" : reader.GetSqlInt16 (i); break;
189 case "Int32" : reader.GetInt32 (i);break;
190 case "SqlInt32" : reader.GetSqlInt32(i);break;
191 case "Int64" : reader.GetInt64 (i);break;
192 case "SqlInt64" : reader.GetSqlInt64(i); break;
193 case "Decimal" : reader.GetDecimal(i);break;
194 case "SqlDecimal" : reader.GetSqlDecimal (i);break;
195 case "SqlMoney" : reader.GetSqlMoney (i);break;
196 case "Float" : reader.GetFloat (i);break;
197 case "SqlSingle" : reader.GetSqlSingle(i);break;
198 case "Double" : reader.GetDouble (i);break;
199 case "SqlDouble" : reader.GetSqlDouble(i);break;
200 case "Guid" : reader.GetGuid(i);break;
201 case "SqlGuid" : reader.GetSqlGuid(i);break;
202 case "String" : reader.GetString(i);break;
203 case "SqlString" : reader.GetSqlString(i);break;
204 case "Char" : reader.GetChar(i);break;
205 case "Byte" : reader.GetByte (i);break;
206 case "SqlByte" : reader.GetSqlByte(i); break;
207 case "DateTime" : reader.GetDateTime(i); break;
208 case "SqlDateTime" : reader.GetSqlDateTime(i); break;
209 case "SqlBinary" : reader.GetSqlBinary(i); break;
210 default : Console.WriteLine ("OOOOPSSSSSS {0}",s);break;
214 // This method just helps in Calling common tests among all the Get* Methods
215 // without replicating code
216 void GetMethodTests (string s)
220 CallGetMethod (s, 1);
221 Assert.Fail ("#1[Get"+s+"] InvalidCastException must be thrown");
222 } catch (InvalidCastException e) {
223 Assert.AreEqual (typeof (InvalidCastException), e.GetType (),
224 "#2[Get"+s+"] Incorrect Exception : " + e);
227 // GetSql* Methods do not throw SqlNullValueException
228 // So, Testimg only for Get* Methods
229 if (!s.StartsWith("Sql")) {
231 CallGetMethod (s, 2);
232 Assert.Fail ("#3[Get"+s+"] Exception must be thrown");
233 } catch (SqlNullValueException e) {
234 Assert.AreEqual (typeof (SqlNullValueException), e.GetType (),
235 "#4[Get"+s+"] Incorrect Exception : " + e);
240 CallGetMethod (s, 3);
241 Assert.Fail ("#5[Get"+s+"] IndexOutOfRangeException must be thrown");
242 } catch (IndexOutOfRangeException e) {
243 Assert.AreEqual (typeof (IndexOutOfRangeException), e.GetType (),
244 "#6[Get"+s+"] Incorrect Exception : " + e);
249 public void GetBooleanTest ()
251 cmd.CommandText = string.Format (query, "bit", "bit", "int");
252 reader = cmd.ExecuteReader ();
254 // Test for standard exceptions
255 GetMethodTests("Boolean");
257 // Test if data is returned correctly
258 Assert.AreEqual (numericRow ["type_bit"], reader.GetBoolean (0),
259 "#2 DataValidation Failed");
261 // Test for standard exceptions
262 GetMethodTests("SqlBoolean");
264 // Test if data is returned correctly
265 Assert.AreEqual (numericRow["type_bit"], reader.GetSqlBoolean(0).Value,
266 "#4 DataValidation Failed");
271 public void GetByteTest ()
273 cmd.CommandText = string.Format (query, "tinyint", "tinyint", "int");
274 reader = cmd.ExecuteReader ();
276 // Test for standard exceptions
277 GetMethodTests("Byte");
279 // Test if data is returned correctly
280 Assert.AreEqual (numericRow["type_tinyint"], reader.GetByte(0),
281 "#2 DataValidation Failed");
283 // Test for standard exceptions
284 GetMethodTests("SqlByte");
286 // Test if data is returned correctly
287 Assert.AreEqual (numericRow["type_tinyint"], reader.GetSqlByte(0).Value,
288 "#4 DataValidation Failed");
293 public void GetInt16Test ()
295 cmd.CommandText = string.Format (query, "smallint", "smallint", "int");
296 reader = cmd.ExecuteReader();
298 // Test for standard exceptions
299 GetMethodTests("Int16");
301 // Test if data is returned correctly
302 Assert.AreEqual (numericRow["type_smallint"], reader.GetInt16(0),
303 "#2 DataValidation Failed");
305 // Test for standard exceptions
306 GetMethodTests("SqlInt16");
308 // Test if data is returned correctly
309 Assert.AreEqual (numericRow["type_smallint"], reader.GetSqlInt16(0).Value,
310 "#4 DataValidation Failed");
315 public void GetInt32Test ()
317 if (ClientVersion == 7)
318 cmd.CommandText = string.Format (query, "int", "int", "decimal1");
320 cmd.CommandText = string.Format (query, "int", "int", "bigint");
322 reader = cmd.ExecuteReader ();
324 // Test for standard exceptions
325 GetMethodTests("Int32");
327 // Test if data is returned correctly
328 Assert.AreEqual (numericRow["type_int"], reader.GetInt32(0),
329 "#2 DataValidation Failed");
331 // Test for standard exceptions
332 GetMethodTests("SqlInt32");
334 // Test if data is returned correctly
335 Assert.AreEqual (numericRow["type_int"], reader.GetSqlInt32(0).Value,
336 "#4 DataValidation Failed");
341 public void GetInt64Test ()
343 if (ClientVersion == 7)
344 Assert.Ignore ("BigInt data type is not supported.");
346 cmd.CommandText = string.Format (query, "bigint", "bigint", "int");
347 reader = cmd.ExecuteReader ();
352 // Test for standard exceptions
353 GetMethodTests("Int64");
355 // Test if data is returned correctly
356 value = reader.GetInt64 (0);
357 Assert.AreEqual (numericRow ["type_bigint"], value, "#A");
359 // Test for standard exceptions
360 GetMethodTests("SqlInt64");
362 // Test if data is returned correctly
363 value = reader.GetSqlInt64 (0);
364 Assert.IsNotNull (value, "#B1");
365 Assert.AreEqual (typeof (SqlInt64), value.GetType (), "#B2");
366 SqlInt64 sqlValue = (SqlInt64) value;
367 Assert.IsFalse (sqlValue.IsNull, "#B3");
368 Assert.AreEqual (numericRow ["type_bigint"], sqlValue.Value, "#B4");
370 value = reader.GetValue (0);
371 Assert.IsNotNull (value, "#C1");
372 Assert.AreEqual (typeof (long), value.GetType (), "#C2");
373 Assert.AreEqual (numericRow ["type_bigint"], value, "#C3");
379 public void GetDecimalTest ()
381 cmd.CommandText = string.Format (query, "decimal1", "decimal", "int");
382 reader = cmd.ExecuteReader ();
384 // Test for standard exceptions
385 GetMethodTests("Decimal");
387 // Test if data is returned correctly
388 Assert.AreEqual (numericRow["type_decimal1"], reader.GetDecimal(0),
389 "#2 DataValidation Failed");
391 // Test for standard exceptions
392 GetMethodTests("SqlDecimal");
394 // Test if data is returned correctly
395 Assert.AreEqual (numericRow["type_decimal1"], reader.GetSqlDecimal(0).Value,
396 "#4 DataValidation Failed");
400 //#613087, #620860 Test
402 public void GetDecimalOfInt64Test_Max ()
404 string crTable = "CREATE TABLE #613087 (decimalint64 decimal(20,0))";
405 //string drTable = "drop table #613087";
407 cmd.CommandText = crTable;
408 cmd.CommandType = CommandType.Text;
409 cmd.ExecuteNonQuery ();
411 cmd.CommandText = "INSERT INTO #613087 VALUES (@decimalint64)";
412 SqlParameter param = new SqlParameter ();
413 param.ParameterName = "@decimalint64";
414 param.Value = new SqlDecimal ((long)Int64.MaxValue);
415 cmd.Parameters.Add (param);
416 cmd.ExecuteNonQuery ();
418 cmd.Parameters.Clear ();
419 cmd.CommandText = "Select * from #613087";
420 reader = cmd.ExecuteReader();
422 Assert.AreEqual (param.Value, reader.GetSqlDecimal (0), "SqlDecimalFromInt64_Max Test failed");
425 //#613087, #620860 Test
427 public void GetDecimalOfInt64Test_Min ()
429 string crTable = "CREATE TABLE #613087 (decimalint64 decimal(20,0))";
430 //string drTable = "drop table #613087";
432 cmd.CommandText = crTable;
433 cmd.CommandType = CommandType.Text;
434 cmd.ExecuteNonQuery ();
436 cmd.CommandText = "INSERT INTO #613087 VALUES (@decimalint64)";
437 SqlParameter param = new SqlParameter ();
438 param.ParameterName = "@decimalint64";
439 param.Value = new SqlDecimal ((long)Int64.MinValue);
440 cmd.Parameters.Add (param);
441 cmd.ExecuteNonQuery ();
443 cmd.Parameters.Clear ();
444 cmd.CommandText = "Select * from #613087";
445 reader = cmd.ExecuteReader();
447 Assert.AreEqual (param.Value, reader.GetSqlDecimal (0), "SqlDecimalFromInt64_Min Test failed");
450 //#613087, #620860 Test
452 public void GetDecimalOfInt64Test_Any ()
454 string crTable = "CREATE TABLE #613087 (decimalint64 decimal(20,0))";
455 //string drTable = "drop table #613087";
457 cmd.CommandText = crTable;
458 cmd.CommandType = CommandType.Text;
459 cmd.ExecuteNonQuery ();
461 cmd.CommandText = "INSERT INTO #613087 VALUES (@decimalint64)";
462 SqlParameter param = new SqlParameter ();
463 param.ParameterName = "@decimalint64";
464 param.DbType = DbType.Decimal;
465 param.Value = ulong.MaxValue;
466 cmd.Parameters.Add (param);
467 cmd.ExecuteNonQuery ();
469 cmd.Parameters.Clear ();
470 cmd.CommandText = "Select * from #613087";
471 reader = cmd.ExecuteReader();
473 Assert.AreEqual (param.Value, (ulong)reader.GetSqlDecimal (0).Value, "SqlDecimalFromInt64_Any Test failed");
477 public void GetSqlMoneyTest ()
479 cmd.CommandText = string.Format (query, "money", "money", "int");
480 reader = cmd.ExecuteReader ();
482 // Test for standard exceptions
483 GetMethodTests("SqlMoney");
485 // Test if data is returned correctly
486 Assert.AreEqual (numericRow["type_money"], reader.GetSqlMoney(0).Value,
487 "#2 DataValidation Failed");
492 public void GetFloatTest ()
494 cmd.CommandText = "select type_float,type_double,convert(real,null)";
495 cmd.CommandText += "from numeric_family where id=1";
496 reader = cmd.ExecuteReader ();
498 // Test for standard exceptions
499 GetMethodTests("Float");
501 // Test if data is returned correctly
502 Assert.AreEqual (numericRow["type_float"], reader.GetFloat(0),
503 "#2 DataValidation Failed");
505 // Test for standard exceptions
506 GetMethodTests("SqlSingle");
508 // Test if data is returned correctly
509 Assert.AreEqual (numericRow["type_float"], reader.GetSqlSingle(0).Value,
510 "#2 DataValidation Failed");
515 public void GetDoubleTest ()
517 cmd.CommandText = "select type_double,type_float,convert(float,null)";
518 cmd.CommandText += " from numeric_family where id=1";
519 reader = cmd.ExecuteReader ();
521 // Test for standard exceptions
522 GetMethodTests("Double");
524 // Test if data is returned correctly
525 Assert.AreEqual (numericRow["type_double"], reader.GetDouble(0),
526 "#2 DataValidation Failed");
528 // Test for standard exceptions
529 GetMethodTests("SqlDouble");
531 // Test if data is returned correctly
532 Assert.AreEqual (numericRow["type_double"], reader.GetSqlDouble(0).Value,
533 "#4 DataValidation Failed");
538 public void GetBytesTest ()
540 cmd.CommandText = "Select type_text,type_ntext,convert(text,null) ";
541 cmd.CommandText += "from string_family where id=1";
542 reader = cmd.ExecuteReader ();
545 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
546 Assert.AreEqual (4, totalsize, "#1");
551 byte[] asciiArray = (new ASCIIEncoding ()).GetBytes ("text");
552 byte[] unicodeArray = (new UnicodeEncoding ()).GetBytes ("nt\u092d\u093ext");
553 byte[] buffer = null ;
556 reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess);
558 size = reader.GetBytes (0,0,null,0,0);
559 Assert.AreEqual (asciiArray.Length, size, "#3 Data Incorrect");
561 buffer = new byte[size];
562 size = reader.GetBytes (0,0,buffer,0,(int)size);
563 for (int i=0;i<size; i++)
564 Assert.AreEqual (asciiArray[i], buffer[i], "#4 Data Incorrect");
566 size = reader.GetBytes (1, 0, null, 0, 0);
567 Assert.AreEqual (unicodeArray.Length, size, "#5 Data Incorrect");
568 buffer = new byte[size];
569 size = reader.GetBytes (1,0,buffer,0,(int)size);
570 for (int i=0;i<size; i++)
571 Assert.AreEqual (unicodeArray[i], buffer[i], "#6 Data Incorrect");
573 // Test if msdotnet behavior s followed when null value
574 // is read using GetBytes
576 reader.GetBytes (2, 0, null, 0, 0);
578 } catch (SqlNullValueException) {
582 reader.GetBytes (2, 0, buffer, 0, 10);
584 } catch (SqlNullValueException) {
587 // do i need to test for image/binary values also ???
591 public void GetBytes_BufferIndex_Negative ()
593 IDbConnection conn = ConnectionManager.Singleton.Connection;
597 IDbCommand cmd = conn.CreateCommand ();
598 cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1";
600 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
601 Assert.IsTrue (reader.Read (), "#1");
603 long size = reader.GetBytes (0, 0, null, -1, 0);
604 Assert.AreEqual (5, size);
607 ConnectionManager.Singleton.CloseConnection ();
612 public void GetBytes_DataIndex_Negative ()
614 IDbConnection conn = ConnectionManager.Singleton.Connection;
618 IDbCommand cmd = conn.CreateCommand ();
619 cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1";
621 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
622 Assert.IsTrue (reader.Read ());
624 long totalsize = reader.GetBytes (0, -1L, null, 0, 0);
625 Assert.AreEqual (5, totalsize, "#A");
628 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
629 Assert.IsTrue (reader.Read ());
631 byte [] val = new byte [5];
633 reader.GetBytes (0, -1L, val, 0, 3);
635 } catch (InvalidOperationException ex) {
636 // Invalid GetBytes attempt at dataIndex '-1'
637 // With CommandBehavior.SequentialAccess,
638 // you may only read from dataIndex '0'
640 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
641 Assert.IsNull (ex.InnerException, "#B3");
642 Assert.IsNotNull (ex.Message, "#B4");
643 Assert.IsTrue (ex.Message.IndexOf ("dataIndex") != -1, "#B5:" + ex.Message);
647 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult)) {
648 Assert.IsTrue (reader.Read ());
651 reader.GetBytes (0, -1L, null, 0, 0);
653 } catch (InvalidOperationException ex) {
654 // Invalid value for argument 'dataIndex'.
655 // The value must be greater than or equal to 0
656 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
657 Assert.IsNull (ex.InnerException, "#C3");
658 Assert.IsNotNull (ex.Message, "#C4");
659 Assert.IsTrue (ex.Message.IndexOf ("'dataIndex'") != -1, "#C5:" + ex.Message);
662 byte [] val = new byte [3];
664 reader.GetBytes (0, -1L, val, 0, 3);
666 } catch (InvalidOperationException ex) {
667 // Invalid value for argument 'dataIndex'.
668 // The value must be greater than or equal to 0
669 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
670 Assert.IsNull (ex.InnerException, "#D3");
671 Assert.IsNotNull (ex.Message, "#D4");
672 Assert.IsTrue (ex.Message.IndexOf ("'dataIndex'") != -1, "#D5:" + ex.Message);
676 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult)) {
677 Assert.IsTrue (reader.Read ());
679 byte [] val = new byte [5];
681 reader.GetBytes (0, -1L, val, 0, 3);
683 } catch (InvalidOperationException ex) {
684 // Invalid value for argument 'dataIndex'.
685 // The value must be greater than or equal to 0
686 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
687 Assert.IsNull (ex.InnerException, "#E3");
688 Assert.IsNotNull (ex.Message, "#E4");
689 Assert.IsTrue (ex.Message.IndexOf ("'dataIndex'") != -1, "#E5:" + ex.Message);
693 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
694 Assert.IsTrue (reader.Read ());
696 long totalsize = reader.GetBytes (0, -1L, null, 5, 8);
697 Assert.AreEqual (5, totalsize, "#F");
700 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult)) {
701 Assert.IsTrue (reader.Read ());
704 reader.GetBytes (0, -1L, null, 4, 8);
706 } catch (InvalidOperationException ex) {
707 // Invalid value for argument 'dataIndex'.
708 // The value must be greater than or equal to 0
709 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#G2");
710 Assert.IsNull (ex.InnerException, "#G3");
711 Assert.IsNotNull (ex.Message, "#G4");
712 Assert.IsTrue (ex.Message.IndexOf ("'dataIndex'") != -1, "#G5:" + ex.Message);
716 ConnectionManager.Singleton.CloseConnection ();
721 public void GetBytes_Length_Negative ()
723 IDbConnection conn = ConnectionManager.Singleton.Connection;
727 IDbCommand cmd = conn.CreateCommand ();
728 cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1";
730 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
731 Assert.IsTrue (reader.Read (), "#A1");
733 long size = reader.GetBytes (0, 0, null, 0, -1);
734 Assert.AreEqual (5, size, "#A2");
737 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult)) {
738 Assert.IsTrue (reader.Read (), "#B1");
740 long size = reader.GetBytes (0, 0, null, 0, -1);
741 Assert.AreEqual (5, size, "#B2");
744 ConnectionManager.Singleton.CloseConnection ();
749 public void GetBytes_Buffer_TooSmall ()
751 cmd = conn.CreateCommand ();
752 cmd.CommandText = "SELECT type_blob FROM binary_family where id = 2";
754 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult | CommandBehavior.SequentialAccess)) {
755 Assert.IsTrue (reader.Read ());
757 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
758 byte [] val = new byte [totalsize -1];
761 reader.GetBytes (0, 0, val, 0, (int) totalsize);
763 } catch (IndexOutOfRangeException ex) {
764 // Buffer offset '0' plus the bytes available
765 // '275' is greater than the length of the
767 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
768 Assert.IsNull (ex.InnerException, "#A3");
769 Assert.IsNotNull (ex.Message, "#A4");
770 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#A5:" + ex.Message);
771 Assert.IsTrue (ex.Message.IndexOf ("'" + totalsize + "'") != -1, "#A6:" + ex.Message);
775 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult | CommandBehavior.SequentialAccess)) {
776 Assert.IsTrue (reader.Read ());
778 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
779 byte [] val = new byte [totalsize];
782 reader.GetBytes (0, 0, val, 1, (int) totalsize);
784 } catch (IndexOutOfRangeException ex) {
785 // Buffer offset '1' plus the bytes available
786 // '275' is greater than the length of the
788 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
789 Assert.IsNull (ex.InnerException, "#B3");
790 Assert.IsNotNull (ex.Message, "#B4");
791 Assert.IsTrue (ex.Message.IndexOf ("'1'") != -1, "#B5:" + ex.Message);
792 Assert.IsTrue (ex.Message.IndexOf ("'" + totalsize + "'") != -1, "#B6:" + ex.Message);
796 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult | CommandBehavior.SequentialAccess)) {
797 Assert.IsTrue (reader.Read ());
799 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
800 byte [] val = new byte [totalsize];
803 reader.GetBytes (0, 0, val, 0, (int) (totalsize + 1));
805 } catch (IndexOutOfRangeException ex) {
806 // Buffer offset '0' plus the bytes available
807 // '277' is greater than the length of the
809 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#C2");
810 Assert.IsNull (ex.InnerException, "#C3");
811 Assert.IsNotNull (ex.Message, "#C4");
812 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#C5:" + ex.Message);
813 Assert.IsTrue (ex.Message.IndexOf ("'" + (totalsize + 1) + "'") != -1, "#C6:" + ex.Message);
819 public void GetBytes ()
821 cmd = conn.CreateCommand ();
822 cmd.CommandText = "SELECT type_blob FROM binary_family where id = 2";
824 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult)) {
825 Assert.IsTrue (reader.Read (), "#H1");
827 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
829 byte [] val = new byte [totalsize];
835 ret = reader.GetBytes (0, offset, val, offset, 50);
838 } while (count < totalsize);
840 Assert.AreEqual (long_bytes.Length, count, "#H2");
841 Assert.AreEqual (long_bytes, val, "#H3");
846 public void GetBytes_Type_Binary ()
848 cmd.CommandText = "Select type_binary, type_varbinary, " +
849 "type_blob from binary_family where id = 1";
850 reader = cmd.ExecuteReader ();
852 byte[] binary = (byte[])reader.GetValue (0);
853 byte[] varbinary = (byte[])reader.GetValue (1);
854 byte[] image = (byte[])reader.GetValue (2);
857 reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess);
861 len = (int)reader.GetBytes (0,0,null,0,0);
862 Assert.AreEqual (binary.Length, len, "#1");
863 arr = new byte [len];
864 reader.GetBytes (0,0,arr,0,len);
865 for (int i=0; i<len; ++i)
866 Assert.AreEqual (binary[i], arr[i], "#2");
869 len = (int)reader.GetBytes (1,0,null,0,0);
870 Assert.AreEqual (varbinary.Length, len, "#1");
871 arr = new byte [len];
872 reader.GetBytes (1,0,arr,0,len);
873 for (int i=0; i<len; ++i)
874 Assert.AreEqual (varbinary[i], arr[i], "#2");
876 len = (int)reader.GetBytes (2,0,null,0,0);
877 Assert.AreEqual (image.Length, len, "#1");
878 arr = new byte [len];
879 reader.GetBytes (2,0,arr,0,len);
880 for (int i=0; i<len; ++i)
881 Assert.AreEqual (image[i], arr[i], "#2");
885 cmd.CommandText = "Select type_binary,type_varbinary,type_blob ";
886 cmd.CommandText += "from binary_family where id=1";
888 reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess);
891 len = (int)reader.GetBytes (0,0,null,0,0);
892 arr = new byte [100];
893 for (int i=0; i<len; ++i) {
894 Assert.AreEqual (len-i, reader.GetBytes (0, i, null, 0, 0), "#1_"+i);
895 Assert.AreEqual (1, reader.GetBytes (0, i, arr, 0, 1), "#2_"+i);
896 Assert.AreEqual (binary [i], arr [0], "#3_"+i);
898 Assert.AreEqual (0, reader.GetBytes (0, len+10, null, 0, 0));
903 public void GetBytes_Type_DateTime ()
905 cmd.CommandText = "SELECT type_datetime FROM datetime_family where id = 1";
907 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
908 Assert.IsTrue (reader.Read ());
911 reader.GetBytes (0, 0, null, 0, 0);
913 } catch (InvalidCastException ex) {
914 // Invalid attempt to GetBytes on column
916 // The GetBytes function can only be used
917 // on columns of type Text, NText, or Image
918 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#A2");
919 Assert.IsNull (ex.InnerException, "#A3");
920 Assert.IsNotNull (ex.Message, "#A4");
921 Assert.IsTrue (ex.Message.IndexOf ("'type_datetime'") != -1, "#A5:" + ex.Message);
922 Assert.IsTrue (ex.Message.IndexOf ("GetBytes") != -1, "#A6:" + ex.Message);
923 Assert.IsTrue (ex.Message.IndexOf ("Text") != -1, "#A7:" + ex.Message);
924 Assert.IsTrue (ex.Message.IndexOf ("NText") != -1, "#A8:" + ex.Message);
925 Assert.IsTrue (ex.Message.IndexOf ("Image") != -1, "#A9:" + ex.Message);
929 using (IDataReader reader = cmd.ExecuteReader ()) {
930 Assert.IsTrue (reader.Read ());
933 reader.GetBytes (0, 0, null, 0, 0);
935 } catch (InvalidCastException ex) {
936 // Invalid attempt to GetBytes on column
938 // The GetBytes function can only be used
939 // on columns of type Text, NText, or Image
940 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#B2");
941 Assert.IsNull (ex.InnerException, "#B3");
942 Assert.IsNotNull (ex.Message, "#B4");
943 Assert.IsTrue (ex.Message.IndexOf ("'type_datetime'") != -1, "#B5:" + ex.Message);
944 Assert.IsTrue (ex.Message.IndexOf ("GetBytes") != -1, "#B6:" + ex.Message);
945 Assert.IsTrue (ex.Message.IndexOf ("Text") != -1, "#B7:" + ex.Message);
946 Assert.IsTrue (ex.Message.IndexOf ("NText") != -1, "#B8:" + ex.Message);
947 Assert.IsTrue (ex.Message.IndexOf ("Image") != -1, "#B9:" + ex.Message);
951 cmd.CommandText = "SELECT type_datetime FROM datetime_family where id = 4";
953 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
954 Assert.IsTrue (reader.Read ());
957 reader.GetBytes (0, 0, null, 0, 0);
959 } catch (InvalidCastException ex) {
960 // Invalid attempt to GetBytes on column
962 // The GetBytes function can only be used
963 // on columns of type Text, NText, or Image
964 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#C2");
965 Assert.IsNull (ex.InnerException, "#C3");
966 Assert.IsNotNull (ex.Message, "#C4");
967 Assert.IsTrue (ex.Message.IndexOf ("'type_datetime'") != -1, "#C5:" + ex.Message);
968 Assert.IsTrue (ex.Message.IndexOf ("GetBytes") != -1, "#C6:" + ex.Message);
969 Assert.IsTrue (ex.Message.IndexOf ("Text") != -1, "#C7:" + ex.Message);
970 Assert.IsTrue (ex.Message.IndexOf ("NText") != -1, "#C8:" + ex.Message);
971 Assert.IsTrue (ex.Message.IndexOf ("Image") != -1, "#C9:" + ex.Message);
975 using (IDataReader reader = cmd.ExecuteReader ()) {
976 Assert.IsTrue (reader.Read ());
979 reader.GetBytes (0, 0, null, 0, 0);
981 } catch (InvalidCastException ex) {
982 // Invalid attempt to GetBytes on column
984 // The GetBytes function can only be used
985 // on columns of type Text, NText, or Image
986 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#D2");
987 Assert.IsNull (ex.InnerException, "#D3");
988 Assert.IsNotNull (ex.Message, "#D4");
989 Assert.IsTrue (ex.Message.IndexOf ("'type_datetime'") != -1, "#D5:" + ex.Message);
990 Assert.IsTrue (ex.Message.IndexOf ("GetBytes") != -1, "#D6:" + ex.Message);
991 Assert.IsTrue (ex.Message.IndexOf ("Text") != -1, "#D7:" + ex.Message);
992 Assert.IsTrue (ex.Message.IndexOf ("NText") != -1, "#D8:" + ex.Message);
993 Assert.IsTrue (ex.Message.IndexOf ("Image") != -1, "#D9:" + ex.Message);
999 public void GetBytes_Type_Text ()
1005 cmd.CommandText = "SELECT type_text FROM string_family order by id asc";
1007 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
1008 expected = new byte [] { 0x74, 0x65, 0x78,
1011 Assert.IsTrue (reader.Read (), "#A1");
1012 len = reader.GetBytes (0, 0, null, 0, 0);
1013 Assert.AreEqual (4, len, "#A2");
1014 buffer = new byte [len];
1015 len = reader.GetBytes (0, 0, buffer, 0, (int) len);
1016 Assert.AreEqual (4, len, "#A3");
1017 Assert.AreEqual (expected, buffer, "#A4");
1019 expected = new byte [] { 0x00, 0x00, 0x6f, 0x6e,
1022 Assert.IsTrue (reader.Read (), "#B1");
1023 len = reader.GetBytes (0, 0, null, 0, 0);
1024 Assert.AreEqual (270, len, "#B2");
1025 buffer = new byte [6];
1026 len = reader.GetBytes (0, 1, buffer, 2, 3);
1027 Assert.AreEqual (3, len, "#B3");
1028 Assert.AreEqual (expected, buffer, "#B4");
1030 expected = new byte [0];
1032 Assert.IsTrue (reader.Read (), "#C1");
1033 len = reader.GetBytes (0, 0, null, 0, 0);
1034 Assert.AreEqual (0, len, "#C2");
1035 buffer = new byte [len];
1036 len = reader.GetBytes (0, 0, buffer, 0, 0);
1037 Assert.AreEqual (0, len, "#C3");
1038 Assert.AreEqual (expected, buffer, "#C4");
1040 Assert.IsTrue (reader.Read (), "#D1");
1042 reader.GetBytes (0, 0, null, 0, 0);
1043 Assert.Fail ("#D2");
1044 } catch (SqlNullValueException) {
1048 using (IDataReader reader = cmd.ExecuteReader ()) {
1049 expected = new byte [] { 0x74, 0x65, 0x78,
1052 Assert.IsTrue (reader.Read (), "#E1");
1053 len = reader.GetBytes (0, 0, null, 0, 0);
1054 Assert.AreEqual (4, len, "#E2");
1055 buffer = new byte [len];
1056 len = reader.GetBytes (0, 0, buffer, 0, (int) len);
1057 Assert.AreEqual (4, len, "#E3");
1058 Assert.AreEqual (expected, buffer, "#E4");
1060 expected = new byte [] { 0x00, 0x00, 0x6f, 0x6e,
1063 Assert.IsTrue (reader.Read (), "#F1");
1064 len = reader.GetBytes (0, 0, null, 0, 0);
1065 Assert.AreEqual (270, len, "#F2");
1066 buffer = new byte [6];
1067 len = reader.GetBytes (0, 1, buffer, 2, 3);
1068 Assert.AreEqual (3, len, "#F3");
1069 Assert.AreEqual (expected, buffer, "#F4");
1071 expected = new byte [0];
1073 Assert.IsTrue (reader.Read (), "#G1");
1074 len = reader.GetBytes (0, 0, null, 0, 0);
1075 Assert.AreEqual (0, len, "#G2");
1076 buffer = new byte [len];
1077 len = reader.GetBytes (0, 0, buffer, 0, 0);
1078 Assert.AreEqual (0, len, "#G3");
1079 Assert.AreEqual (expected, buffer, "#G4");
1081 Assert.IsTrue (reader.Read (), "#H1");
1083 reader.GetBytes (0, 0, new byte [0], 0, 0);
1084 Assert.Fail ("#H2");
1085 } catch (NullReferenceException) {
1088 reader.GetBytes (0, 0, null, 0, 0);
1089 Assert.Fail ("#H3");
1090 } catch (NullReferenceException) {
1096 public void GetChar ()
1098 cmd.CommandText = "SELECT type_char FROM string_family where id = 1";
1100 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
1101 Assert.IsTrue (reader.Read ());
1105 Assert.Fail ("#A1");
1106 } catch (NotSupportedException ex) {
1107 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#A2");
1108 Assert.IsNull (ex.InnerException, "#A3");
1109 Assert.IsNotNull (ex.Message, "#A4");
1110 Assert.AreEqual ((new NotSupportedException ()).Message, ex.Message, "#A5");
1114 using (IDataReader reader = cmd.ExecuteReader ()) {
1115 Assert.IsTrue (reader.Read ());
1119 Assert.Fail ("#B1");
1120 } catch (NotSupportedException ex) {
1121 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#B2");
1122 Assert.IsNull (ex.InnerException, "#B3");
1123 Assert.IsNotNull (ex.Message, "#B4");
1124 Assert.AreEqual ((new NotSupportedException ()).Message, ex.Message, "#B5");
1130 public void GetChars ()
1132 cmd.CommandText = "Select type_char, type_varchar,type_text, type_ntext ";
1133 cmd.CommandText += "from string_family where id=1";
1134 reader = cmd.ExecuteReader ();
1136 string charstring = reader.GetString (0);
1137 //string ncharstring = reader.GetString (1);
1138 string varcharstring = reader.GetString (1);
1139 //string nvarcharstring = reader.GetString (2);
1140 string textstring = reader.GetString (2);
1141 string ntextstring = reader.GetString (3);
1144 reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess);
1149 len = (int) reader.GetChars (0, 0, null, 0, 0);
1150 Assert.AreEqual (charstring.Length, len, "#1");
1151 arr = new char [len];
1152 reader.GetChars (0, 0, arr, 0, len);
1153 Assert.AreEqual (0, charstring.CompareTo (new String (arr)), "#2");
1155 len = (int)reader.GetChars (1,0,null,0,0);
1156 Assert.AreEqual (varcharstring.Length, len, "#3");
1157 arr = new char [len];
1158 reader.GetChars (1, 0,arr,0,len);
1159 Assert.AreEqual (0, varcharstring.CompareTo (new String (arr)), "#4");
1161 len = (int)reader.GetChars (2,0,null,0,0);
1162 Assert.AreEqual (textstring.Length, len, "#5");
1163 arr = new char [len];
1164 reader.GetChars (2,0,arr,0,len);
1165 Assert.AreEqual (0, textstring.CompareTo (new String (arr)), "#6");
1167 len = (int)reader.GetChars (3,0,null,0,0);
1168 Assert.AreEqual (ntextstring.Length, len, "#7");
1169 arr = new char [len];
1170 reader.GetChars (3,0,arr,0,len);
1171 Assert.AreEqual (0, ntextstring.CompareTo (new String (arr)), "#8");
1175 reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess);
1178 len = (int)reader.GetChars (0,0,null,0,0);
1179 arr = new char [10];
1180 for (int i = 0; i < len; ++i) {
1181 Assert.AreEqual (len - i, reader.GetChars (0, i, null, 0, 0), "#9_" + i);
1182 Assert.AreEqual (1, reader.GetChars (0, i, arr, 0, 1), "#10_" + i);
1183 Assert.AreEqual (charstring [i], arr [0], "#11_" + i);
1185 Assert.AreEqual (0, reader.GetChars (0, len + 10, null, 0, 0));
1191 public void GetStringTest ()
1193 cmd.CommandText = "Select type_varchar,10,convert(varchar,null)";
1194 cmd.CommandText += "from string_family where id=1";
1195 reader = cmd.ExecuteReader ();
1197 // Test for standard exceptions
1198 GetMethodTests("String");
1200 // Test if data is returned correctly
1201 Assert.AreEqual (stringRow["type_varchar"], reader.GetString(0),
1202 "#2 DataValidation Failed");
1204 // Test for standard exceptions
1205 GetMethodTests("SqlString");
1207 // Test if data is returned correctly
1208 Assert.AreEqual (stringRow["type_varchar"], reader.GetSqlString(0).Value,
1209 "#4 DataValidation Failed");
1214 public void GetSqlBinaryTest ()
1216 cmd.CommandText = "Select type_binary ,10 ,convert(binary,null)";
1217 cmd.CommandText += "from binary_family where id=1";
1218 reader = cmd.ExecuteReader ();
1220 // Test for standard exceptions
1221 GetMethodTests ("SqlBinary");
1223 // Test if data is returned correctly
1224 Assert.AreEqual (binaryRow["type_binary"], reader.GetSqlBinary(0).Value,
1225 "#2 DataValidation Failed");
1230 public void GetGuidTest ()
1232 cmd.CommandText = "Select type_guid,id,convert(uniqueidentifier,null)";
1233 cmd.CommandText += "from string_family where id=1";
1234 reader = cmd.ExecuteReader ();
1237 // Test for standard exceptions
1238 GetMethodTests("Guid");
1240 // Test if data is returned correctly
1241 Assert.AreEqual (stringRow["type_guid"], reader.GetGuid(0),
1242 "#2 DataValidation Failed");
1244 // Test for standard exceptions
1245 GetMethodTests("SqlGuid");
1247 // Test if data is returned correctly
1248 Assert.AreEqual (stringRow["type_guid"], reader.GetSqlGuid(0).Value,
1249 "#4 DataValidation Failed");
1254 public void GetDateTimeTest ()
1256 cmd.CommandText = "Select type_datetime,10,convert(datetime,null)";
1257 cmd.CommandText += "from datetime_family where id=1";
1258 reader = cmd.ExecuteReader ();
1261 // Test for standard exceptions
1262 GetMethodTests("DateTime");
1264 // Test if data is returned correctly
1265 Assert.AreEqual (datetimeRow["type_datetime"], reader.GetDateTime(0),
1266 "#2 DataValidation Failed");
1268 // Test for standard exceptions
1269 GetMethodTests("SqlDateTime");
1271 // Test if data is returned correctly
1272 Assert.AreEqual (datetimeRow["type_datetime"], reader.GetSqlDateTime(0).Value,
1273 "#2 DataValidation Failed");
1278 [Ignore ("Not Supported by msdotnet")]
1279 public void GetCharTest ()
1281 cmd.CommandText = "Select type_char,type_guid,convert(char,null)";
1282 cmd.CommandText += "from string_family where id=1";
1283 reader = cmd.ExecuteReader ();
1285 // Test for standard exceptions
1286 GetMethodTests ("Char");
1291 public void GetValueTest ()
1293 cmd.CommandText = "Select id, null from numeric_family where id=1";
1294 reader = cmd.ExecuteReader ();
1298 obj = reader.GetValue (0);
1299 Assert.AreEqual ((byte)1, obj, "#1 Shud return the value of id");
1300 obj = reader.GetValue (1);
1301 Assert.AreEqual (DBNull.Value, obj, "#2 shud return DBNull");
1306 public void GetValuesTest ()
1308 cmd.CommandText = "Select 10,20,30 from numeric_family where id=1";
1309 reader = cmd.ExecuteReader ();
1311 object[] arr = null;
1314 arr = new object[1];
1315 count = reader.GetValues (arr);
1316 Assert.AreEqual (10, (int)arr[0], "#1 Only first object shud be copied");
1317 Assert.AreEqual (1, count, "#1 return value shud equal objects copied");
1319 arr = new object[3];
1320 count = reader.GetValues (arr);
1321 Assert.AreEqual (3, count, "#2 return value shud equal objects copied");
1323 arr = new object [5];
1324 count = reader.GetValues (arr);
1325 Assert.AreEqual (3, count, "#3 return value shud equal objects copied");
1326 Assert.IsNull (arr[3], "#4 Only 3 objects shud be copied");
1332 public void GetValues_Values_Null ()
1334 cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1";
1336 using (IDataReader rdr = cmd.ExecuteReader ()) {
1337 Assert.IsTrue (rdr.Read ());
1340 rdr.GetValues ((object []) null);
1342 } catch (ArgumentNullException ex) {
1343 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1344 Assert.IsNull (ex.InnerException, "#3");
1345 Assert.IsNotNull (ex.Message, "#4");
1346 Assert.AreEqual ("values", ex.ParamName, "#5");
1352 public void GetSqlValue ()
1354 cmd.CommandText = "Select id, type_tinyint, null from numeric_family where id=1";
1355 reader = cmd.ExecuteReader ();
1358 Assert.AreEqual ((byte) 255, ((SqlByte) reader.GetSqlValue (1)).Value, "#1");
1359 //Assert.AreEqual (DBNull.Value, reader.GetSqlValue(2), "#2");
1365 public void GetSqlValue_Index_Invalid ()
1367 cmd.CommandText = "Select id, type_tinyint, null from numeric_family where id=1";
1368 reader = cmd.ExecuteReader ();
1372 reader.GetSqlValue (-1);
1373 Assert.Fail ("#A1");
1374 } catch (IndexOutOfRangeException ex) {
1375 // Index was outside the bounds of the array
1376 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
1377 Assert.IsNull (ex.InnerException, "#A3");
1378 Assert.IsNotNull (ex.Message, "#A4");
1382 reader.GetSqlValue (3);
1383 Assert.Fail ("#B1");
1384 } catch (IndexOutOfRangeException ex) {
1385 // Index was outside the bounds of the array
1386 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
1387 Assert.IsNull (ex.InnerException, "#B3");
1388 Assert.IsNotNull (ex.Message, "#B4");
1393 public void GetSqlValue_Reader_Closed ()
1395 SqlCommand cmd = conn.CreateCommand ();
1396 cmd.CommandText = "SELECT * FROM employee";
1397 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1401 rdr.GetSqlValue (-1);
1403 } catch (InvalidOperationException ex) {
1404 // Invalid attempt to call MetaData
1405 // when reader is closed
1406 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1407 Assert.IsNull (ex.InnerException, "#3");
1408 Assert.IsNotNull (ex.Message, "#4");
1414 public void GetSqlValue_Reader_NoData ()
1416 SqlCommand cmd = conn.CreateCommand ();
1417 cmd.CommandText = "SELECT * FROM employee where id = 6666";
1418 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1420 rdr.GetSqlValue (-1);
1421 Assert.Fail ("#A1");
1422 } catch (InvalidOperationException ex) {
1423 // Invalid attempt to read when no data
1425 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
1426 Assert.IsNull (ex.InnerException, "#A3");
1427 Assert.IsNotNull (ex.Message, "#A4");
1430 Assert.IsFalse (rdr.Read (), "#B");
1433 rdr.GetSqlValue (-1);
1434 Assert.Fail ("#C1");
1435 } catch (InvalidOperationException ex) {
1436 // Invalid attempt to read when no data
1438 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
1439 Assert.IsNull (ex.InnerException, "#C3");
1440 Assert.IsNotNull (ex.Message, "#C4");
1446 public void GetSqlValues ()
1448 cmd.CommandText = "Select 10,20,30 from numeric_family where id=1";
1449 reader = cmd.ExecuteReader ();
1451 object[] arr = null;
1454 arr = new object[1];
1455 count = reader.GetSqlValues (arr);
1456 // Something is wrong with types ... gotta figure it out
1457 //Assert.AreEqual (10, arr[0], "#1 Only first object shud be copied");
1458 Assert.AreEqual (1, count, "#1 return value shud equal objects copied");
1460 arr = new object[3];
1461 count = reader.GetSqlValues (arr);
1462 Assert.AreEqual (3, count, "#2 return value shud equal objects copied");
1464 arr = new object[5];
1465 count = reader.GetSqlValues (arr);
1466 Assert.AreEqual (3, count, "#3 return value shud equal objects copied");
1467 Assert.IsNull (arr[3], "#4 Only 3 objects shud be copied");
1473 public void GetSqlValues_Reader_Closed ()
1475 SqlCommand cmd = conn.CreateCommand ();
1476 cmd.CommandText = "SELECT * FROM employee";
1477 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1481 rdr.GetSqlValues (null);
1483 } catch (InvalidOperationException ex) {
1484 // Invalid attempt to call MetaData
1485 // when reader is closed
1486 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1487 Assert.IsNull (ex.InnerException, "#3");
1488 Assert.IsNotNull (ex.Message, "#4");
1494 public void GetSqlValues_Reader_NoData ()
1496 SqlCommand cmd = conn.CreateCommand ();
1497 cmd.CommandText = "SELECT * FROM employee where id = 6666";
1498 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1500 rdr.GetSqlValues (null);
1501 Assert.Fail ("#A1");
1502 } catch (InvalidOperationException ex) {
1503 // Invalid attempt to read when no data
1505 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
1506 Assert.IsNull (ex.InnerException, "#A3");
1507 Assert.IsNotNull (ex.Message, "#A4");
1510 Assert.IsFalse (rdr.Read (), "#B");
1513 rdr.GetSqlValues (null);
1514 Assert.Fail ("#C1");
1515 } catch (InvalidOperationException ex) {
1516 // Invalid attempt to read when no data
1518 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
1519 Assert.IsNull (ex.InnerException, "#C3");
1520 Assert.IsNotNull (ex.Message, "#C4");
1526 public void GetSqlValues_Values_Null ()
1528 SqlCommand cmd = conn.CreateCommand ();
1529 cmd.CommandText = "SELECT * FROM employee";
1530 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1533 rdr.GetSqlValues (null);
1535 } catch (ArgumentNullException ex) {
1536 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1537 Assert.IsNull (ex.InnerException, "#3");
1538 Assert.IsNotNull (ex.Message, "#4");
1539 Assert.AreEqual ("values", ex.ParamName, "#5");
1545 public void HasRows ()
1547 SqlCommand cmd = conn.CreateCommand ();
1548 cmd.CommandText = "SELECT id FROM employee WHERE id in (1, 2) ORDER BY id ASC";
1549 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1550 Assert.IsTrue (rdr.HasRows, "#A1");
1553 Assert.Fail ("#A2");
1554 } catch (InvalidOperationException) {
1556 Assert.IsTrue (rdr.HasRows, "#A3");
1557 Assert.IsTrue (rdr.Read (), "#A4");
1558 Assert.AreEqual (1, rdr.GetValue (0), "#A5");
1559 Assert.IsTrue (rdr.HasRows, "#A6");
1560 Assert.AreEqual (1, rdr.GetValue (0), "#A7");
1561 Assert.IsTrue (rdr.Read (), "#A8");
1562 Assert.AreEqual (2, rdr.GetValue (0), "#A9");
1563 Assert.IsTrue (rdr.HasRows, "#A10");
1564 Assert.IsFalse (rdr.Read (), "#A11");
1565 Assert.IsTrue (rdr.HasRows, "#A12");
1566 Assert.IsFalse (rdr.NextResult (), "#A13");
1567 Assert.IsFalse (rdr.HasRows, "#A14");
1570 cmd.CommandText = "SELECT id FROM employee WHERE id = 666";
1571 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1572 Assert.IsFalse (rdr.HasRows, "#B1");
1573 Assert.IsFalse (rdr.Read (), "#B2");
1576 cmd.CommandText = "SELECT id FROM employee WHERE id = 666; SELECT 3";
1577 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1578 Assert.IsFalse (rdr.HasRows, "#C1");
1579 Assert.IsFalse (rdr.Read (), "#C2");
1580 Assert.IsFalse (rdr.HasRows, "#C3");
1581 Assert.IsTrue (rdr.NextResult (), "#C4");
1582 Assert.IsTrue (rdr.HasRows, "#C5");
1585 Assert.Fail ("#C6");
1586 } catch (InvalidOperationException) {
1588 Assert.IsTrue (rdr.Read (), "#C7");
1589 Assert.AreEqual (3, rdr.GetValue (0), "#C8");
1590 Assert.IsTrue (rdr.HasRows, "#C9");
1591 Assert.AreEqual (3, rdr.GetValue (0), "#C10");
1592 Assert.IsFalse (rdr.Read (), "#C11");
1593 Assert.IsTrue (rdr.HasRows, "#C12");
1596 Assert.Fail ("#C13");
1597 } catch (InvalidOperationException) {
1599 Assert.IsFalse (rdr.NextResult (), "#C14");
1600 Assert.IsFalse (rdr.HasRows, "#C15");
1601 Assert.IsFalse (rdr.Read (), "#C16");
1602 Assert.IsFalse (rdr.HasRows, "#C17");
1605 cmd.CommandText = "SELECT id FROM employee WHERE id = 1; SELECT 3";
1606 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.SingleResult)) {
1607 Assert.IsTrue (rdr.HasRows, "#D1");
1608 Assert.IsTrue (rdr.Read (), "#D2");
1609 Assert.IsTrue (rdr.HasRows, "#D3");
1610 Assert.IsFalse (rdr.NextResult (), "#D4");
1611 Assert.IsFalse (rdr.HasRows, "#D5");
1612 Assert.IsFalse (rdr.Read (), "#D6");
1613 Assert.IsFalse (rdr.HasRows, "#D7");
1616 cmd.CommandText = "SELECT id FROM employee WHERE id = 666; SELECT 3";
1617 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.SingleResult)) {
1618 Assert.IsFalse (rdr.HasRows, "#E1");
1619 Assert.IsFalse (rdr.Read (), "#E2");
1620 Assert.IsFalse (rdr.HasRows, "#E3");
1621 Assert.IsFalse (rdr.NextResult (), "#E4");
1622 Assert.IsFalse (rdr.HasRows, "#E5");
1623 Assert.IsFalse (rdr.Read (), "#E6");
1624 Assert.IsFalse (rdr.HasRows, "#E7");
1627 cmd.CommandText = "SELECT id FROM employee WHERE id = 1; SELECT 3";
1628 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.SchemaOnly)) {
1629 Assert.IsFalse (rdr.HasRows, "#F1");
1632 Assert.Fail ("#F2");
1633 } catch (InvalidOperationException) {
1635 Assert.IsFalse (rdr.Read (), "#F3");
1638 Assert.Fail ("#F4");
1639 } catch (InvalidOperationException) {
1641 Assert.IsFalse (rdr.HasRows, "#F5");
1644 Assert.Fail ("#F6");
1645 } catch (InvalidOperationException) {
1647 Assert.IsTrue (rdr.NextResult (), "#F7");
1650 Assert.Fail ("#F8");
1651 } catch (InvalidOperationException) {
1653 Assert.IsFalse (rdr.HasRows, "#F9");
1654 Assert.IsFalse (rdr.Read (), "#F10");
1655 Assert.IsFalse (rdr.HasRows, "#F11");
1656 Assert.IsFalse (rdr.NextResult (), "#F12");
1657 Assert.IsFalse (rdr.HasRows, "#F13");
1658 Assert.IsFalse (rdr.Read (), "#F14");
1659 Assert.IsFalse (rdr.HasRows, "#F15");
1662 cmd.CommandText = "SELECT id FROM employee WHERE id = 666; SELECT 3";
1663 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.SchemaOnly)) {
1664 Assert.IsFalse (rdr.HasRows, "#G1");
1665 Assert.IsFalse (rdr.Read (), "#G2");
1666 Assert.IsFalse (rdr.HasRows, "#G3");
1667 Assert.IsTrue (rdr.NextResult (), "#G4");
1668 Assert.IsFalse (rdr.HasRows, "#G5");
1669 Assert.IsFalse (rdr.Read (), "#G6");
1670 Assert.IsFalse (rdr.HasRows, "#G7");
1671 Assert.IsFalse (rdr.NextResult (), "#G8");
1672 Assert.IsFalse (rdr.HasRows, "#G9");
1673 Assert.IsFalse (rdr.Read (), "#G10");
1674 Assert.IsFalse (rdr.HasRows, "#G11");
1679 public void HasRows_Reader_Closed ()
1681 SqlCommand cmd = conn.CreateCommand ();
1682 cmd.CommandText = "SELECT id FROM employee WHERE id in (1, 2) ORDER BY id ASC";
1683 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1686 bool hasRows = rdr.HasRows;
1687 Assert.Fail ("#A1:" + hasRows);
1688 } catch (InvalidOperationException ex) {
1689 // Invalid attempt to call MetaData
1690 // when reader is closed
1691 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
1692 Assert.IsNull (ex.InnerException, "#A3");
1693 Assert.IsNotNull (ex.Message, "#A4");
1697 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1698 Assert.IsTrue (rdr.Read (), "#B1");
1701 bool hasRows = rdr.HasRows;
1702 Assert.Fail ("#B2:" + hasRows);
1703 } catch (InvalidOperationException ex) {
1704 // Invalid attempt to call MetaData
1705 // when reader is closed
1706 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B3");
1707 Assert.IsNull (ex.InnerException, "#B4");
1708 Assert.IsNotNull (ex.Message, "#B5");
1714 public void isDBNullTest ()
1716 cmd.CommandText = "select id , null from numeric_family where id=1";
1717 reader = cmd.ExecuteReader ();
1720 Assert.IsFalse (reader.IsDBNull (0), "#1");
1721 Assert.IsTrue (reader.IsDBNull (1) , "#2");
1724 reader.IsDBNull (10);
1725 Assert.Fail ("#1 Invalid Argument");
1726 } catch (IndexOutOfRangeException e) {
1727 Assert.AreEqual (typeof(IndexOutOfRangeException), e.GetType(),
1728 "#1 Incorrect Exception : " + e);
1733 public void ReadTest ()
1735 cmd.CommandText = "select id, type_bit from numeric_family where id=1" ;
1736 reader = cmd.ExecuteReader ();
1737 Assert.IsTrue (reader.Read () , "#1");
1738 Assert.IsFalse (reader.Read (), "#2");
1743 Assert.Fail ("#3 Exception shud be thrown : Reader is closed");
1744 } catch (InvalidOperationException e) {
1745 Assert.AreEqual (typeof(InvalidOperationException), e.GetType (),
1746 "#4 Incorrect Exception : " + e);
1751 public void NextResult ()
1753 cmd.CommandText = "Select id from numeric_family where id=1";
1754 reader = cmd.ExecuteReader ();
1755 Assert.IsFalse (reader.NextResult (), "#1");
1758 cmd.CommandText = "select id from numeric_family where id=1;";
1759 cmd.CommandText += "select type_bit from numeric_family where id=2;";
1760 reader = cmd.ExecuteReader ();
1761 Assert.IsTrue (reader.NextResult (), "#B1");
1762 Assert.IsTrue (reader.Read (), "#B2");
1763 Assert.IsFalse (reader.NextResult (), "#B3");
1765 reader.GetValue (0);
1766 Assert.Fail ("#B3");
1767 } catch (InvalidOperationException) {
1769 Assert.IsFalse (reader.Read (), "#B4");
1771 reader.GetValue (0);
1772 Assert.Fail ("#B5");
1773 } catch (InvalidOperationException) {
1778 public void NextResult_Reader_Close ()
1780 SqlCommand cmd = conn.CreateCommand ();
1781 cmd.CommandText = "SELECT * FROM employee";
1782 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1788 } catch (InvalidOperationException ex) {
1789 // Invalid attempt to NextResult when
1791 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1792 Assert.IsNull (ex.InnerException, "#3");
1793 Assert.IsNotNull (ex.Message, "#4");
1799 public void GetNameTest ()
1801 cmd.CommandText = "Select id,10 as gen,20 from numeric_family where id=1";
1802 reader = cmd.ExecuteReader ();
1804 Assert.AreEqual ("id" , reader.GetName(0) , "#1");
1805 Assert.AreEqual ("gen" , reader.GetName(1) , "#2");
1809 Assert.Fail ("#4 Exception shud be thrown");
1810 } catch (IndexOutOfRangeException e) {
1811 Assert.AreEqual (typeof(IndexOutOfRangeException), e.GetType(),
1812 "#5 Incorrect Exception : " + e);
1817 public void GetOrdinalTest ()
1819 //what is kana-width insensitive ?????
1820 cmd.CommandText = "Select id,10 as gen,20 from numeric_family where id=1";
1821 reader = cmd.ExecuteReader ();
1823 Assert.AreEqual (0, reader.GetOrdinal ("id"), "#1");
1824 Assert.AreEqual (0, reader.GetOrdinal ("ID"), "#2");
1825 Assert.AreEqual (1, reader.GetOrdinal ("gen"), "#3");
1826 // Would expect column1,columnn2 etc for unnamed columns,
1827 // but msdotnet return empty string for unnamed columns
1828 Assert.AreEqual (2, reader.GetOrdinal (""), "#4");
1831 reader.GetOrdinal ("invalidname");
1832 } catch (IndexOutOfRangeException e) {
1833 Assert.AreEqual (typeof (IndexOutOfRangeException),
1834 e.GetType(), "#4 Incorrect Exception : " + e);
1839 public void GetSchemaTable ()
1841 IDbConnection conn = ConnectionManager.Singleton.Connection;
1842 ConnectionManager.Singleton.OpenConnection ();
1844 IDbCommand cmd = null;
1845 IDataReader reader = null;
1850 cmd = conn.CreateCommand ();
1851 cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee";
1852 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo);
1853 schema = reader.GetSchemaTable ();
1856 AssertSchemaTableStructure (schema, "#A:");
1857 Assert.AreEqual (3, schema.Rows.Count, "#A:RowCount");
1858 pkRow = schema.Select ("ColumnName = 'id'") [0];
1859 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#A:ColumnName_IsNull");
1860 Assert.AreEqual ("id", pkRow ["ColumnName"], "#A:ColumnName_Value");
1861 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#A:ColumnOrdinal_IsNull");
1862 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#A:ColumnOrdinal_Value");
1863 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#A:ColumnSize_IsNull");
1864 Assert.AreEqual (4, pkRow ["ColumnSize"], "#A:ColumnSize_Value");
1865 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#A:NumericPrecision_IsNull");
1866 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#A:NumericPrecision_Value");
1867 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#A:NumericScale_IsNull");
1868 Assert.AreEqual (255, pkRow ["NumericScale"], "#A:NumericScale_Value");
1869 Assert.IsFalse (pkRow.IsNull ("DataType"), "#A:DataType_IsNull");
1870 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#A:DataType_Value");
1871 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#A:ProviderType_IsNull");
1872 Assert.AreEqual (8, pkRow ["ProviderType"], "#A:ProviderType_Value");
1873 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#A:IsLong_IsNull");
1874 Assert.AreEqual (false, pkRow ["IsLong"], "#A:IsLong_Value");
1875 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#A:AllowDBNull_IsNull");
1876 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#A:AllowDBNull_Value");
1877 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#A:IsReadOnly_IsNull");
1878 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#A:IsReadOnly_Value");
1879 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#A:IsRowVersion_IsNull");
1880 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#A:IsRowVersion_Value");
1881 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#A:IsUnique_IsNull");
1882 Assert.AreEqual (false, pkRow ["IsUnique"], "#A:IsUnique_Value");
1883 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#A:IsKey_IsNull");
1884 Assert.AreEqual (true, pkRow ["IsKey"], "#A:IsKey_Value");
1885 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#A:IsAutoIncrement_IsNull");
1886 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#A:IsAutoIncrement_Value");
1887 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#A:BaseSchemaName_IsNull");
1888 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#A:BaseSchemaName_Value");
1889 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#A:BaseCatalogName_IsNull");
1890 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#A:BaseCatalogName_Value");
1891 Assert.IsFalse (pkRow.IsNull ("BaseTableName"), "#A:BaseTableName_IsNull");
1892 Assert.AreEqual ("employee", pkRow ["BaseTableName"], "#A:BaseTableName_Value");
1893 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#A:BaseColumnName_IsNull");
1894 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#A:BaseColumnName_Value");
1896 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly);
1897 schema = reader.GetSchemaTable ();
1900 AssertSchemaTableStructure (schema, "#B:");
1901 Assert.AreEqual (3, schema.Rows.Count, "#B:RowCount");
1902 pkRow = schema.Select ("ColumnName = 'id'") [0];
1903 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#B:ColumnName_IsNull");
1904 Assert.AreEqual ("id", pkRow ["ColumnName"], "#B:ColumnName_Value");
1905 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#B:ColumnOrdinal_IsNull");
1906 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#B:ColumnOrdinal_Value");
1907 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#B:ColumnSize_IsNull");
1908 Assert.AreEqual (4, pkRow ["ColumnSize"], "#B:ColumnSize_Value");
1909 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#B:NumericPrecision_IsNull");
1910 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#B:NumericPrecision_Value");
1911 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#B:NumericScale_IsNull");
1912 Assert.AreEqual (255, pkRow ["NumericScale"], "#B:NumericScale_Value");
1913 Assert.IsFalse (pkRow.IsNull ("DataType"), "#B:DataType_IsNull");
1914 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#B:DataType_Value");
1915 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#B:ProviderType_IsNull");
1916 Assert.AreEqual (8, pkRow ["ProviderType"], "#B:ProviderType_Value");
1917 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#B:IsLong_IsNull");
1918 Assert.AreEqual (false, pkRow ["IsLong"], "#B:IsLong_Value");
1919 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#B:AllowDBNull_IsNull");
1920 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#B:AllowDBNull_Value");
1921 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#B:IsReadOnly_IsNull");
1922 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#B:IsReadOnly_Value");
1923 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#B:IsRowVersion_IsNull");
1924 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#B:IsRowVersion_Value");
1925 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#B:IsUnique_IsNull");
1926 Assert.AreEqual (false, pkRow ["IsUnique"], "#B:IsUnique_Value");
1927 Assert.IsTrue (pkRow.IsNull ("IsKey"), "#B:IsKey_IsNull");
1928 Assert.AreEqual (DBNull.Value, pkRow ["IsKey"], "#B:IsKey_Value");
1929 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#B:IsAutoIncrement_IsNull");
1930 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#B:IsAutoIncrement_Value");
1931 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#B:BaseSchemaName_IsNull");
1932 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#B:BaseSchemaName_Value");
1933 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#B:BaseCatalogName_IsNull");
1934 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#B:BaseCatalogName_Value");
1935 Assert.IsTrue (pkRow.IsNull ("BaseTableName"), "#B:BaseTableName_IsNull");
1936 Assert.AreEqual (DBNull.Value, pkRow ["BaseTableName"], "#B:BaseTableName_Value");
1937 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#B:BaseColumnName_IsNull");
1938 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#B:BaseColumnName_Value");
1940 reader = cmd.ExecuteReader (CommandBehavior.KeyInfo);
1941 schema = reader.GetSchemaTable ();
1944 AssertSchemaTableStructure (schema, "#C:");
1945 Assert.AreEqual (3, schema.Rows.Count, "#C:RowCount");
1946 pkRow = schema.Select ("ColumnName = 'id'") [0];
1947 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#C:ColumnName_IsNull");
1948 Assert.AreEqual ("id", pkRow ["ColumnName"], "#C:ColumnName_Value");
1949 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#C:ColumnOrdinal_IsNull");
1950 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#C:ColumnOrdinal_Value");
1951 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#C:ColumnSize_IsNull");
1952 Assert.AreEqual (4, pkRow ["ColumnSize"], "#C:ColumnSize_Value");
1953 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#C:NumericPrecision_IsNull");
1954 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#C:NumericPrecision_Value");
1955 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#C:NumericScale_IsNull");
1956 Assert.AreEqual (255, pkRow ["NumericScale"], "#C:NumericScale_Value");
1957 Assert.IsFalse (pkRow.IsNull ("DataType"), "#C:DataType_IsNull");
1958 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#C:DataType_Value");
1959 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#C:ProviderType_IsNull");
1960 Assert.AreEqual (8, pkRow ["ProviderType"], "#C:ProviderType_Value");
1961 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#C:IsLong_IsNull");
1962 Assert.AreEqual (false, pkRow ["IsLong"], "#C:IsLong_Value");
1963 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#C:AllowDBNull_IsNull");
1964 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#C:AllowDBNull_Value");
1965 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#C:IsReadOnly_IsNull");
1966 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#C:IsReadOnly_Value");
1967 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#C:IsRowVersion_IsNull");
1968 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#C:IsRowVersion_Value");
1969 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#C:IsUnique_IsNull");
1970 Assert.AreEqual (false, pkRow ["IsUnique"], "#C:IsUnique_Value");
1971 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#C:IsKey_IsNull");
1972 Assert.AreEqual (true, pkRow ["IsKey"], "#C:IsKey_Value");
1973 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#C:IsAutoIncrement_IsNull");
1974 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#C:IsAutoIncrement_Value");
1975 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#C:BaseSchemaName_IsNull");
1976 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#C:BaseSchemaName_Value");
1977 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#C:BaseCatalogName_IsNull");
1978 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#C:BaseCatalogName_Value");
1979 Assert.IsFalse (pkRow.IsNull ("BaseTableName"), "#C:BaseTableName_IsNull");
1980 Assert.AreEqual ("employee", pkRow ["BaseTableName"], "#C:BaseTableName_Value");
1981 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#C:BaseColumnName_IsNull");
1982 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#C:BaseColumnName_Value");
1984 reader = cmd.ExecuteReader ();
1985 schema = reader.GetSchemaTable ();
1988 AssertSchemaTableStructure (schema, "#D:");
1989 Assert.AreEqual (3, schema.Rows.Count, "#D:RowCount");
1990 pkRow = schema.Select ("ColumnName = 'id'") [0];
1991 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#D:ColumnName_IsNull");
1992 Assert.AreEqual ("id", pkRow ["ColumnName"], "#D:ColumnName_Value");
1993 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#D:ColumnOrdinal_IsNull");
1994 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#D:ColumnOrdinal_Value");
1995 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#D:ColumnSize_IsNull");
1996 Assert.AreEqual (4, pkRow ["ColumnSize"], "#D:ColumnSize_Value");
1997 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#D:NumericPrecision_IsNull");
1998 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#D:NumericPrecision_Value");
1999 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#D:NumericScale_IsNull");
2000 Assert.AreEqual (255, pkRow ["NumericScale"], "#D:NumericScale_Value");
2001 Assert.IsFalse (pkRow.IsNull ("DataType"), "#D:DataType_IsNull");
2002 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#D:DataType_Value");
2003 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#D:ProviderType_IsNull");
2004 Assert.AreEqual (8, pkRow ["ProviderType"], "#D:ProviderType_Value");
2005 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#D:IsLong_IsNull");
2006 Assert.AreEqual (false, pkRow ["IsLong"], "#D:IsLong_Value");
2007 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#D:AllowDBNull_IsNull");
2008 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#D:AllowDBNull_Value");
2009 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#D:IsReadOnly_IsNull");
2010 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#D:IsReadOnly_Value");
2011 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#D:IsRowVersion_IsNull");
2012 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#D:IsRowVersion_Value");
2013 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#D:IsUnique_IsNull");
2014 Assert.AreEqual (false, pkRow ["IsUnique"], "#D:IsUnique_Value");
2015 Assert.IsTrue (pkRow.IsNull ("IsKey"), "#D:IsKey_IsNull");
2016 Assert.AreEqual (DBNull.Value, pkRow ["IsKey"], "#D:IsKey_Value");
2017 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#D:IsAutoIncrement_IsNull");
2018 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#D:IsAutoIncrement_Value");
2019 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#D:BaseSchemaName_IsNull");
2020 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#D:BaseSchemaName_Value");
2021 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#D:BaseCatalogName_IsNull");
2022 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#D:BaseCatalogName_Value");
2023 Assert.IsTrue (pkRow.IsNull ("BaseTableName"), "#D:BaseTableName_IsNull");
2024 Assert.AreEqual (DBNull.Value, pkRow ["BaseTableName"], "#D:BaseTableName_Value");
2025 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#D:BaseColumnName_IsNull");
2026 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#D:BaseColumnName_Value");
2028 cmd = conn.CreateCommand ();
2029 cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee";
2031 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo);
2032 schema = reader.GetSchemaTable ();
2035 AssertSchemaTableStructure (schema, "#E:");
2036 Assert.AreEqual (3, schema.Rows.Count, "#E:RowCount");
2037 pkRow = schema.Select ("ColumnName = 'id'") [0];
2038 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#E:ColumnName_IsNull");
2039 Assert.AreEqual ("id", pkRow ["ColumnName"], "#E:ColumnName_Value");
2040 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#E:ColumnOrdinal_IsNull");
2041 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#E:ColumnOrdinal_Value");
2042 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#E:ColumnSize_IsNull");
2043 Assert.AreEqual (4, pkRow ["ColumnSize"], "#E:ColumnSize_Value");
2044 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#E:NumericPrecision_IsNull");
2045 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#E:NumericPrecision_Value");
2046 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#E:NumericScale_IsNull");
2047 Assert.AreEqual (255, pkRow ["NumericScale"], "#E:NumericScale_Value");
2048 Assert.IsFalse (pkRow.IsNull ("DataType"), "#E:DataType_IsNull");
2049 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#E:DataType_Value");
2050 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#E:ProviderType_IsNull");
2051 Assert.AreEqual (8, pkRow ["ProviderType"], "#E:ProviderType_Value");
2052 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#E:IsLong_IsNull");
2053 Assert.AreEqual (false, pkRow ["IsLong"], "#E:IsLong_Value");
2054 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#E:AllowDBNull_IsNull");
2055 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#E:AllowDBNull_Value");
2056 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#E:IsReadOnly_IsNull");
2057 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#E:IsReadOnly_Value");
2058 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#E:IsRowVersion_IsNull");
2059 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#E:IsRowVersion_Value");
2060 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#E:IsUnique_IsNull");
2061 Assert.AreEqual (false, pkRow ["IsUnique"], "#E:IsUnique_Value");
2062 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#E:IsKey_IsNull");
2063 Assert.AreEqual (true, pkRow ["IsKey"], "#E:IsKey_Value");
2064 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#E:IsAutoIncrement_IsNull");
2065 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#E:IsAutoIncrement_Value");
2066 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#E:BaseSchemaName_IsNull");
2067 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#E:BaseSchemaName_Value");
2068 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#E:BaseCatalogName_IsNull");
2069 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#E:BaseCatalogName_Value");
2070 Assert.IsFalse (pkRow.IsNull ("BaseTableName"), "#E:BaseTableName_IsNull");
2071 Assert.AreEqual ("employee", pkRow ["BaseTableName"], "#E:BaseTableName_Value");
2072 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#E:BaseColumnName_IsNull");
2073 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#E:BaseColumnName_Value");
2075 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly);
2076 schema = reader.GetSchemaTable ();
2079 AssertSchemaTableStructure (schema, "#F:");
2080 Assert.AreEqual (3, schema.Rows.Count, "#F:RowCount");
2081 pkRow = schema.Select ("ColumnName = 'id'") [0];
2082 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#F:ColumnName_IsNull");
2083 Assert.AreEqual ("id", pkRow ["ColumnName"], "#F:ColumnName_Value");
2084 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#F:ColumnOrdinal_IsNull");
2085 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#F:ColumnOrdinal_Value");
2086 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#F:ColumnSize_IsNull");
2087 Assert.AreEqual (4, pkRow ["ColumnSize"], "#F:ColumnSize_Value");
2088 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#F:NumericPrecision_IsNull");
2089 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#F:NumericPrecision_Value");
2090 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#F:NumericScale_IsNull");
2091 Assert.AreEqual (255, pkRow ["NumericScale"], "#F:NumericScale_Value");
2092 Assert.IsFalse (pkRow.IsNull ("DataType"), "#F:DataType_IsNull");
2093 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#F:DataType_Value");
2094 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#F:ProviderType_IsNull");
2095 Assert.AreEqual (8, pkRow ["ProviderType"], "#F:ProviderType_Value");
2096 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#F:IsLong_IsNull");
2097 Assert.AreEqual (false, pkRow ["IsLong"], "#F:IsLong_Value");
2098 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#F:AllowDBNull_IsNull");
2099 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#F:AllowDBNull_Value");
2100 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#F:IsReadOnly_IsNull");
2101 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#F:IsReadOnly_Value");
2102 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#F:IsRowVersion_IsNull");
2103 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#F:IsRowVersion_Value");
2104 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#F:IsUnique_IsNull");
2105 Assert.AreEqual (false, pkRow ["IsUnique"], "#F:IsUnique_Value");
2106 Assert.IsTrue (pkRow.IsNull ("IsKey"), "#F:IsKey_IsNull");
2107 Assert.AreEqual (DBNull.Value, pkRow ["IsKey"], "#F:IsKey_Value");
2108 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#F:IsAutoIncrement_IsNull");
2109 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#F:IsAutoIncrement_Value");
2110 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#F:BaseSchemaName_IsNull");
2111 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#F:BaseSchemaName_Value");
2112 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#F:BaseCatalogName_IsNull");
2113 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#F:BaseCatalogName_Value");
2114 Assert.IsTrue (pkRow.IsNull ("BaseTableName"), "#F:BaseTableName_IsNull");
2115 Assert.AreEqual (DBNull.Value, pkRow ["BaseTableName"], "#F:BaseTableName_Value");
2116 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#F:BaseColumnName_IsNull");
2117 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#F:BaseColumnName_Value");
2119 reader = cmd.ExecuteReader (CommandBehavior.KeyInfo);
2120 schema = reader.GetSchemaTable ();
2123 AssertSchemaTableStructure (schema, "#G:");
2124 Assert.AreEqual (3, schema.Rows.Count, "#G:RowCount");
2125 pkRow = schema.Select ("ColumnName = 'id'") [0];
2126 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#G:ColumnName_IsNull");
2127 Assert.AreEqual ("id", pkRow ["ColumnName"], "#G:ColumnName_Value");
2128 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#G:ColumnOrdinal_IsNull");
2129 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#G:ColumnOrdinal_Value");
2130 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#G:ColumnSize_IsNull");
2131 Assert.AreEqual (4, pkRow ["ColumnSize"], "#G:ColumnSize_Value");
2132 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#G:NumericPrecision_IsNull");
2133 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#G:NumericPrecision_Value");
2134 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#G:NumericScale_IsNull");
2135 Assert.AreEqual (255, pkRow ["NumericScale"], "#G:NumericScale_Value");
2136 Assert.IsFalse (pkRow.IsNull ("DataType"), "#G:DataType_IsNull");
2137 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#G:DataType_Value");
2138 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#G:ProviderType_IsNull");
2139 Assert.AreEqual (8, pkRow ["ProviderType"], "#G:ProviderType_Value");
2140 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#G:IsLong_IsNull");
2141 Assert.AreEqual (false, pkRow ["IsLong"], "#G:IsLong_Value");
2142 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#G:AllowDBNull_IsNull");
2143 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#G:AllowDBNull_Value");
2144 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#G:IsReadOnly_IsNull");
2145 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#G:IsReadOnly_Value");
2146 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#G:IsRowVersion_IsNull");
2147 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#G:IsRowVersion_Value");
2148 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#G:IsUnique_IsNull");
2149 Assert.AreEqual (false, pkRow ["IsUnique"], "#G:IsUnique_Value");
2150 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#G:IsKey_IsNull");
2151 Assert.AreEqual (true, pkRow ["IsKey"], "#G:IsKey_Value");
2152 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#G:IsAutoIncrement_IsNull");
2153 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#G:IsAutoIncrement_Value");
2154 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#G:BaseSchemaName_IsNull");
2155 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#G:BaseSchemaName_Value");
2156 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#G:BaseCatalogName_IsNull");
2157 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#G:BaseCatalogName_Value");
2158 Assert.IsFalse (pkRow.IsNull ("BaseTableName"), "#G:BaseTableName_IsNull");
2159 Assert.AreEqual ("employee", pkRow ["BaseTableName"], "#G:BaseTableName_Value");
2160 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#G:BaseColumnName_IsNull");
2161 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#G:BaseColumnName_Value");
2163 reader = cmd.ExecuteReader ();
2164 schema = reader.GetSchemaTable ();
2167 AssertSchemaTableStructure (schema, "#H:");
2168 Assert.AreEqual (3, schema.Rows.Count, "#H:RowCount");
2169 pkRow = schema.Select ("ColumnName = 'id'") [0];
2170 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#H:ColumnName_IsNull");
2171 Assert.AreEqual ("id", pkRow ["ColumnName"], "#H:ColumnName_Value");
2172 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#H:ColumnOrdinal_IsNull");
2173 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#H:ColumnOrdinal_Value");
2174 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#H:ColumnSize_IsNull");
2175 Assert.AreEqual (4, pkRow ["ColumnSize"], "#H:ColumnSize_Value");
2176 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#H:NumericPrecision_IsNull");
2177 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#H:NumericPrecision_Value");
2178 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#H:NumericScale_IsNull");
2179 Assert.AreEqual (255, pkRow ["NumericScale"], "#H:NumericScale_Value");
2180 Assert.IsFalse (pkRow.IsNull ("DataType"), "#H:DataType_IsNull");
2181 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#H:DataType_Value");
2182 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#H:ProviderType_IsNull");
2183 Assert.AreEqual (8, pkRow ["ProviderType"], "#H:ProviderType_Value");
2184 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#H:IsLong_IsNull");
2185 Assert.AreEqual (false, pkRow ["IsLong"], "#H:IsLong_Value");
2186 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#H:AllowDBNull_IsNull");
2187 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#H:AllowDBNull_Value");
2188 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#H:IsReadOnly_IsNull");
2189 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#H:IsReadOnly_Value");
2190 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#H:IsRowVersion_IsNull");
2191 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#H:IsRowVersion_Value");
2192 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#H:IsUnique_IsNull");
2193 Assert.AreEqual (false, pkRow ["IsUnique"], "#H:IsUnique_Value");
2194 Assert.IsTrue (pkRow.IsNull ("IsKey"), "#H:IsKey_IsNull");
2195 Assert.AreEqual (DBNull.Value, pkRow ["IsKey"], "#H:IsKey_Value");
2196 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#H:IsAutoIncrement_IsNull");
2197 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#H:IsAutoIncrement_Value");
2198 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#H:BaseSchemaName_IsNull");
2199 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#H:BaseSchemaName_Value");
2200 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#H:BaseCatalogName_IsNull");
2201 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#H:BaseCatalogName_Value");
2202 Assert.IsTrue (pkRow.IsNull ("BaseTableName"), "#H:BaseTableName_IsNull");
2203 Assert.AreEqual (DBNull.Value, pkRow ["BaseTableName"], "#H:BaseTableName_Value");
2204 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#H:BaseColumnName_IsNull");
2205 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#H:BaseColumnName_Value");
2207 cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee where id = @id";
2208 IDbDataParameter param = cmd.CreateParameter ();
2209 param.ParameterName = "@id";
2210 cmd.Parameters.Add (param);
2211 param.DbType = DbType.Int32;
2213 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo);
2214 schema = reader.GetSchemaTable ();
2217 AssertSchemaTableStructure (schema, "#I:");
2218 Assert.AreEqual (3, schema.Rows.Count, "#I:RowCount");
2219 pkRow = schema.Select ("ColumnName = 'id'") [0];
2220 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#I:ColumnName_IsNull");
2221 Assert.AreEqual ("id", pkRow ["ColumnName"], "#I:ColumnName_Value");
2222 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#I:ColumnOrdinal_IsNull");
2223 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#I:ColumnOrdinal_Value");
2224 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#I:ColumnSize_IsNull");
2225 Assert.AreEqual (4, pkRow ["ColumnSize"], "#I:ColumnSize_Value");
2226 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#I:NumericPrecision_IsNull");
2227 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#I:NumericPrecision_Value");
2228 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#I:NumericScale_IsNull");
2229 Assert.AreEqual (255, pkRow ["NumericScale"], "#I:NumericScale_Value");
2230 Assert.IsFalse (pkRow.IsNull ("DataType"), "#I:DataType_IsNull");
2231 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#I:DataType_Value");
2232 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#I:ProviderType_IsNull");
2233 Assert.AreEqual (8, pkRow ["ProviderType"], "#I:ProviderType_Value");
2234 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#I:IsLong_IsNull");
2235 Assert.AreEqual (false, pkRow ["IsLong"], "#I:IsLong_Value");
2236 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#I:AllowDBNull_IsNull");
2237 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#I:AllowDBNull_Value");
2238 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#I:IsReadOnly_IsNull");
2239 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#I:IsReadOnly_Value");
2240 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#I:IsRowVersion_IsNull");
2241 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#I:IsRowVersion_Value");
2242 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#I:IsUnique_IsNull");
2243 Assert.AreEqual (false, pkRow ["IsUnique"], "#I:IsUnique_Value");
2244 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#I:IsKey_IsNull");
2245 Assert.AreEqual (true, pkRow ["IsKey"], "#I:IsKey_Value");
2246 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#I:IsAutoIncrement_IsNull");
2247 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#I:IsAutoIncrement_Value");
2248 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#I:BaseSchemaName_IsNull");
2249 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#I:BaseSchemaName_Value");
2250 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#I:BaseCatalogName_IsNull");
2251 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#I:BaseCatalogName_Value");
2252 Assert.IsFalse (pkRow.IsNull ("BaseTableName"), "#I:BaseTableName_IsNull");
2253 Assert.AreEqual ("employee", pkRow ["BaseTableName"], "#I:BaseTableName_Value");
2254 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#I:BaseColumnName_IsNull");
2255 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#I:BaseColumnName_Value");
2257 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly);
2258 schema = reader.GetSchemaTable ();
2261 AssertSchemaTableStructure (schema, "#J:");
2262 Assert.AreEqual (3, schema.Rows.Count, "#J:RowCount");
2263 pkRow = schema.Select ("ColumnName = 'id'") [0];
2264 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#J:ColumnName_IsNull");
2265 Assert.AreEqual ("id", pkRow ["ColumnName"], "#J:ColumnName_Value");
2266 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#J:ColumnOrdinal_IsNull");
2267 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#J:ColumnOrdinal_Value");
2268 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#J:ColumnSize_IsNull");
2269 Assert.AreEqual (4, pkRow ["ColumnSize"], "#J:ColumnSize_Value");
2270 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#J:NumericPrecision_IsNull");
2271 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#J:NumericPrecision_Value");
2272 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#J:NumericScale_IsNull");
2273 Assert.AreEqual (255, pkRow ["NumericScale"], "#J:NumericScale_Value");
2274 Assert.IsFalse (pkRow.IsNull ("DataType"), "#J:DataType_IsNull");
2275 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#J:DataType_Value");
2276 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#J:ProviderType_IsNull");
2277 Assert.AreEqual (8, pkRow ["ProviderType"], "#J:ProviderType_Value");
2278 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#J:IsLong_IsNull");
2279 Assert.AreEqual (false, pkRow ["IsLong"], "#J:IsLong_Value");
2280 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#J:AllowDBNull_IsNull");
2281 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#J:AllowDBNull_Value");
2282 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#J:IsReadOnly_IsNull");
2283 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#J:IsReadOnly_Value");
2284 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#J:IsRowVersion_IsNull");
2285 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#J:IsRowVersion_Value");
2286 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#J:IsUnique_IsNull");
2287 Assert.AreEqual (false, pkRow ["IsUnique"], "#J:IsUnique_Value");
2288 Assert.IsTrue (pkRow.IsNull ("IsKey"), "#J:IsKey_IsNull");
2289 Assert.AreEqual (DBNull.Value, pkRow ["IsKey"], "#J:IsKey_Value");
2290 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#J:IsAutoIncrement_IsNull");
2291 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#J:IsAutoIncrement_Value");
2292 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#J:BaseSchemaName_IsNull");
2293 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#J:BaseSchemaName_Value");
2294 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#J:BaseCatalogName_IsNull");
2295 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#J:BaseCatalogName_Value");
2296 Assert.IsTrue (pkRow.IsNull ("BaseTableName"), "#J:BaseTableName_IsNull");
2297 Assert.AreEqual (DBNull.Value, pkRow ["BaseTableName"], "#J:BaseTableName_Value");
2298 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#J:BaseColumnName_IsNull");
2299 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#J:BaseColumnName_Value");
2301 reader = cmd.ExecuteReader (CommandBehavior.KeyInfo);
2302 schema = reader.GetSchemaTable ();
2305 AssertSchemaTableStructure (schema, "#K:");
2306 Assert.AreEqual (3, schema.Rows.Count, "#K:RowCount");
2307 pkRow = schema.Select ("ColumnName = 'id'") [0];
2308 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#K:ColumnName_IsNull");
2309 Assert.AreEqual ("id", pkRow ["ColumnName"], "#K:ColumnName_Value");
2310 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#K:ColumnOrdinal_IsNull");
2311 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#K:ColumnOrdinal_Value");
2312 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#K:ColumnSize_IsNull");
2313 Assert.AreEqual (4, pkRow ["ColumnSize"], "#K:ColumnSize_Value");
2314 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#K:NumericPrecision_IsNull");
2315 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#K:NumericPrecision_Value");
2316 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#K:NumericScale_IsNull");
2317 Assert.AreEqual (255, pkRow ["NumericScale"], "#K:NumericScale_Value");
2318 Assert.IsFalse (pkRow.IsNull ("DataType"), "#K:DataType_IsNull");
2319 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#K:DataType_Value");
2320 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#K:ProviderType_IsNull");
2321 Assert.AreEqual (8, pkRow ["ProviderType"], "#K:ProviderType_Value");
2322 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#K:IsLong_IsNull");
2323 Assert.AreEqual (false, pkRow ["IsLong"], "#K:IsLong_Value");
2324 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#K:AllowDBNull_IsNull");
2325 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#K:AllowDBNull_Value");
2326 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#K:IsReadOnly_IsNull");
2327 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#K:IsReadOnly_Value");
2328 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#K:IsRowVersion_IsNull");
2329 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#K:IsRowVersion_Value");
2330 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#K:IsUnique_IsNull");
2331 Assert.AreEqual (false, pkRow ["IsUnique"], "#K:IsUnique_Value");
2332 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#K:IsKey_IsNull");
2333 Assert.AreEqual (true, pkRow ["IsKey"], "#K:IsKey_Value");
2334 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#K:IsAutoIncrement_IsNull");
2335 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#K:IsAutoIncrement_Value");
2336 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#K:BaseSchemaName_IsNull");
2337 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#K:BaseSchemaName_Value");
2338 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#K:BaseCatalogName_IsNull");
2339 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#K:BaseCatalogName_Value");
2340 Assert.IsFalse (pkRow.IsNull ("BaseTableName"), "#K:BaseTableName_IsNull");
2341 Assert.AreEqual ("employee", pkRow ["BaseTableName"], "#K:BaseTableName_Value");
2342 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#K:BaseColumnName_IsNull");
2343 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#K:BaseColumnName_Value");
2345 reader = cmd.ExecuteReader ();
2346 schema = reader.GetSchemaTable ();
2349 AssertSchemaTableStructure (schema, "#L:");
2350 Assert.AreEqual (3, schema.Rows.Count, "#L:RowCount");
2351 pkRow = schema.Select ("ColumnName = 'id'") [0];
2352 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#L:ColumnName_IsNull");
2353 Assert.AreEqual ("id", pkRow ["ColumnName"], "#L:ColumnName_Value");
2354 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#L:ColumnOrdinal_IsNull");
2355 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#L:ColumnOrdinal_Value");
2356 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#L:ColumnSize_IsNull");
2357 Assert.AreEqual (4, pkRow ["ColumnSize"], "#L:ColumnSize_Value");
2358 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#L:NumericPrecision_IsNull");
2359 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#L:NumericPrecision_Value");
2360 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#L:NumericScale_IsNull");
2361 Assert.AreEqual (255, pkRow ["NumericScale"], "#L:NumericScale_Value");
2362 Assert.IsFalse (pkRow.IsNull ("DataType"), "#L:DataType_IsNull");
2363 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#L:DataType_Value");
2364 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#L:ProviderType_IsNull");
2365 Assert.AreEqual (8, pkRow ["ProviderType"], "#L:ProviderType_Value");
2366 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#L:IsLong_IsNull");
2367 Assert.AreEqual (false, pkRow ["IsLong"], "#L:IsLong_Value");
2368 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#L:AllowDBNull_IsNull");
2369 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#L:AllowDBNull_Value");
2370 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#L:IsReadOnly_IsNull");
2371 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#L:IsReadOnly_Value");
2372 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#L:IsRowVersion_IsNull");
2373 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#L:IsRowVersion_Value");
2374 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#L:IsUnique_IsNull");
2375 Assert.AreEqual (false, pkRow ["IsUnique"], "#L:IsUnique_Value");
2376 Assert.IsTrue (pkRow.IsNull ("IsKey"), "#L:IsKey_IsNull");
2377 Assert.AreEqual (DBNull.Value, pkRow ["IsKey"], "#L:IsKey_Value");
2378 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#L:IsAutoIncrement_IsNull");
2379 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#L:IsAutoIncrement_Value");
2380 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#L:BaseSchemaName_IsNull");
2381 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#L:BaseSchemaName_Value");
2382 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#L:BaseCatalogName_IsNull");
2383 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#L:BaseCatalogName_Value");
2384 Assert.IsTrue (pkRow.IsNull ("BaseTableName"), "#L:BaseTableName_IsNull");
2385 Assert.AreEqual (DBNull.Value, pkRow ["BaseTableName"], "#L:BaseTableName_Value");
2386 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#L:BaseColumnName_IsNull");
2387 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#L:BaseColumnName_Value");
2393 ConnectionManager.Singleton.CloseConnection ();
2398 public void GetSchemaTableTest ()
2400 cmd.CommandText = "Select type_decimal1 as decimal,id,10 ";
2401 cmd.CommandText += "from numeric_family where id=1";
2402 reader = cmd.ExecuteReader (CommandBehavior.KeyInfo);
2403 DataTable schemaTable = reader.GetSchemaTable ();
2404 DataRow row0 = schemaTable.Rows[0];
2405 DataRow row1 = schemaTable.Rows[1];
2407 Assert.AreEqual ("decimal", row0["ColumnName"], "#1");
2408 Assert.AreEqual ("", schemaTable.Rows[2]["ColumnName"], "#2");
2410 Assert.AreEqual (0, row0["ColumnOrdinal"], "#2");
2411 Assert.AreEqual (17, row0["ColumnSize"], "#3");
2412 if (ClientVersion == 7)
2413 Assert.AreEqual (28, row0["NumericPrecision"], "#4");
2415 Assert.AreEqual (38, row0 ["NumericPrecision"], "#4");
2416 Assert.AreEqual (0, row0["NumericScale"], "#5");
2418 Assert.AreEqual (false, row0["IsUnique"], "#6");
2419 // msdotnet returns IsUnique as false for Primary key
2420 // even though table consists of a single Primary Key
2421 //Assert.AreEqual (true, row1["IsUnique"], "#7");
2422 Assert.AreEqual (false, row0["IsKey"], "#8");
2423 Assert.AreEqual (true, row1["IsKey"], "#9");
2425 //Assert.AreEqual ("servername", row0["BaseServerName"], "#10");
2426 //Assert.AreEqual ("monotest", row0["BaseCatalogName"], "#11");
2427 Assert.AreEqual ("type_decimal1", row0["BaseColumnName"], "#12");
2428 //Assert.IsNull(row0["BaseSchemaName"], "#13");
2429 Assert.AreEqual ("numeric_family", row0["BaseTableName"], "#14");
2430 Assert.AreEqual (typeof (Decimal), row0["DataType"], "#15");
2431 Assert.AreEqual (true, row0["AllowDBNull"], "#16");
2432 Assert.AreEqual (false, row1["AllowDBNull"], "#17");
2433 //Assert.IsNull(row0["ProviderType"], "#18");
2434 Assert.AreEqual (true, row0["IsAliased"], "#19");
2435 Assert.AreEqual (false, row1["IsAliased"], "#20");
2437 Assert.AreEqual (false, row0["IsExpression"], "#21");
2438 Assert.AreEqual (false, row0["IsIdentity"], "#22");
2439 Assert.AreEqual (false, row0["IsAutoIncrement"], "#23");
2440 Assert.AreEqual (false, row0["IsRowVersion"], "#24");
2441 Assert.AreEqual (false, row0["IsHidden"], "#25");
2442 Assert.AreEqual (false, row0["IsLong"], "#26");
2443 Assert.AreEqual (false, row0["IsReadOnly"], "#27");
2444 Assert.AreEqual (true, schemaTable.Rows[2]["IsReadOnly"], "#27");
2446 // Test Exception is thrown when reader is closed
2449 reader.GetSchemaTable ();
2450 Assert.Fail ("#28 Exception shud be thrown" );
2451 } catch (InvalidOperationException e) {
2452 Assert.AreEqual (typeof (InvalidOperationException), e.GetType(),
2453 "#29 Incorrect Exception");
2458 public void GetDataTypeNameTest ()
2460 cmd.CommandText = "Select id, type_tinyint, 10,null from numeric_family where id=1";
2461 reader = cmd.ExecuteReader ();
2463 Assert.AreEqual ("tinyint", reader.GetDataTypeName(1), "#1");
2464 Assert.AreEqual ("int", reader.GetDataTypeName(2), "#2");
2465 //need check on windows
2466 Assert.AreEqual ("int", reader.GetDataTypeName(3), "#3");
2468 reader.GetDataTypeName (10);
2469 Assert.Fail ("#4 Exception shud be thrown");
2470 } catch (IndexOutOfRangeException e) {
2471 Assert.AreEqual (typeof (IndexOutOfRangeException), e.GetType (),
2472 "#5 Incorrect Exception : " + e);
2477 public void GetFieldType_BigInt ()
2479 if (ClientVersion <= 7)
2480 Assert.Ignore ("BigInt data type is not supported.");
2482 cmd.CommandText = "SELECT type_bigint FROM numeric_family WHERE id = 1";
2484 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2485 Assert.AreEqual (typeof (long), rdr.GetFieldType (0));
2490 public void GetFieldType_Binary ()
2492 cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
2494 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2495 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0));
2500 public void GetFieldType_Bit ()
2502 cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
2504 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2505 Assert.AreEqual (typeof (bool), rdr.GetFieldType (0));
2510 public void GetFieldType_Char ()
2512 cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
2514 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2515 Assert.AreEqual (typeof (string), rdr.GetFieldType (0));
2520 public void GetFieldType_Date ()
2526 public void GetFieldType_DateTime ()
2528 cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
2530 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2531 Assert.AreEqual (typeof (DateTime), rdr.GetFieldType (0));
2536 public void GetFieldType_Decimal ()
2538 cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
2540 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2541 Assert.AreEqual (typeof (decimal), rdr.GetFieldType (0));
2544 cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
2546 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2547 Assert.AreEqual (typeof (decimal), rdr.GetFieldType (0));
2550 cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
2552 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2553 Assert.AreEqual (typeof (decimal), rdr.GetFieldType (0));
2556 cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
2558 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2559 Assert.AreEqual (typeof (decimal), rdr.GetFieldType (0));
2564 public void GetFieldType_Float ()
2566 cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
2568 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2569 Assert.AreEqual (typeof (double), rdr.GetFieldType (0));
2574 public void GetFieldType_Image ()
2576 cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
2578 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2579 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0));
2584 public void GetFieldType_Int ()
2586 cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
2588 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2589 Assert.AreEqual (typeof (int), rdr.GetFieldType (0));
2594 public void GetFieldType_Money ()
2596 cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
2598 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2599 Assert.AreEqual (typeof (decimal), rdr.GetFieldType (0));
2604 public void GetFieldType_NChar ()
2606 cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
2608 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2609 Assert.AreEqual (typeof (string), rdr.GetFieldType (0));
2614 public void GetFieldType_NText ()
2616 cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
2618 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2619 Assert.AreEqual (typeof (string), rdr.GetFieldType (0));
2624 public void GetFieldType_NVarChar ()
2626 cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
2628 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2629 Assert.AreEqual (typeof (string), rdr.GetFieldType (0));
2634 public void GetFieldType_Real ()
2636 cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
2638 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2639 Assert.AreEqual (typeof (float), rdr.GetFieldType (0));
2645 public void GetFieldType_SmallDateTime ()
2647 cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
2649 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2650 Assert.AreEqual (typeof (DateTime), rdr.GetFieldType (0));
2655 public void GetFieldType_SmallInt ()
2657 cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
2659 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2660 Assert.AreEqual (typeof (short), rdr.GetFieldType (0));
2665 public void GetFieldType_SmallMoney ()
2667 cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
2669 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2670 Assert.AreEqual (typeof (decimal), rdr.GetFieldType (0));
2675 public void GetFieldType_Text ()
2677 cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
2679 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2680 Assert.AreEqual (typeof (string), rdr.GetFieldType (0));
2685 public void GetFieldType_Time ()
2691 public void GetFieldType_Timestamp ()
2693 cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
2695 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2696 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0));
2701 public void GetFieldType_TinyInt ()
2703 cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
2705 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2706 Assert.AreEqual (typeof (byte), rdr.GetFieldType (0));
2711 public void GetFieldType_Udt ()
2717 public void GetFieldType_UniqueIdentifier ()
2719 cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
2721 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2722 Assert.AreEqual (typeof (Guid), rdr.GetFieldType (0));
2727 public void GetFieldType_VarBinary ()
2729 cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
2731 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2732 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0));
2737 public void GetFieldType_VarChar ()
2739 cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
2741 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2742 Assert.AreEqual (typeof (string), rdr.GetFieldType (0));
2746 // Need to populate the data from a config file
2747 // Will be replaced later
2748 void validateData(string sqlQuery, DataTable table)
2750 string fmt = "#TAB[{0}] ROW[{1}] COL[{2}] Data Mismatch";
2752 int noOfColumns = table.Columns.Count ;
2755 cmd.CommandText = sqlQuery ;
2756 reader = cmd.ExecuteReader ();
2758 while (reader.Read ()){
2759 for (int j=1; j< noOfColumns ; ++j) {
2760 Assert.AreEqual (table.Rows[i][j], reader[j],
2761 String.Format (fmt, table.TableName, i+1, j));
2770 public void NumericDataValidation ()
2772 validateData ("select * from numeric_family order by id ASC",
2777 public void StringDataValidation ()
2779 validateData ("select * from string_family order by id ASC",
2784 public void BinaryDataValidation ()
2786 validateData ("select * from binary_family order by id ASC",
2791 public void DatetimeDataValidation ()
2793 validateData ("select * from datetime_family order by id ASC",
2797 string connectionString = ConnectionManager.Singleton.ConnectionString;
2799 //FIXME : Add more test cases
2801 public void GetProviderSpecificFieldTypeTest ()
2803 using (SqlConnection conn = new SqlConnection (connectionString)) {
2805 SqlCommand cmd = conn.CreateCommand ();
2806 cmd.CommandText = "SELECT * FROM employee";
2807 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
2809 Assert.AreEqual (6, rdr.FieldCount, "#A1");
2810 Assert.AreEqual(typeof(SqlInt32), rdr.GetProviderSpecificFieldType (0), "#A2");
2811 Assert.AreEqual(typeof(SqlString), rdr.GetProviderSpecificFieldType (1), "#A3");
2812 Assert.AreEqual(typeof(SqlString), rdr.GetProviderSpecificFieldType (2), "#A4");
2813 Assert.AreEqual(typeof(SqlDateTime), rdr.GetProviderSpecificFieldType (3), "#A5");
2814 Assert.AreEqual(typeof(SqlDateTime), rdr.GetProviderSpecificFieldType (4), "#A6");
2815 Assert.AreEqual(typeof(SqlString), rdr.GetProviderSpecificFieldType (5), "#A7");
2817 cmd.CommandText = "SELECT * FROM numeric_family";
2818 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
2820 Assert.AreEqual (15, rdr.FieldCount, "#B1");
2821 Assert.AreEqual(typeof (SqlInt32), rdr.GetProviderSpecificFieldType(0), "#B2");
2822 Assert.AreEqual(typeof (SqlBoolean), rdr.GetProviderSpecificFieldType(1), "#B3");
2823 Assert.AreEqual(typeof (SqlByte), rdr.GetProviderSpecificFieldType(2), "#B4");
2824 Assert.AreEqual(typeof (SqlInt16), rdr.GetProviderSpecificFieldType(3), "#B5");
2825 Assert.AreEqual(typeof (SqlInt32), rdr.GetProviderSpecificFieldType(4), "#B6");
2826 Assert.AreEqual(typeof (SqlInt64), rdr.GetProviderSpecificFieldType(5), "#B7");
2827 Assert.AreEqual(typeof (SqlDecimal), rdr.GetProviderSpecificFieldType(6), "#B8");
2828 Assert.AreEqual(typeof (SqlDecimal), rdr.GetProviderSpecificFieldType(7), "#B9");
2829 Assert.AreEqual(typeof (SqlDecimal), rdr.GetProviderSpecificFieldType(8), "#B10");
2830 Assert.AreEqual(typeof (SqlDecimal), rdr.GetProviderSpecificFieldType(9), "#B11");
2831 Assert.AreEqual(typeof (SqlMoney), rdr.GetProviderSpecificFieldType(10), "#B12");
2832 Assert.AreEqual(typeof (SqlMoney), rdr.GetProviderSpecificFieldType(11), "#B13");
2833 Assert.AreEqual(typeof (SqlSingle), rdr.GetProviderSpecificFieldType(12), "#B14");
2834 Assert.AreEqual(typeof (SqlDouble), rdr.GetProviderSpecificFieldType(13), "#B15");
2835 Assert.AreEqual(typeof (SqlInt32), rdr.GetProviderSpecificFieldType(14), "#B16");
2840 //FIXME : Add more test cases
2842 public void GetProviderSpecificValueTest ()
2844 using (SqlConnection conn = new SqlConnection (connectionString)) {
2846 SqlCommand cmd = conn.CreateCommand ();
2847 cmd.CommandText = "SELECT * FROM employee";
2848 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
2850 Assert.AreEqual (6, rdr.FieldCount, "#1");
2851 Assert.AreEqual((SqlInt32)1,rdr.GetProviderSpecificValue(0), "#2");
2852 Assert.AreEqual((SqlString)"suresh",rdr.GetProviderSpecificValue(1), "#3");
2853 Assert.AreEqual((SqlDateTime) new DateTime (1978, 8, 22), rdr.GetProviderSpecificValue(3), "#4");
2859 public void GetProviderSpecificValueLowerBoundaryTest ()
2861 using (SqlConnection conn = new SqlConnection (connectionString)) {
2863 SqlCommand cmd = conn.CreateCommand ();
2864 cmd.CommandText = "SELECT * FROM employee";
2865 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
2868 object value = rdr.GetProviderSpecificValue (-1);
2869 Assert.Fail ("#1:" + value);
2870 } catch (IndexOutOfRangeException) {
2871 Assert.AreEqual((SqlInt32) 1, rdr.GetProviderSpecificValue (0), "#2");
2872 Assert.AreEqual((SqlString) "suresh", rdr.GetProviderSpecificValue(1), "#3");
2873 Assert.AreEqual((SqlDateTime) new DateTime (1978, 8, 22), rdr.GetProviderSpecificValue (3), "#4");
2880 public void GetProviderSpecificValueUpperBoundaryTest ()
2882 using (SqlConnection conn = new SqlConnection (connectionString)) {
2884 SqlCommand cmd = conn.CreateCommand ();
2885 cmd.CommandText = "SELECT * FROM employee";
2886 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
2889 object value = rdr.GetProviderSpecificValue (rdr.FieldCount);
2890 Assert.Fail ("#1:" + value);
2891 } catch (IndexOutOfRangeException) {
2892 Assert.AreEqual((SqlInt32) 1, rdr.GetProviderSpecificValue (0), "#2");
2893 Assert.AreEqual((SqlString) "suresh", rdr.GetProviderSpecificValue (1), "#3");
2894 Assert.AreEqual((SqlDateTime) new DateTime (1978, 8, 22), rdr.GetProviderSpecificValue (3), "#4");
2900 //FIXME : Add more test cases
2902 public void GetProviderSpecificValuesTest ()
2904 using (SqlConnection conn = new SqlConnection (connectionString)) {
2906 SqlCommand cmd = conn.CreateCommand ();
2907 cmd.CommandText = "SELECT * FROM employee";
2908 Object [] psValues = new Object[6];
2909 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
2911 int count = rdr.GetProviderSpecificValues (psValues);
2912 Assert.AreEqual (6, count, "#1");
2913 Assert.AreEqual ((SqlInt32) 1, psValues [0], "#2");
2914 Assert.AreEqual ((SqlString) "suresh", psValues [1], "#3");
2915 Assert.AreEqual ((SqlString) "kumar", psValues [2], "#4");
2916 Assert.AreEqual ((SqlDateTime) new DateTime (1978, 8, 22), psValues [3], "#5");
2917 Assert.AreEqual ((SqlDateTime) new DateTime (2001, 03, 12), psValues [4], "#6");
2918 Assert.AreEqual ((SqlString) "suresh@gmail.com", psValues [5], "#7");
2924 public void GetProviderSpecificValues_Values_Null ()
2926 cmd.CommandText = "SELECT * FROM employee";
2927 reader = cmd.ExecuteReader ();
2931 reader.GetProviderSpecificValues (null);
2933 } catch (ArgumentNullException ex) {
2934 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2935 Assert.IsNull (ex.InnerException, "#3");
2936 Assert.IsNotNull (ex.Message, "#4");
2937 Assert.AreEqual ("values", ex.ParamName, "#5");
2942 public void GetProviderSpecificValuesSmallArrayTest ()
2944 using (SqlConnection conn = new SqlConnection (connectionString)) {
2946 SqlCommand cmd = conn.CreateCommand ();
2947 cmd.CommandText = "SELECT * FROM employee";
2948 Object [] psValues = new Object[2];
2949 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
2951 int count = rdr.GetProviderSpecificValues (psValues);
2952 Assert.AreEqual (2, count, "#1");
2953 Assert.AreEqual ((SqlInt32) 1, psValues [0], "#2");
2954 Assert.AreEqual ((SqlString) "suresh", psValues [1], "#3");
2960 public void GetProviderSpecificValuesLargeArrayTest ()
2962 using (SqlConnection conn = new SqlConnection (connectionString)) {
2964 SqlCommand cmd = conn.CreateCommand ();
2965 cmd.CommandText = "SELECT * FROM employee";
2966 Object [] psValues = new Object[10];
2967 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
2969 int count = rdr.GetProviderSpecificValues (psValues);
2970 Assert.AreEqual (6, count, "#1");
2971 Assert.AreEqual ((SqlInt32) 1, psValues [0], "#2");
2972 Assert.AreEqual ((SqlString) "suresh", psValues [1], "#3");
2973 Assert.AreEqual ((SqlString) "kumar", psValues [2], "#4");
2974 Assert.AreEqual ((SqlDateTime) new DateTime (1978, 8, 22), psValues [3], "#5");
2975 Assert.AreEqual ((SqlDateTime) new DateTime (2001, 03, 12), psValues [4], "#6");
2976 Assert.AreEqual ((SqlString) "suresh@gmail.com", psValues [5], "#7");
2977 Assert.IsNull (psValues [6], "#8");
2978 Assert.IsNull (psValues [7], "#9");
2979 Assert.IsNull (psValues [8], "#10");
2980 Assert.IsNull (psValues [9], "#11");
2986 public void GetSqlBytesTest ()
2988 using (SqlConnection conn = new SqlConnection (connectionString)) {
2990 SqlCommand cmd = conn.CreateCommand ();
2991 cmd.CommandText = "SELECT * FROM binary_family where id=1";
2992 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
2994 Assert.AreEqual (8, rdr.FieldCount);
2996 SqlBytes sb = rdr.GetSqlBytes (1);
2997 Assert.AreEqual (8, sb.Length, "#A1");
2998 Assert.AreEqual (53, sb [0], "#A2");
2999 Assert.AreEqual (0, sb [1], "#A3");
3000 Assert.AreEqual (0, sb [2], "#A4");
3001 Assert.AreEqual (0, sb [3], "#A5");
3002 Assert.AreEqual (0, sb [4], "#A6");
3003 Assert.AreEqual (0, sb [5], "#A7");
3004 Assert.AreEqual (0, sb [6], "#A8");
3005 Assert.AreEqual (0, sb [7], "#A9");
3007 sb = rdr.GetSqlBytes (2);
3008 Assert.AreEqual (typeof (SqlBinary), rdr.GetSqlValue (2).GetType (), "B1#");
3009 Assert.AreEqual (33, sb.Length, "#B2");
3010 Assert.AreEqual (48, sb [0], "#B3");
3011 Assert.AreEqual (49, sb [1], "#B4");
3012 Assert.AreEqual (50, sb [2], "#B5");
3013 Assert.AreEqual (53, sb [15], "#B6");
3014 Assert.AreEqual (57, sb [29], "#B7");
3021 static void AssertSchemaTableStructure (DataTable schemaTable, string prefix)
3023 object [] [] columns = {
3024 new object [] { "ColumnName", typeof (string) },
3025 new object [] { "ColumnOrdinal", typeof (int) },
3026 new object [] { "ColumnSize", typeof (int) },
3027 new object [] { "NumericPrecision", typeof (short) },
3028 new object [] { "NumericScale", typeof (short) },
3029 new object [] { "IsUnique", typeof (bool) },
3030 new object [] { "IsKey", typeof (bool) },
3031 new object [] { "BaseServerName", typeof (string) },
3032 new object [] { "BaseCatalogName", typeof (string) },
3033 new object [] { "BaseColumnName", typeof (string) },
3034 new object [] { "BaseSchemaName", typeof (string) },
3035 new object [] { "BaseTableName", typeof (string) },
3036 new object [] { "DataType", typeof (Type) },
3037 new object [] { "AllowDBNull", typeof (bool) },
3038 new object [] { "ProviderType", typeof (int) },
3039 new object [] { "IsAliased", typeof (bool) },
3040 new object [] { "IsExpression", typeof (bool) },
3041 new object [] { "IsIdentity", typeof (bool) },
3042 new object [] { "IsAutoIncrement", typeof (bool) },
3043 new object [] { "IsRowVersion", typeof (bool) },
3044 new object [] { "IsHidden", typeof (bool) },
3045 new object [] { "IsLong", typeof (bool) },
3046 new object [] { "IsReadOnly", typeof (bool) },
3047 new object [] { "ProviderSpecificDataType", typeof (Type) },
3048 new object [] { "DataTypeName", typeof (string) },
3049 new object [] { "XmlSchemaCollectionDatabase", typeof (string) },
3050 new object [] { "XmlSchemaCollectionOwningSchema", typeof (string) },
3051 new object [] { "XmlSchemaCollectionName", typeof (string) },
3052 new object [] { "UdtAssemblyQualifiedName", typeof (string) },
3053 new object [] { "NonVersionedProviderType", typeof (int) },
3054 new object [] { "IsColumnSet", typeof (bool) }
3057 Assert.AreEqual (columns.Length, schemaTable.Columns.Count, prefix);
3059 for (int i = 0; i < columns.Length; i++) {
3060 DataColumn col = schemaTable.Columns [i];
3061 Assert.IsTrue (col.AllowDBNull, prefix + "AllowDBNull (" + i + ")");
3062 Assert.AreEqual (columns [i] [0], col.ColumnName, prefix + "ColumnName (" + i + ")");
3063 Assert.AreEqual (columns [i] [1], col.DataType, prefix + "DataType (" + i + ")");
3069 return (engine.ClientVersion);
3075 [Category ("sqlserver")]
3076 public class SqlDataReaderSchemaTest
3080 EngineConfig engine;
3083 public void SetUp ()
3085 conn = (SqlConnection) ConnectionManager.Singleton.Connection;
3086 ConnectionManager.Singleton.OpenConnection ();
3087 cmd = conn.CreateCommand ();
3088 engine = ConnectionManager.Singleton.Engine;
3092 public void TearDown ()
3096 ConnectionManager.Singleton.CloseConnection ();
3100 public void ColumnSize_BigInt ()
3102 if (ClientVersion <= 7)
3103 Assert.Ignore ("BigInt data type is not supported.");
3105 cmd.CommandText = "SELECT type_bigint FROM numeric_family WHERE id = 1";
3107 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3108 DataTable schemaTable = rdr.GetSchemaTable ();
3109 DataRow row = schemaTable.Rows [0];
3110 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3111 // we only support TDS 7.0, which returns bigint data values as decimal(19,0)
3112 if (ClientVersion > 7)
3113 Assert.AreEqual (8, row ["ColumnSize"], "Value");
3115 Assert.AreEqual (17, row ["ColumnSize"], "Value");
3120 public void ColumnSize_Binary ()
3122 cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
3124 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3125 DataTable schemaTable = rdr.GetSchemaTable ();
3126 DataRow row = schemaTable.Rows [0];
3127 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3128 Assert.AreEqual (8, row ["ColumnSize"], "Value");
3133 public void ColumnSize_Bit ()
3135 cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
3137 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3138 DataTable schemaTable = rdr.GetSchemaTable ();
3139 DataRow row = schemaTable.Rows [0];
3140 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3141 Assert.AreEqual (1, row ["ColumnSize"], "Value");
3146 public void ColumnSize_Char ()
3148 cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
3150 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3151 DataTable schemaTable = rdr.GetSchemaTable ();
3152 DataRow row = schemaTable.Rows [0];
3153 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3154 Assert.AreEqual (10, row ["ColumnSize"], "Value");
3159 public void ColumnSize_Date ()
3165 public void ColumnSize_DateTime ()
3167 cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
3169 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3170 DataTable schemaTable = rdr.GetSchemaTable ();
3171 DataRow row = schemaTable.Rows [0];
3172 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3173 Assert.AreEqual (8, row ["ColumnSize"], "Value");
3178 public void ColumnSize_Decimal ()
3180 cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
3182 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3183 DataTable schemaTable = rdr.GetSchemaTable ();
3184 DataRow row = schemaTable.Rows [0];
3185 Assert.IsFalse (row.IsNull ("ColumnSize"), "#A:IsNull");
3186 Assert.AreEqual (17, row ["ColumnSize"], "#A:Value");
3189 cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
3191 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3192 DataTable schemaTable = rdr.GetSchemaTable ();
3193 DataRow row = schemaTable.Rows [0];
3194 Assert.IsFalse (row.IsNull ("ColumnSize"), "#B:IsNull");
3195 Assert.AreEqual (17, row ["ColumnSize"], "#B:Value");
3198 cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
3200 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3201 DataTable schemaTable = rdr.GetSchemaTable ();
3202 DataRow row = schemaTable.Rows [0];
3203 Assert.IsFalse (row.IsNull ("ColumnSize"), "#C:IsNull");
3204 Assert.AreEqual (17, row ["ColumnSize"], "#C:Value");
3207 cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
3209 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3210 DataTable schemaTable = rdr.GetSchemaTable ();
3211 DataRow row = schemaTable.Rows [0];
3212 Assert.IsFalse (row.IsNull ("ColumnSize"), "#D:IsNull");
3213 Assert.AreEqual (17, row ["ColumnSize"], "#D:Value");
3218 public void ColumnSize_Float ()
3220 cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
3222 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3223 DataTable schemaTable = rdr.GetSchemaTable ();
3224 DataRow row = schemaTable.Rows [0];
3225 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3226 Assert.AreEqual (8, row ["ColumnSize"], "Value");
3231 public void ColumnSize_Image ()
3233 cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
3235 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3236 DataTable schemaTable = rdr.GetSchemaTable ();
3237 DataRow row = schemaTable.Rows [0];
3238 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3239 Assert.AreEqual (int.MaxValue, row ["ColumnSize"], "Value");
3244 public void ColumnSize_Int ()
3246 cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
3248 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3249 DataTable schemaTable = rdr.GetSchemaTable ();
3250 DataRow row = schemaTable.Rows [0];
3251 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3252 Assert.AreEqual (4, row ["ColumnSize"], "Value");
3257 public void ColumnSize_Money ()
3259 cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
3261 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3262 DataTable schemaTable = rdr.GetSchemaTable ();
3263 DataRow row = schemaTable.Rows [0];
3264 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3265 Assert.AreEqual (8, row ["ColumnSize"], "Value");
3270 public void ColumnSize_NChar ()
3272 cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
3274 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3275 DataTable schemaTable = rdr.GetSchemaTable ();
3276 DataRow row = schemaTable.Rows [0];
3277 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3278 Assert.AreEqual (10, row ["ColumnSize"], "Value");
3283 public void ColumnSize_NText ()
3285 cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
3287 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3288 DataTable schemaTable = rdr.GetSchemaTable ();
3289 DataRow row = schemaTable.Rows [0];
3290 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3291 Assert.AreEqual (1073741823, row ["ColumnSize"], "Value");
3296 public void ColumnSize_NVarChar ()
3298 cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
3300 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3301 DataTable schemaTable = rdr.GetSchemaTable ();
3302 DataRow row = schemaTable.Rows [0];
3303 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3304 Assert.AreEqual (10, row ["ColumnSize"], "Value");
3309 public void ColumnSize_Real ()
3311 cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
3313 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3314 DataTable schemaTable = rdr.GetSchemaTable ();
3315 DataRow row = schemaTable.Rows [0];
3316 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3317 Assert.AreEqual (4, row ["ColumnSize"], "Value");
3323 public void ColumnSize_SmallDateTime ()
3325 cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
3327 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3328 DataTable schemaTable = rdr.GetSchemaTable ();
3329 DataRow row = schemaTable.Rows [0];
3330 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3331 Assert.AreEqual (4, row ["ColumnSize"], "Value");
3336 public void ColumnSize_SmallInt ()
3338 cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
3340 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3341 DataTable schemaTable = rdr.GetSchemaTable ();
3342 DataRow row = schemaTable.Rows [0];
3343 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3344 Assert.AreEqual (2, row ["ColumnSize"], "Value");
3349 public void ColumnSize_SmallMoney ()
3351 cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
3353 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3354 DataTable schemaTable = rdr.GetSchemaTable ();
3355 DataRow row = schemaTable.Rows [0];
3356 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3357 Assert.AreEqual (4, row ["ColumnSize"], "Value");
3362 public void ColumnSize_Text ()
3364 cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
3366 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3367 DataTable schemaTable = rdr.GetSchemaTable ();
3368 DataRow row = schemaTable.Rows [0];
3369 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3370 Assert.AreEqual (2147483647, row ["ColumnSize"], "Value");
3375 public void ColumnSize_Time ()
3381 public void ColumnSize_Timestamp ()
3383 cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
3385 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3386 DataTable schemaTable = rdr.GetSchemaTable ();
3387 DataRow row = schemaTable.Rows [0];
3388 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3389 Assert.AreEqual (8, row ["ColumnSize"], "Value");
3394 public void ColumnSize_TinyInt ()
3396 cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
3398 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3399 DataTable schemaTable = rdr.GetSchemaTable ();
3400 DataRow row = schemaTable.Rows [0];
3401 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3402 Assert.AreEqual (1, row ["ColumnSize"], "Value");
3407 public void ColumnSize_Udt ()
3413 public void ColumnSize_UniqueIdentifier ()
3415 cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
3417 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3418 DataTable schemaTable = rdr.GetSchemaTable ();
3419 DataRow row = schemaTable.Rows [0];
3420 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3421 Assert.AreEqual (16, row ["ColumnSize"], "Value");
3426 public void ColumnSize_VarBinary ()
3428 cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
3430 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3431 DataTable schemaTable = rdr.GetSchemaTable ();
3432 DataRow row = schemaTable.Rows [0];
3433 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3434 Assert.AreEqual (255, row ["ColumnSize"], "Value");
3439 public void ColumnSize_VarChar ()
3441 cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
3443 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3444 DataTable schemaTable = rdr.GetSchemaTable ();
3445 DataRow row = schemaTable.Rows [0];
3446 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3447 Assert.AreEqual (10, row ["ColumnSize"], "Value");
3452 public void DataType_BigInt ()
3454 if (ClientVersion <= 7)
3455 Assert.Ignore ("BigInt data type is not supported.");
3457 cmd.CommandText = "SELECT type_bigint FROM numeric_family WHERE id = 1";
3459 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3460 DataTable schemaTable = rdr.GetSchemaTable ();
3461 DataRow row = schemaTable.Rows [0];
3462 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3463 Assert.AreEqual (typeof (long), row ["DataType"], "Value");
3468 public void DataType_Binary ()
3470 cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
3472 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3473 DataTable schemaTable = rdr.GetSchemaTable ();
3474 DataRow row = schemaTable.Rows [0];
3475 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3476 Assert.AreEqual (typeof (byte []), row ["DataType"], "Value");
3481 public void DataType_Bit ()
3483 cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
3485 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3486 DataTable schemaTable = rdr.GetSchemaTable ();
3487 DataRow row = schemaTable.Rows [0];
3488 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3489 Assert.AreEqual (typeof (bool), row ["DataType"], "Value");
3494 public void DataType_Char ()
3496 cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
3498 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3499 DataTable schemaTable = rdr.GetSchemaTable ();
3500 DataRow row = schemaTable.Rows [0];
3501 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3502 Assert.AreEqual (typeof (string), row ["DataType"], "Value");
3507 public void DataType_Date ()
3513 public void DataType_DateTime ()
3515 cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
3517 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3518 DataTable schemaTable = rdr.GetSchemaTable ();
3519 DataRow row = schemaTable.Rows [0];
3520 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3521 Assert.AreEqual (typeof (DateTime), row ["DataType"], "Value");
3526 public void DataType_Decimal ()
3528 cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
3530 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3531 DataTable schemaTable = rdr.GetSchemaTable ();
3532 DataRow row = schemaTable.Rows [0];
3533 Assert.IsFalse (row.IsNull ("DataType"), "#A:IsNull");
3534 Assert.AreEqual (typeof (decimal), row ["DataType"], "#A:Value");
3537 cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
3539 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3540 DataTable schemaTable = rdr.GetSchemaTable ();
3541 DataRow row = schemaTable.Rows [0];
3542 Assert.IsFalse (row.IsNull ("DataType"), "#B:IsNull");
3543 Assert.AreEqual (typeof (decimal), row ["DataType"], "#B:Value");
3546 cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
3548 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3549 DataTable schemaTable = rdr.GetSchemaTable ();
3550 DataRow row = schemaTable.Rows [0];
3551 Assert.IsFalse (row.IsNull ("DataType"), "#C:IsNull");
3552 Assert.AreEqual (typeof (decimal), row ["DataType"], "#C:Value");
3555 cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
3557 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3558 DataTable schemaTable = rdr.GetSchemaTable ();
3559 DataRow row = schemaTable.Rows [0];
3560 Assert.IsFalse (row.IsNull ("DataType"), "#D:IsNull");
3561 Assert.AreEqual (typeof (decimal), row ["DataType"], "#D:Value");
3566 public void DataType_Float ()
3568 cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
3570 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3571 DataTable schemaTable = rdr.GetSchemaTable ();
3572 DataRow row = schemaTable.Rows [0];
3573 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3574 Assert.AreEqual (typeof (double), row ["DataType"], "Value");
3579 public void DataType_Image ()
3581 cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
3583 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3584 DataTable schemaTable = rdr.GetSchemaTable ();
3585 DataRow row = schemaTable.Rows [0];
3586 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3587 Assert.AreEqual (typeof (byte []), row ["DataType"], "Value");
3592 public void DataType_Int ()
3594 cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
3596 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3597 DataTable schemaTable = rdr.GetSchemaTable ();
3598 DataRow row = schemaTable.Rows [0];
3599 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3600 Assert.AreEqual (typeof (int), row ["DataType"], "Value");
3605 public void DataType_Money ()
3607 cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
3609 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3610 DataTable schemaTable = rdr.GetSchemaTable ();
3611 DataRow row = schemaTable.Rows [0];
3612 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3613 Assert.AreEqual (typeof (decimal), row ["DataType"], "Value");
3618 public void DataType_NChar ()
3620 cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
3622 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3623 DataTable schemaTable = rdr.GetSchemaTable ();
3624 DataRow row = schemaTable.Rows [0];
3625 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3626 Assert.AreEqual (typeof (string), row ["DataType"], "Value");
3631 public void DataType_NText ()
3633 cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
3635 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3636 DataTable schemaTable = rdr.GetSchemaTable ();
3637 DataRow row = schemaTable.Rows [0];
3638 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3639 Assert.AreEqual (typeof (string), row ["DataType"], "Value");
3644 public void DataType_NVarChar ()
3646 cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
3648 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3649 DataTable schemaTable = rdr.GetSchemaTable ();
3650 DataRow row = schemaTable.Rows [0];
3651 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3652 Assert.AreEqual (typeof (string), row ["DataType"], "Value");
3657 public void DataType_Real ()
3659 cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
3661 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3662 DataTable schemaTable = rdr.GetSchemaTable ();
3663 DataRow row = schemaTable.Rows [0];
3664 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3665 Assert.AreEqual (typeof (float), row ["DataType"], "Value");
3671 public void DataType_SmallDateTime ()
3673 cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
3675 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3676 DataTable schemaTable = rdr.GetSchemaTable ();
3677 DataRow row = schemaTable.Rows [0];
3678 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3679 Assert.AreEqual (typeof (DateTime), row ["DataType"], "Value");
3684 public void DataType_SmallInt ()
3686 cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
3688 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3689 DataTable schemaTable = rdr.GetSchemaTable ();
3690 DataRow row = schemaTable.Rows [0];
3691 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3692 Assert.AreEqual (typeof (short), row ["DataType"], "Value");
3697 public void DataType_SmallMoney ()
3699 cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
3701 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3702 DataTable schemaTable = rdr.GetSchemaTable ();
3703 DataRow row = schemaTable.Rows [0];
3704 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3705 Assert.AreEqual (typeof (decimal), row ["DataType"], "Value");
3710 public void DataType_Text ()
3712 cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
3714 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3715 DataTable schemaTable = rdr.GetSchemaTable ();
3716 DataRow row = schemaTable.Rows [0];
3717 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3718 Assert.AreEqual (typeof (string), row ["DataType"], "Value");
3723 public void DataType_Time ()
3729 public void DataType_Timestamp ()
3731 cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
3733 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3734 DataTable schemaTable = rdr.GetSchemaTable ();
3735 DataRow row = schemaTable.Rows [0];
3736 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3737 Assert.AreEqual (typeof (byte []), row ["DataType"], "Value");
3742 public void DataType_TinyInt ()
3744 cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
3746 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3747 DataTable schemaTable = rdr.GetSchemaTable ();
3748 DataRow row = schemaTable.Rows [0];
3749 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3750 Assert.AreEqual (typeof (byte), row ["DataType"], "Value");
3755 public void DataType_Udt ()
3761 public void DataType_UniqueIdentifier ()
3763 cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
3765 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3766 DataTable schemaTable = rdr.GetSchemaTable ();
3767 DataRow row = schemaTable.Rows [0];
3768 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3769 Assert.AreEqual (typeof (Guid), row ["DataType"], "Value");
3774 public void DataType_VarBinary ()
3776 cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
3778 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3779 DataTable schemaTable = rdr.GetSchemaTable ();
3780 DataRow row = schemaTable.Rows [0];
3781 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3782 Assert.AreEqual (typeof (byte []), row ["DataType"], "Value");
3787 public void DataType_VarChar ()
3789 cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
3791 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3792 DataTable schemaTable = rdr.GetSchemaTable ();
3793 DataRow row = schemaTable.Rows [0];
3794 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3795 Assert.AreEqual (typeof (string), row ["DataType"], "Value");
3800 public void IsLong_BigInt ()
3802 if (ClientVersion <= 7)
3803 Assert.Ignore ("BigInt data type is not supported.");
3805 cmd.CommandText = "SELECT type_bigint FROM numeric_family WHERE id = 1";
3807 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3808 DataTable schemaTable = rdr.GetSchemaTable ();
3809 DataRow row = schemaTable.Rows [0];
3810 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3811 Assert.AreEqual (false, row ["IsLong"], "Value");
3816 public void IsLong_Binary ()
3818 cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
3820 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3821 DataTable schemaTable = rdr.GetSchemaTable ();
3822 DataRow row = schemaTable.Rows [0];
3823 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3824 Assert.AreEqual (false, row ["IsLong"], "Value");
3829 public void IsLong_Bit ()
3831 cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
3833 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3834 DataTable schemaTable = rdr.GetSchemaTable ();
3835 DataRow row = schemaTable.Rows [0];
3836 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3837 Assert.AreEqual (false, row ["IsLong"], "Value");
3842 public void IsLong_Char ()
3844 cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
3846 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3847 DataTable schemaTable = rdr.GetSchemaTable ();
3848 DataRow row = schemaTable.Rows [0];
3849 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3850 Assert.AreEqual (false, row ["IsLong"], "Value");
3855 public void IsLong_Date ()
3861 public void IsLong_DateTime ()
3863 cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
3865 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3866 DataTable schemaTable = rdr.GetSchemaTable ();
3867 DataRow row = schemaTable.Rows [0];
3868 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3869 Assert.AreEqual (false, row ["IsLong"], "Value");
3874 public void IsLong_Decimal ()
3876 cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
3878 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3879 DataTable schemaTable = rdr.GetSchemaTable ();
3880 DataRow row = schemaTable.Rows [0];
3881 Assert.IsFalse (row.IsNull ("IsLong"), "#A:IsNull");
3882 Assert.AreEqual (false, row ["IsLong"], "#A:Value");
3885 cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
3887 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3888 DataTable schemaTable = rdr.GetSchemaTable ();
3889 DataRow row = schemaTable.Rows [0];
3890 Assert.IsFalse (row.IsNull ("IsLong"), "#B:IsNull");
3891 Assert.AreEqual (false, row ["IsLong"], "#B:Value");
3894 cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
3896 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3897 DataTable schemaTable = rdr.GetSchemaTable ();
3898 DataRow row = schemaTable.Rows [0];
3899 Assert.IsFalse (row.IsNull ("IsLong"), "#C:IsNull");
3900 Assert.AreEqual (false, row ["IsLong"], "#C:Value");
3903 cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
3905 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3906 DataTable schemaTable = rdr.GetSchemaTable ();
3907 DataRow row = schemaTable.Rows [0];
3908 Assert.IsFalse (row.IsNull ("IsLong"), "#D:IsNull");
3909 Assert.AreEqual (false, row ["IsLong"], "#D:Value");
3914 public void IsLong_Float ()
3916 cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
3918 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3919 DataTable schemaTable = rdr.GetSchemaTable ();
3920 DataRow row = schemaTable.Rows [0];
3921 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3922 Assert.AreEqual (false, row ["IsLong"], "Value");
3927 public void IsLong_Image ()
3929 cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
3931 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3932 DataTable schemaTable = rdr.GetSchemaTable ();
3933 DataRow row = schemaTable.Rows [0];
3934 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3935 Assert.AreEqual (true, row ["IsLong"], "Value");
3940 public void IsLong_Int ()
3942 cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
3944 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3945 DataTable schemaTable = rdr.GetSchemaTable ();
3946 DataRow row = schemaTable.Rows [0];
3947 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3948 Assert.AreEqual (false, row ["IsLong"], "Value");
3953 public void IsLong_Money ()
3955 cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
3957 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3958 DataTable schemaTable = rdr.GetSchemaTable ();
3959 DataRow row = schemaTable.Rows [0];
3960 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3961 Assert.AreEqual (false, row ["IsLong"], "Value");
3966 public void IsLong_NChar ()
3968 cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
3970 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3971 DataTable schemaTable = rdr.GetSchemaTable ();
3972 DataRow row = schemaTable.Rows [0];
3973 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3974 Assert.AreEqual (false, row ["IsLong"], "Value");
3979 public void IsLong_NText ()
3981 cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
3983 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3984 DataTable schemaTable = rdr.GetSchemaTable ();
3985 DataRow row = schemaTable.Rows [0];
3986 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3987 Assert.AreEqual (true, row ["IsLong"], "Value");
3992 public void IsLong_NVarChar ()
3994 cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
3996 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3997 DataTable schemaTable = rdr.GetSchemaTable ();
3998 DataRow row = schemaTable.Rows [0];
3999 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4000 Assert.AreEqual (false, row ["IsLong"], "Value");
4005 public void IsLong_Real ()
4007 cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
4009 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4010 DataTable schemaTable = rdr.GetSchemaTable ();
4011 DataRow row = schemaTable.Rows [0];
4012 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4013 Assert.AreEqual (false, row ["IsLong"], "Value");
4019 public void IsLong_SmallDateTime ()
4021 cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
4023 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4024 DataTable schemaTable = rdr.GetSchemaTable ();
4025 DataRow row = schemaTable.Rows [0];
4026 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4027 Assert.AreEqual (false, row ["IsLong"], "Value");
4032 public void IsLong_SmallInt ()
4034 cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
4036 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4037 DataTable schemaTable = rdr.GetSchemaTable ();
4038 DataRow row = schemaTable.Rows [0];
4039 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4040 Assert.AreEqual (false, row ["IsLong"], "Value");
4045 public void IsLong_SmallMoney ()
4047 cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
4049 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4050 DataTable schemaTable = rdr.GetSchemaTable ();
4051 DataRow row = schemaTable.Rows [0];
4052 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4053 Assert.AreEqual (false, row ["IsLong"], "Value");
4058 public void IsLong_Text ()
4060 cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
4062 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4063 DataTable schemaTable = rdr.GetSchemaTable ();
4064 DataRow row = schemaTable.Rows [0];
4065 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4066 Assert.AreEqual (true, row ["IsLong"], "Value");
4071 public void IsLong_Time ()
4077 public void IsLong_Timestamp ()
4079 cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
4081 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4082 DataTable schemaTable = rdr.GetSchemaTable ();
4083 DataRow row = schemaTable.Rows [0];
4084 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4085 Assert.AreEqual (false, row ["IsLong"], "Value");
4090 public void IsLong_TinyInt ()
4092 cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
4094 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4095 DataTable schemaTable = rdr.GetSchemaTable ();
4096 DataRow row = schemaTable.Rows [0];
4097 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4098 Assert.AreEqual (false, row ["IsLong"], "Value");
4103 public void IsLong_Udt ()
4109 public void IsLong_UniqueIdentifier ()
4111 cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
4113 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4114 DataTable schemaTable = rdr.GetSchemaTable ();
4115 DataRow row = schemaTable.Rows [0];
4116 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4117 Assert.AreEqual (false, row ["IsLong"], "Value");
4122 public void IsLong_VarBinary ()
4124 cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
4126 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4127 DataTable schemaTable = rdr.GetSchemaTable ();
4128 DataRow row = schemaTable.Rows [0];
4129 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4130 Assert.AreEqual (false, row ["IsLong"], "Value");
4135 public void IsLong_VarChar ()
4137 cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
4139 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4140 DataTable schemaTable = rdr.GetSchemaTable ();
4141 DataRow row = schemaTable.Rows [0];
4142 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4143 Assert.AreEqual (false, row ["IsLong"], "Value");
4148 public void NumericPrecision_BigInt ()
4150 if (ClientVersion <= 7)
4151 Assert.Ignore ("BigInt data type is not supported.");
4153 cmd.CommandText = "SELECT type_bigint FROM numeric_family WHERE id = 1";
4155 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4156 DataTable schemaTable = rdr.GetSchemaTable ();
4157 DataRow row = schemaTable.Rows [0];
4158 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4159 if (ClientVersion > 7)
4160 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4162 Assert.AreEqual (19, row ["NumericPrecision"], "Value");
4167 public void NumericPrecision_Binary ()
4169 cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
4171 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4172 DataTable schemaTable = rdr.GetSchemaTable ();
4173 DataRow row = schemaTable.Rows [0];
4174 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4175 if (ClientVersion > 7)
4176 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4178 Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4183 public void NumericPrecision_Bit ()
4185 cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
4187 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4188 DataTable schemaTable = rdr.GetSchemaTable ();
4189 DataRow row = schemaTable.Rows [0];
4190 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4191 if (ClientVersion > 7)
4192 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4194 Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4199 public void NumericPrecision_Char ()
4201 cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
4203 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4204 DataTable schemaTable = rdr.GetSchemaTable ();
4205 DataRow row = schemaTable.Rows [0];
4206 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4207 if (ClientVersion > 7)
4208 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4210 Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4215 public void NumericPrecision_Date ()
4221 public void NumericPrecision_DateTime ()
4223 cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
4225 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4226 DataTable schemaTable = rdr.GetSchemaTable ();
4227 DataRow row = schemaTable.Rows [0];
4228 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4229 if (ClientVersion > 7)
4230 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4232 Assert.AreEqual (23, row ["NumericPrecision"], "Value");
4237 public void NumericPrecision_Decimal ()
4239 cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
4241 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4242 DataTable schemaTable = rdr.GetSchemaTable ();
4243 DataRow row = schemaTable.Rows [0];
4244 Assert.IsFalse (row.IsNull ("NumericPrecision"), "#A:IsNull");
4245 if (ClientVersion == 7)
4246 Assert.AreEqual (28, row ["NumericPrecision"], "#A:Value");
4248 Assert.AreEqual (38, row ["NumericPrecision"], "#A:Value");
4251 cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
4253 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4254 DataTable schemaTable = rdr.GetSchemaTable ();
4255 DataRow row = schemaTable.Rows [0];
4256 Assert.IsFalse (row.IsNull ("NumericPrecision"), "#B:IsNull");
4257 Assert.AreEqual (10, row ["NumericPrecision"], "#B:Value");
4260 cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
4262 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4263 DataTable schemaTable = rdr.GetSchemaTable ();
4264 DataRow row = schemaTable.Rows [0];
4265 Assert.IsFalse (row.IsNull ("NumericPrecision"), "#C:IsNull");
4266 if (ClientVersion == 7)
4267 Assert.AreEqual (28, row ["NumericPrecision"], "#C:Value");
4269 Assert.AreEqual (38, row ["NumericPrecision"], "#C:Value");
4272 cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
4274 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4275 DataTable schemaTable = rdr.GetSchemaTable ();
4276 DataRow row = schemaTable.Rows [0];
4277 Assert.IsFalse (row.IsNull ("NumericPrecision"), "#D:IsNull");
4278 Assert.AreEqual (10, row ["NumericPrecision"], "#D:Value");
4283 public void NumericPrecision_Float ()
4285 cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
4287 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4288 DataTable schemaTable = rdr.GetSchemaTable ();
4289 DataRow row = schemaTable.Rows [0];
4290 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4291 if (ClientVersion > 7)
4292 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4294 Assert.AreEqual (15, row ["NumericPrecision"], "Value");
4299 public void NumericPrecision_Image ()
4301 cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
4303 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4304 DataTable schemaTable = rdr.GetSchemaTable ();
4305 DataRow row = schemaTable.Rows [0];
4306 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4307 if (ClientVersion > 7)
4308 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4310 Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4315 public void NumericPrecision_Int ()
4317 cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
4319 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4320 DataTable schemaTable = rdr.GetSchemaTable ();
4321 DataRow row = schemaTable.Rows [0];
4322 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4323 if (ClientVersion > 7)
4324 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4326 Assert.AreEqual (10, row ["NumericPrecision"], "Value");
4331 public void NumericPrecision_Money ()
4333 cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
4335 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4336 DataTable schemaTable = rdr.GetSchemaTable ();
4337 DataRow row = schemaTable.Rows [0];
4338 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4339 if (ClientVersion > 7)
4340 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4342 Assert.AreEqual (19, row ["NumericPrecision"], "Value");
4347 public void NumericPrecision_NChar ()
4349 cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
4351 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4352 DataTable schemaTable = rdr.GetSchemaTable ();
4353 DataRow row = schemaTable.Rows [0];
4354 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4355 if (ClientVersion > 7)
4356 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4358 Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4363 public void NumericPrecision_NText ()
4365 cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
4367 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4368 DataTable schemaTable = rdr.GetSchemaTable ();
4369 DataRow row = schemaTable.Rows [0];
4370 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4371 if (ClientVersion > 7)
4372 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4374 Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4379 public void NumericPrecision_NVarChar ()
4381 cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
4383 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4384 DataTable schemaTable = rdr.GetSchemaTable ();
4385 DataRow row = schemaTable.Rows [0];
4386 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4387 if (ClientVersion > 7)
4388 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4390 Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4395 public void NumericPrecision_Real ()
4397 cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
4399 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4400 DataTable schemaTable = rdr.GetSchemaTable ();
4401 DataRow row = schemaTable.Rows [0];
4402 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4403 if (ClientVersion > 7)
4404 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4406 Assert.AreEqual (7, row ["NumericPrecision"], "Value");
4412 public void NumericPrecision_SmallDateTime ()
4414 cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
4416 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4417 DataTable schemaTable = rdr.GetSchemaTable ();
4418 DataRow row = schemaTable.Rows [0];
4419 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4420 if (ClientVersion > 7)
4421 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4423 Assert.AreEqual (16, row ["NumericPrecision"], "Value");
4428 public void NumericPrecision_SmallInt ()
4430 cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
4432 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4433 DataTable schemaTable = rdr.GetSchemaTable ();
4434 DataRow row = schemaTable.Rows [0];
4435 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4436 if (ClientVersion > 7)
4437 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4439 Assert.AreEqual (5, row ["NumericPrecision"], "Value");
4444 public void NumericPrecision_SmallMoney ()
4446 cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
4448 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4449 DataTable schemaTable = rdr.GetSchemaTable ();
4450 DataRow row = schemaTable.Rows [0];
4451 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4452 if (ClientVersion > 7)
4453 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4455 Assert.AreEqual (10, row ["NumericPrecision"], "Value");
4460 public void NumericPrecision_Text ()
4462 cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
4464 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4465 DataTable schemaTable = rdr.GetSchemaTable ();
4466 DataRow row = schemaTable.Rows [0];
4467 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4468 if (ClientVersion > 7)
4469 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4471 Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4476 public void NumericPrecision_Time ()
4482 public void NumericPrecision_Timestamp ()
4484 cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
4486 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4487 DataTable schemaTable = rdr.GetSchemaTable ();
4488 DataRow row = schemaTable.Rows [0];
4489 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4490 if (ClientVersion > 7)
4491 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4493 Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4498 public void NumericPrecision_TinyInt ()
4500 cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
4502 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4503 DataTable schemaTable = rdr.GetSchemaTable ();
4504 DataRow row = schemaTable.Rows [0];
4505 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4506 if (ClientVersion > 7)
4507 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4509 Assert.AreEqual (3, row ["NumericPrecision"], "Value");
4514 public void NumericPrecision_Udt ()
4520 public void NumericPrecision_UniqueIdentifier ()
4522 cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
4524 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4525 DataTable schemaTable = rdr.GetSchemaTable ();
4526 DataRow row = schemaTable.Rows [0];
4527 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4528 if (ClientVersion > 7)
4529 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4531 Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4536 public void NumericPrecision_VarBinary ()
4538 cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
4540 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4541 DataTable schemaTable = rdr.GetSchemaTable ();
4542 DataRow row = schemaTable.Rows [0];
4543 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4544 if (ClientVersion > 7)
4545 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4547 Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4552 public void NumericPrecision_VarChar ()
4554 cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
4556 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4557 DataTable schemaTable = rdr.GetSchemaTable ();
4558 DataRow row = schemaTable.Rows [0];
4559 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4560 if (ClientVersion > 7)
4561 Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4563 Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4568 public void NumericPrecision_Variant ()
4574 public void NumericPrecision_Xml ()
4580 public void NumericScale_BigInt ()
4582 if (ClientVersion <= 7)
4583 Assert.Ignore ("BigInt data type is not supported.");
4585 cmd.CommandText = "SELECT type_bigint FROM numeric_family WHERE id = 1";
4587 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4588 DataTable schemaTable = rdr.GetSchemaTable ();
4589 DataRow row = schemaTable.Rows [0];
4590 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4591 if (ClientVersion > 7)
4592 Assert.AreEqual (0, row ["NumericScale"], "Value");
4594 Assert.AreEqual (255, row ["NumericScale"], "Value");
4599 public void NumericScale_Binary ()
4601 cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
4603 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4604 DataTable schemaTable = rdr.GetSchemaTable ();
4605 DataRow row = schemaTable.Rows [0];
4606 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4607 if (ClientVersion > 7)
4608 Assert.AreEqual (0, row ["NumericScale"], "Value");
4610 Assert.AreEqual (255, row ["NumericScale"], "Value");
4615 public void NumericScale_Bit ()
4617 cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
4619 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4620 DataTable schemaTable = rdr.GetSchemaTable ();
4621 DataRow row = schemaTable.Rows [0];
4622 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4623 if (ClientVersion > 7)
4624 Assert.AreEqual (0, row ["NumericScale"], "Value");
4626 Assert.AreEqual (255, row ["NumericScale"], "Value");
4631 public void NumericScale_Char ()
4633 cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
4635 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4636 DataTable schemaTable = rdr.GetSchemaTable ();
4637 DataRow row = schemaTable.Rows [0];
4638 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4639 if (ClientVersion > 7)
4640 Assert.AreEqual (0, row ["NumericScale"], "Value");
4642 Assert.AreEqual (255, row ["NumericScale"], "Value");
4647 public void NumericScale_Date ()
4653 public void NumericScale_DateTime ()
4655 cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
4657 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4658 DataTable schemaTable = rdr.GetSchemaTable ();
4659 DataRow row = schemaTable.Rows [0];
4660 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4661 if (ClientVersion > 7)
4662 Assert.AreEqual (0, row ["NumericScale"], "Value");
4664 Assert.AreEqual (3, row ["NumericScale"], "Value");
4669 public void NumericScale_Decimal ()
4671 cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
4673 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4674 DataTable schemaTable = rdr.GetSchemaTable ();
4675 DataRow row = schemaTable.Rows [0];
4676 Assert.IsFalse (row.IsNull ("NumericScale"), "#A:IsNull");
4677 Assert.AreEqual (0, row ["NumericScale"], "#A:Value");
4680 cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
4682 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4683 DataTable schemaTable = rdr.GetSchemaTable ();
4684 DataRow row = schemaTable.Rows [0];
4685 Assert.IsFalse (row.IsNull ("NumericScale"), "#B:IsNull");
4686 Assert.AreEqual (3, row ["NumericScale"], "#B:Value");
4689 cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
4691 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4692 DataTable schemaTable = rdr.GetSchemaTable ();
4693 DataRow row = schemaTable.Rows [0];
4694 Assert.IsFalse (row.IsNull ("NumericScale"), "#C:IsNull");
4695 Assert.AreEqual (0, row ["NumericScale"], "#C:Value");
4698 cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
4700 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4701 DataTable schemaTable = rdr.GetSchemaTable ();
4702 DataRow row = schemaTable.Rows [0];
4703 Assert.IsFalse (row.IsNull ("NumericScale"), "#D:IsNull");
4704 Assert.AreEqual (3, row ["NumericScale"], "#D:Value");
4709 public void NumericScale_Float ()
4711 cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
4713 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4714 DataTable schemaTable = rdr.GetSchemaTable ();
4715 DataRow row = schemaTable.Rows [0];
4716 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4717 if (ClientVersion > 7)
4718 Assert.AreEqual (0, row ["NumericScale"], "Value");
4720 Assert.AreEqual (255, row ["NumericScale"], "Value");
4725 public void NumericScale_Image ()
4727 cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
4729 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4730 DataTable schemaTable = rdr.GetSchemaTable ();
4731 DataRow row = schemaTable.Rows [0];
4732 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4733 if (ClientVersion > 7)
4734 Assert.AreEqual (0, row ["NumericScale"], "Value");
4736 Assert.AreEqual (255, row ["NumericScale"], "Value");
4741 public void NumericScale_Int ()
4743 cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
4745 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4746 DataTable schemaTable = rdr.GetSchemaTable ();
4747 DataRow row = schemaTable.Rows [0];
4748 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4749 if (ClientVersion > 7)
4750 Assert.AreEqual (0, row ["NumericScale"], "Value");
4752 Assert.AreEqual (255, row ["NumericScale"], "Value");
4757 public void NumericScale_Money ()
4759 cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
4761 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4762 DataTable schemaTable = rdr.GetSchemaTable ();
4763 DataRow row = schemaTable.Rows [0];
4764 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4765 if (ClientVersion > 7)
4766 Assert.AreEqual (0, row ["NumericScale"], "Value");
4768 Assert.AreEqual (255, row ["NumericScale"], "Value");
4773 public void NumericScale_NChar ()
4775 cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
4777 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4778 DataTable schemaTable = rdr.GetSchemaTable ();
4779 DataRow row = schemaTable.Rows [0];
4780 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4781 if (ClientVersion > 7)
4782 Assert.AreEqual (0, row ["NumericScale"], "Value");
4784 Assert.AreEqual (255, row ["NumericScale"], "Value");
4789 public void NumericScale_NText ()
4791 cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
4793 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4794 DataTable schemaTable = rdr.GetSchemaTable ();
4795 DataRow row = schemaTable.Rows [0];
4796 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4797 if (ClientVersion > 7)
4798 Assert.AreEqual (0, row ["NumericScale"], "Value");
4800 Assert.AreEqual (255, row ["NumericScale"], "Value");
4805 public void NumericScale_NVarChar ()
4807 cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
4809 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4810 DataTable schemaTable = rdr.GetSchemaTable ();
4811 DataRow row = schemaTable.Rows [0];
4812 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4813 if (ClientVersion > 7)
4814 Assert.AreEqual (0, row ["NumericScale"], "Value");
4816 Assert.AreEqual (255, row ["NumericScale"], "Value");
4821 public void NumericScale_Real ()
4823 cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
4825 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4826 DataTable schemaTable = rdr.GetSchemaTable ();
4827 DataRow row = schemaTable.Rows [0];
4828 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4829 if (ClientVersion > 7)
4830 Assert.AreEqual (0, row ["NumericScale"], "Value");
4832 Assert.AreEqual (255, row ["NumericScale"], "Value");
4838 public void NumericScale_SmallDateTime ()
4840 cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
4842 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4843 DataTable schemaTable = rdr.GetSchemaTable ();
4844 DataRow row = schemaTable.Rows [0];
4845 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4846 Assert.AreEqual (0, row ["NumericScale"], "Value");
4851 public void NumericScale_SmallInt ()
4853 cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
4855 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4856 DataTable schemaTable = rdr.GetSchemaTable ();
4857 DataRow row = schemaTable.Rows [0];
4858 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4859 if (ClientVersion > 7)
4860 Assert.AreEqual (0, row ["NumericScale"], "Value");
4862 Assert.AreEqual (255, row ["NumericScale"], "Value");
4867 public void NumericScale_SmallMoney ()
4869 cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
4871 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4872 DataTable schemaTable = rdr.GetSchemaTable ();
4873 DataRow row = schemaTable.Rows [0];
4874 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4875 if (ClientVersion > 7)
4876 Assert.AreEqual (0, row ["NumericScale"], "Value");
4878 Assert.AreEqual (255, row ["NumericScale"], "Value");
4883 public void NumericScale_Text ()
4885 cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
4887 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4888 DataTable schemaTable = rdr.GetSchemaTable ();
4889 DataRow row = schemaTable.Rows [0];
4890 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4891 if (ClientVersion > 7)
4892 Assert.AreEqual (0, row ["NumericScale"], "Value");
4894 Assert.AreEqual (255, row ["NumericScale"], "Value");
4899 public void NumericScale_Time ()
4905 public void NumericScale_Timestamp ()
4907 cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
4909 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4910 DataTable schemaTable = rdr.GetSchemaTable ();
4911 DataRow row = schemaTable.Rows [0];
4912 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4913 if (ClientVersion > 7)
4914 Assert.AreEqual (0, row ["NumericScale"], "Value");
4916 Assert.AreEqual (255, row ["NumericScale"], "Value");
4921 public void NumericScale_TinyInt ()
4923 cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
4925 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4926 DataTable schemaTable = rdr.GetSchemaTable ();
4927 DataRow row = schemaTable.Rows [0];
4928 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4929 if (ClientVersion > 7)
4930 Assert.AreEqual (0, row ["NumericScale"], "Value");
4932 Assert.AreEqual (255, row ["NumericScale"], "Value");
4937 public void NumericScale_Udt ()
4943 public void NumericScale_UniqueIdentifier ()
4945 cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
4947 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4948 DataTable schemaTable = rdr.GetSchemaTable ();
4949 DataRow row = schemaTable.Rows [0];
4950 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4951 if (ClientVersion > 7)
4952 Assert.AreEqual (0, row ["NumericScale"], "Value");
4954 Assert.AreEqual (255, row ["NumericScale"], "Value");
4959 public void NumericScale_VarBinary ()
4961 cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
4963 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4964 DataTable schemaTable = rdr.GetSchemaTable ();
4965 DataRow row = schemaTable.Rows [0];
4966 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4967 if (ClientVersion > 7)
4968 Assert.AreEqual (0, row ["NumericScale"], "Value");
4970 Assert.AreEqual (255, row ["NumericScale"], "Value");
4975 public void NumericScale_VarChar ()
4977 cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
4979 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4980 DataTable schemaTable = rdr.GetSchemaTable ();
4981 DataRow row = schemaTable.Rows [0];
4982 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4983 if (ClientVersion > 7)
4984 Assert.AreEqual (0, row ["NumericScale"], "Value");
4986 Assert.AreEqual (255, row ["NumericScale"], "Value");
4991 public void NumericScale_Variant ()
4997 public void NumericScale_Xml ()
5003 public void ProviderType_BigInt ()
5005 if (ClientVersion <= 7)
5006 Assert.Ignore ("BigInt data type is not supported.");
5008 cmd.CommandText = "SELECT type_bigint FROM numeric_family WHERE id = 1";
5010 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5011 DataTable schemaTable = rdr.GetSchemaTable ();
5012 DataRow row = schemaTable.Rows [0];
5013 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5014 Assert.AreEqual (0, row ["ProviderType"], "Value");
5019 public void ProviderType_Binary ()
5021 cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
5023 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5024 DataTable schemaTable = rdr.GetSchemaTable ();
5025 DataRow row = schemaTable.Rows [0];
5026 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5027 Assert.AreEqual (1, row ["ProviderType"], "Value");
5032 public void ProviderType_Bit ()
5034 cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
5036 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5037 DataTable schemaTable = rdr.GetSchemaTable ();
5038 DataRow row = schemaTable.Rows [0];
5039 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5040 Assert.AreEqual (2, row ["ProviderType"], "Value");
5045 public void ProviderType_Char ()
5047 cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
5049 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5050 DataTable schemaTable = rdr.GetSchemaTable ();
5051 DataRow row = schemaTable.Rows [0];
5052 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5053 Assert.AreEqual (3, row ["ProviderType"], "Value");
5058 public void ProviderType_Date ()
5064 public void ProviderType_DateTime ()
5066 cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
5068 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5069 DataTable schemaTable = rdr.GetSchemaTable ();
5070 DataRow row = schemaTable.Rows [0];
5071 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5072 Assert.AreEqual (4, row ["ProviderType"], "Value");
5077 public void ProviderType_Decimal ()
5079 cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
5081 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5082 DataTable schemaTable = rdr.GetSchemaTable ();
5083 DataRow row = schemaTable.Rows [0];
5084 Assert.IsFalse (row.IsNull ("ProviderType"), "#A:IsNull");
5085 Assert.AreEqual (5, row ["ProviderType"], "#A:Value");
5088 cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
5090 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5091 DataTable schemaTable = rdr.GetSchemaTable ();
5092 DataRow row = schemaTable.Rows [0];
5093 Assert.IsFalse (row.IsNull ("ProviderType"), "#B:IsNull");
5094 Assert.AreEqual (5, row ["ProviderType"], "#B:Value");
5097 cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
5099 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5100 DataTable schemaTable = rdr.GetSchemaTable ();
5101 DataRow row = schemaTable.Rows [0];
5102 Assert.IsFalse (row.IsNull ("ProviderType"), "#C:IsNull");
5103 Assert.AreEqual (5, row ["ProviderType"], "#C:Value");
5106 cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
5108 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5109 DataTable schemaTable = rdr.GetSchemaTable ();
5110 DataRow row = schemaTable.Rows [0];
5111 Assert.IsFalse (row.IsNull ("ProviderType"), "#D:IsNull");
5112 Assert.AreEqual (5, row ["ProviderType"], "#D:Value");
5117 public void ProviderType_Float ()
5119 cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
5121 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5122 DataTable schemaTable = rdr.GetSchemaTable ();
5123 DataRow row = schemaTable.Rows [0];
5124 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5125 Assert.AreEqual (6, row ["ProviderType"], "Value");
5130 public void ProviderType_Image ()
5132 cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
5134 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5135 DataTable schemaTable = rdr.GetSchemaTable ();
5136 DataRow row = schemaTable.Rows [0];
5137 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5138 Assert.AreEqual (7, row ["ProviderType"], "Value");
5143 public void ProviderType_Int ()
5145 cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
5147 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5148 DataTable schemaTable = rdr.GetSchemaTable ();
5149 DataRow row = schemaTable.Rows [0];
5150 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5151 Assert.AreEqual (8, row ["ProviderType"], "Value");
5156 public void ProviderType_Money ()
5158 cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
5160 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5161 DataTable schemaTable = rdr.GetSchemaTable ();
5162 DataRow row = schemaTable.Rows [0];
5163 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5164 Assert.AreEqual (9, row ["ProviderType"], "Value");
5169 public void ProviderType_NChar ()
5171 cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
5173 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5174 DataTable schemaTable = rdr.GetSchemaTable ();
5175 DataRow row = schemaTable.Rows [0];
5176 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5177 Assert.AreEqual (10, row ["ProviderType"], "Value");
5182 public void ProviderType_NText ()
5184 cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
5186 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5187 DataTable schemaTable = rdr.GetSchemaTable ();
5188 DataRow row = schemaTable.Rows [0];
5189 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5190 Assert.AreEqual (11, row ["ProviderType"], "Value");
5195 public void ProviderType_NVarChar ()
5197 cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
5199 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5200 DataTable schemaTable = rdr.GetSchemaTable ();
5201 DataRow row = schemaTable.Rows [0];
5202 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5203 Assert.AreEqual (12, row ["ProviderType"], "Value");
5208 public void ProviderType_Real ()
5210 cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
5212 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5213 DataTable schemaTable = rdr.GetSchemaTable ();
5214 DataRow row = schemaTable.Rows [0];
5215 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5216 Assert.AreEqual (13, row ["ProviderType"], "Value");
5222 public void ProviderType_SmallDateTime ()
5224 cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
5226 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5227 DataTable schemaTable = rdr.GetSchemaTable ();
5228 DataRow row = schemaTable.Rows [0];
5229 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5230 Assert.AreEqual (15, row ["ProviderType"], "Value");
5235 public void ProviderType_SmallInt ()
5237 cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
5239 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5240 DataTable schemaTable = rdr.GetSchemaTable ();
5241 DataRow row = schemaTable.Rows [0];
5242 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5243 Assert.AreEqual (16, row ["ProviderType"], "Value");
5248 public void ProviderType_SmallMoney ()
5250 cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
5252 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5253 DataTable schemaTable = rdr.GetSchemaTable ();
5254 DataRow row = schemaTable.Rows [0];
5255 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5256 Assert.AreEqual (17, row ["ProviderType"], "Value");
5261 public void ProviderType_Text ()
5263 cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
5265 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5266 DataTable schemaTable = rdr.GetSchemaTable ();
5267 DataRow row = schemaTable.Rows [0];
5268 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5269 Assert.AreEqual (18, row ["ProviderType"], "Value");
5274 public void ProviderType_Time ()
5280 public void ProviderType_Timestamp ()
5282 cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
5284 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5285 DataTable schemaTable = rdr.GetSchemaTable ();
5286 DataRow row = schemaTable.Rows [0];
5287 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5288 // we currently consider timestamp as binary (due to TDS 7.0?)
5289 if (ClientVersion > 7)
5290 Assert.AreEqual (1, row ["ProviderType"], "Value");
5292 Assert.AreEqual (19, row ["ProviderType"], "Value");
5297 public void ProviderType_TinyInt ()
5299 cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
5301 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5302 DataTable schemaTable = rdr.GetSchemaTable ();
5303 DataRow row = schemaTable.Rows [0];
5304 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5305 Assert.AreEqual (20, row ["ProviderType"], "Value");
5310 public void ProviderType_Udt ()
5316 public void ProviderType_UniqueIdentifier ()
5318 cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
5320 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5321 DataTable schemaTable = rdr.GetSchemaTable ();
5322 DataRow row = schemaTable.Rows [0];
5323 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5324 Assert.AreEqual (14, row ["ProviderType"], "Value");
5329 public void ProviderType_VarBinary ()
5331 cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
5333 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5334 DataTable schemaTable = rdr.GetSchemaTable ();
5335 DataRow row = schemaTable.Rows [0];
5336 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5337 Assert.AreEqual (21, row ["ProviderType"], "Value");
5342 public void ProviderType_VarChar ()
5344 cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
5346 using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5347 DataTable schemaTable = rdr.GetSchemaTable ();
5348 DataRow row = schemaTable.Rows [0];
5349 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5350 Assert.AreEqual (22, row ["ProviderType"], "Value");
5355 public void ProviderType_Variant ()
5361 public void ProviderType_Xml ()
5366 private int ClientVersion {
5368 return (engine.ClientVersion);