1 // 2 // OdbcDataReaderTest.cs - NUnit Test Cases for testing the 3 // OdbcDataReader class 4 // 5 // Author: 6 // Sureshkumar T (TSureshkumar@novell.com) 7 // 8 // Copyright (c) 2004 Novell Inc., and the individuals listed 9 // on the ChangeLog entries. 10 // 11 // Permission is hereby granted, free of charge, to any person obtaining 12 // a copy of this software and associated documentation files (the 13 // "Software"), to deal in the Software without restriction, including 14 // without limitation the rights to use, copy, modify, merge, publish, 15 // distribute, sublicense, and/or sell copies of the Software, and to 16 // permit persons to whom the Software is furnished to do so, subject to 17 // the following conditions: 18 // 19 // The above copyright notice and this permission notice shall be 20 // included in all copies or substantial portions of the Software. 21 // 22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 29 // 30 31 #if !NO_ODBC 32 33 using System; 34 using System.Data; 35 using System.Data.Common; 36 using System.Data.Odbc; 37 using System.Globalization; 38 using System.Text; 39 using NUnit.Framework; 40 41 42 namespace MonoTests.System.Data.Connected.Odbc 43 { 44 [TestFixture] 45 [Category ("odbc")] 46 public class OdbcDataReaderTest 47 { 48 static byte [] long_bytes = new byte [] { 49 0x00, 0x66, 0x06, 0x66, 0x97, 0x00, 0x66, 0x06, 0x66, 50 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 51 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 52 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 53 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 54 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 55 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 56 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 57 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 58 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 59 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 60 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 61 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 62 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 63 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 64 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 65 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 66 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 67 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 68 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 69 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 70 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 71 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 72 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 73 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 74 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 75 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 76 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 77 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 78 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 79 0x06, 0x66, 0x06, 0x66, 0x98}; 80 81 OdbcConnection conn; 82 OdbcCommand cmd; 83 84 [SetUp] SetUp()85 public void SetUp () 86 { 87 conn = ConnectionManager.Instance.Odbc.Connection; 88 cmd = conn.CreateCommand (); 89 } 90 91 [TearDown] TearDown()92 public void TearDown () 93 { 94 if (cmd != null) 95 cmd.Dispose (); 96 ConnectionManager.Instance.Close (); 97 } 98 99 [Test] GetBytes()100 public void GetBytes () 101 { 102 cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1"; 103 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult | CommandBehavior.SequentialAccess)) { 104 Assert.IsTrue (reader.Read (), "#C1"); 105 106 long totalsize = reader.GetBytes (0, 0, null, 0, 0); 107 108 byte [] val = new byte [totalsize]; 109 long ret = reader.GetBytes (0, 0L, val, 0, (int) (totalsize * 2)); 110 Assert.AreEqual (totalsize, ret, "#C2"); 111 Assert.AreEqual (new byte [] { 0x32, 0x56, 0x00, 0x44, 0x22 }, val, "#C3"); 112 } 113 114 cmd.CommandText = "SELECT type_blob FROM binary_family where id = 2"; 115 116 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult | CommandBehavior.SequentialAccess)) { 117 Assert.IsTrue (reader.Read (), "#G1"); 118 119 long totalsize = reader.GetBytes (0, 0, null, 0, 0); 120 121 byte [] val = new byte [totalsize]; 122 int offset = 0; 123 long ret = 0; 124 long count = 0; 125 do { 126 ret = reader.GetBytes (0, offset, val, offset, 50); 127 offset += (int) ret; 128 count += ret; 129 } while (count < totalsize); 130 131 Assert.AreEqual (long_bytes.Length, count, "#G2"); 132 Assert.AreEqual (long_bytes, val, "#G3"); 133 } 134 135 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult)) { 136 Assert.IsTrue (reader.Read (), "#H1"); 137 138 long totalsize = reader.GetBytes (0, 0, null, 0, 0); 139 140 byte [] val = new byte [totalsize]; 141 int offset = 0; 142 long ret = 0; 143 long count = 0; 144 do { 145 ret = reader.GetBytes (0, offset, val, offset, 50); 146 offset += (int) ret; 147 count += ret; 148 } while (count < totalsize); 149 150 Assert.AreEqual (long_bytes.Length, count, "#H2"); 151 Assert.AreEqual (long_bytes, val, "#H3"); 152 } 153 } 154 155 [Test] GetBytes_Buffer_TooSmall()156 public void GetBytes_Buffer_TooSmall () 157 { 158 cmd.CommandText = "SELECT type_blob FROM binary_family where id = 2"; 159 160 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult | CommandBehavior.SequentialAccess)) { 161 Assert.IsTrue (reader.Read ()); 162 163 long totalsize = reader.GetBytes (0, 0, null, 0, 0); 164 byte [] val = new byte [totalsize - 1]; 165 166 long ret = reader.GetBytes (0, 0, val, 0, (int) totalsize); 167 Assert.AreEqual (274, ret, "#A1"); 168 for (int i = 0; i < ret; i++) 169 Assert.AreEqual (long_bytes [i], val [i], "#A2:" + i); 170 for (long i = ret; i < val.Length; i++) 171 Assert.AreEqual (0x00, val [i], "#A3:" + i); 172 } 173 174 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult | CommandBehavior.SequentialAccess)) { 175 Assert.IsTrue (reader.Read ()); 176 177 long totalsize = reader.GetBytes (0, 0, null, 0, 0); 178 byte [] val = new byte [totalsize]; 179 int buffer_offset = 1; 180 181 long ret = reader.GetBytes (0, 0, val, buffer_offset, (int) totalsize); 182 Assert.AreEqual (274, ret, "#B1"); 183 Assert.AreEqual (0x00, val [0], "#B2"); 184 for (int i = 0; i < ret; i++) 185 Assert.AreEqual (long_bytes [i], val [i + buffer_offset], "#B2:" + i); 186 for (long i = (ret + buffer_offset); i < val.Length; i++) 187 Assert.AreEqual (0x00, val [i], "#B3:" + i); 188 } 189 190 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult | CommandBehavior.SequentialAccess)) { 191 Assert.IsTrue (reader.Read ()); 192 193 long totalsize = reader.GetBytes (0, 0, null, 0, 0); 194 byte [] val = new byte [totalsize]; 195 196 long ret = reader.GetBytes (0, 0, val, 0, (int) (totalsize + 1)); 197 Assert.AreEqual (totalsize, ret, "#C1"); 198 } 199 200 ConnectionManager.Instance.Odbc.CloseConnection (); 201 } 202 203 [Test] GetBytes_BufferIndex_Negative()204 public void GetBytes_BufferIndex_Negative () 205 { 206 cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1"; 207 208 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { 209 Assert.IsTrue (reader.Read (), "#1"); 210 211 try { 212 reader.GetBytes (0, 0, null, -1, 0); 213 Assert.Fail ("#2"); 214 } catch (ArgumentOutOfRangeException ex) { 215 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#3"); 216 Assert.IsNull (ex.InnerException, "#4"); 217 Assert.IsNotNull (ex.Message, "#5"); 218 Assert.AreEqual ("bufferIndex", ex.ParamName, "#6"); 219 } 220 } 221 } 222 223 [Test] GetBytes_DataIndex_Negative()224 public void GetBytes_DataIndex_Negative () 225 { 226 IDbCommand cmd = conn.CreateCommand (); 227 cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1"; 228 229 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { 230 Assert.IsTrue (reader.Read (), "#A1"); 231 232 try { 233 reader.GetBytes (0, -1L, null, 0, 0); 234 Assert.Fail ("#A2"); 235 } catch (ArgumentOutOfRangeException ex) { 236 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A3"); 237 Assert.IsNull (ex.InnerException, "#A4"); 238 Assert.IsNotNull (ex.Message, "#A5"); 239 Assert.AreEqual ("dataIndex", ex.ParamName, "#A6"); 240 } 241 } 242 243 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult)) { 244 Assert.IsTrue (reader.Read (), "#B1"); 245 246 try { 247 reader.GetBytes (0, -1L, null, 0, 0); 248 Assert.Fail ("#B2"); 249 } catch (ArgumentOutOfRangeException ex) { 250 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B3"); 251 Assert.IsNull (ex.InnerException, "#B4"); 252 Assert.IsNotNull (ex.Message, "#B5"); 253 Assert.AreEqual ("dataIndex", ex.ParamName, "#B6"); 254 } 255 } 256 } 257 258 [Test] GetBytes_Length_Negative()259 public void GetBytes_Length_Negative () 260 { 261 cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1"; 262 263 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { 264 Assert.IsTrue (reader.Read (), "#1"); 265 266 try { 267 reader.GetBytes (0, 0, null, 0, -1); 268 Assert.Fail ("#2"); 269 } catch (ArgumentOutOfRangeException ex) { 270 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#3"); 271 Assert.IsNull (ex.InnerException, "#4"); 272 Assert.IsNotNull (ex.Message, "#5"); 273 Assert.AreEqual ("length", ex.ParamName, "#6"); 274 } 275 } 276 } 277 278 [Test] GetSchemaTable()279 public void GetSchemaTable () 280 { 281 IDataReader reader = null; 282 DataTable schema; 283 DataRow pkRow; 284 285 try { 286 cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee"; 287 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo); 288 schema = reader.GetSchemaTable (); 289 reader.Close (); 290 291 AssertSchemaTableStructure (schema, "#A:"); 292 Assert.AreEqual (3, schema.Rows.Count, "#A:RowCount"); 293 pkRow = schema.Select ("ColumnName = 'id'") [0]; 294 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#A:ColumnName_IsNull"); 295 Assert.AreEqual ("id", pkRow ["ColumnName"], "#A:ColumnName_Value"); 296 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#A:ColumnOrdinal_IsNull"); 297 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#A:ColumnOrdinal_Value"); 298 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#A:ColumnSize_IsNull"); 299 Assert.AreEqual (4, pkRow ["ColumnSize"], "#A:ColumnSize_Value"); 300 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#A:NumericPrecision_IsNull"); 301 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#A:NumericPrecision_Value"); 302 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#A:NumericScale_IsNull"); 303 Assert.AreEqual (0, pkRow ["NumericScale"], "#A:NumericScale_Value"); 304 Assert.IsFalse (pkRow.IsNull ("DataType"), "#A:DataType_IsNull"); 305 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#A:DataType_Value"); 306 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#A:ProviderType_IsNull"); 307 Assert.AreEqual (10, pkRow ["ProviderType"], "#A:ProviderType_Value"); 308 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#A:IsLong_IsNull"); 309 Assert.AreEqual (false, pkRow ["IsLong"], "#A:IsLong_Value"); 310 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#A:AllowDBNull_IsNull"); 311 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#A:AllowDBNull_Value"); 312 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#A:IsReadOnly_IsNull"); 313 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#A:IsReadOnly_Value"); 314 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#A:IsRowVersion_IsNull"); 315 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#A:IsRowVersion_Value"); 316 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#A:IsUnique_IsNull"); 317 Assert.AreEqual (true, pkRow ["IsUnique"], "#A:IsUnique_Value"); 318 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#A:IsKey_IsNull"); 319 Assert.AreEqual (true, pkRow ["IsKey"], "#A:IsKey_Value"); 320 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#A:IsAutoIncrement_IsNull"); 321 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#A:IsAutoIncrement_Value"); 322 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#A:BaseSchemaName_IsNull"); 323 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#A:BaseSchemaName_Value"); 324 Assert.IsFalse (pkRow.IsNull ("BaseCatalogName"), "#A:BaseCatalogName_IsNull"); 325 Assert.AreEqual (ConnectionManager.Instance.DatabaseName, pkRow ["BaseCatalogName"], "#A:BaseCatalogName_Value"); 326 Assert.IsFalse (pkRow.IsNull ("BaseTableName"), "#A:BaseTableName_IsNull"); 327 Assert.AreEqual ("employee", pkRow ["BaseTableName"], "#A:BaseTableName_Value"); 328 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#A:BaseColumnName_IsNull"); 329 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#A:BaseColumnName_Value"); 330 331 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly); 332 schema = reader.GetSchemaTable (); 333 reader.Close (); 334 335 AssertSchemaTableStructure (schema, "#B:"); 336 Assert.AreEqual (3, schema.Rows.Count, "#B:RowCount"); 337 pkRow = schema.Select ("ColumnName = 'id'") [0]; 338 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#B:ColumnName_IsNull"); 339 Assert.AreEqual ("id", pkRow ["ColumnName"], "#B:ColumnName_Value"); 340 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#B:ColumnOrdinal_IsNull"); 341 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#B:ColumnOrdinal_Value"); 342 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#B:ColumnSize_IsNull"); 343 Assert.AreEqual (4, pkRow ["ColumnSize"], "#B:ColumnSize_Value"); 344 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#B:NumericPrecision_IsNull"); 345 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#B:NumericPrecision_Value"); 346 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#B:NumericScale_IsNull"); 347 Assert.AreEqual (0, pkRow ["NumericScale"], "#B:NumericScale_Value"); 348 Assert.IsFalse (pkRow.IsNull ("DataType"), "#B:DataType_IsNull"); 349 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#B:DataType_Value"); 350 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#B:ProviderType_IsNull"); 351 Assert.AreEqual (10, pkRow ["ProviderType"], "#B:ProviderType_Value"); 352 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#B:IsLong_IsNull"); 353 Assert.AreEqual (false, pkRow ["IsLong"], "#B:IsLong_Value"); 354 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#B:AllowDBNull_IsNull"); 355 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#B:AllowDBNull_Value"); 356 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#B:IsReadOnly_IsNull"); 357 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#B:IsReadOnly_Value"); 358 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#B:IsRowVersion_IsNull"); 359 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#B:IsRowVersion_Value"); 360 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#B:IsUnique_IsNull"); 361 Assert.AreEqual (false, pkRow ["IsUnique"], "#B:IsUnique_Value"); 362 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#B:IsKey_IsNull"); 363 Assert.AreEqual (false, pkRow ["IsKey"], "#B:IsKey_Value"); 364 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#B:IsAutoIncrement_IsNull"); 365 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#B:IsAutoIncrement_Value"); 366 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#B:BaseSchemaName_IsNull"); 367 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#B:BaseSchemaName_Value"); 368 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#B:BaseCatalogName_IsNull"); 369 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#B:BaseCatalogName_Value"); 370 Assert.IsTrue (pkRow.IsNull ("BaseTableName"), "#B:BaseTableName_IsNull"); 371 Assert.AreEqual (DBNull.Value, pkRow ["BaseTableName"], "#B:BaseTableName_Value"); 372 Assert.IsTrue (pkRow.IsNull ("BaseColumnName"), "#B:BaseColumnName_IsNull"); 373 Assert.AreEqual (DBNull.Value, pkRow ["BaseColumnName"], "#B:BaseColumnName_Value"); 374 375 reader = cmd.ExecuteReader (CommandBehavior.KeyInfo); 376 schema = reader.GetSchemaTable (); 377 reader.Close (); 378 379 AssertSchemaTableStructure (schema, "#C:"); 380 Assert.AreEqual (3, schema.Rows.Count, "#C:RowCount"); 381 pkRow = schema.Select ("ColumnName = 'id'") [0]; 382 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#C:ColumnName_IsNull"); 383 Assert.AreEqual ("id", pkRow ["ColumnName"], "#C:ColumnName_Value"); 384 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#C:ColumnOrdinal_IsNull"); 385 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#C:ColumnOrdinal_Value"); 386 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#C:ColumnSize_IsNull"); 387 Assert.AreEqual (4, pkRow ["ColumnSize"], "#C:ColumnSize_Value"); 388 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#C:NumericPrecision_IsNull"); 389 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#C:NumericPrecision_Value"); 390 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#C:NumericScale_IsNull"); 391 Assert.AreEqual (0, pkRow ["NumericScale"], "#C:NumericScale_Value"); 392 Assert.IsFalse (pkRow.IsNull ("DataType"), "#C:DataType_IsNull"); 393 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#C:DataType_Value"); 394 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#C:ProviderType_IsNull"); 395 Assert.AreEqual (10, pkRow ["ProviderType"], "#C:ProviderType_Value"); 396 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#C:IsLong_IsNull"); 397 Assert.AreEqual (false, pkRow ["IsLong"], "#C:IsLong_Value"); 398 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#C:AllowDBNull_IsNull"); 399 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#C:AllowDBNull_Value"); 400 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#C:IsReadOnly_IsNull"); 401 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#C:IsReadOnly_Value"); 402 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#C:IsRowVersion_IsNull"); 403 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#C:IsRowVersion_Value"); 404 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#C:IsUnique_IsNull"); 405 Assert.AreEqual (true, pkRow ["IsUnique"], "#C:IsUnique_Value"); 406 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#C:IsKey_IsNull"); 407 Assert.AreEqual (true, pkRow ["IsKey"], "#C:IsKey_Value"); 408 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#C:IsAutoIncrement_IsNull"); 409 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#C:IsAutoIncrement_Value"); 410 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#C:BaseSchemaName_IsNull"); 411 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#C:BaseSchemaName_Value"); 412 Assert.IsFalse (pkRow.IsNull ("BaseCatalogName"), "#C:BaseCatalogName_IsNull"); 413 Assert.AreEqual (ConnectionManager.Instance.DatabaseName, pkRow ["BaseCatalogName"], "#C:BaseCatalogName_Value"); 414 Assert.IsFalse (pkRow.IsNull ("BaseTableName"), "#C:BaseTableName_IsNull"); 415 Assert.AreEqual ("employee", pkRow ["BaseTableName"], "#C:BaseTableName_Value"); 416 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#C:BaseColumnName_IsNull"); 417 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#C:BaseColumnName_Value"); 418 419 reader = cmd.ExecuteReader (); 420 schema = reader.GetSchemaTable (); 421 reader.Close (); 422 423 AssertSchemaTableStructure (schema, "#D:"); 424 Assert.AreEqual (3, schema.Rows.Count, "#D:RowCount"); 425 pkRow = schema.Select ("ColumnName = 'id'") [0]; 426 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#D:ColumnName_IsNull"); 427 Assert.AreEqual ("id", pkRow ["ColumnName"], "#D:ColumnName_Value"); 428 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#D:ColumnOrdinal_IsNull"); 429 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#D:ColumnOrdinal_Value"); 430 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#D:ColumnSize_IsNull"); 431 Assert.AreEqual (4, pkRow ["ColumnSize"], "#D:ColumnSize_Value"); 432 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#D:NumericPrecision_IsNull"); 433 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#D:NumericPrecision_Value"); 434 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#D:NumericScale_IsNull"); 435 Assert.AreEqual (0, pkRow ["NumericScale"], "#D:NumericScale_Value"); 436 Assert.IsFalse (pkRow.IsNull ("DataType"), "#D:DataType_IsNull"); 437 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#D:DataType_Value"); 438 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#D:ProviderType_IsNull"); 439 Assert.AreEqual (10, pkRow ["ProviderType"], "#D:ProviderType_Value"); 440 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#D:IsLong_IsNull"); 441 Assert.AreEqual (false, pkRow ["IsLong"], "#D:IsLong_Value"); 442 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#D:AllowDBNull_IsNull"); 443 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#D:AllowDBNull_Value"); 444 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#D:IsReadOnly_IsNull"); 445 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#D:IsReadOnly_Value"); 446 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#D:IsRowVersion_IsNull"); 447 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#D:IsRowVersion_Value"); 448 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#D:IsUnique_IsNull"); 449 Assert.AreEqual (false, pkRow ["IsUnique"], "#D:IsUnique_Value"); 450 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#D:IsKey_IsNull"); 451 Assert.AreEqual (false, pkRow ["IsKey"], "#D:IsKey_Value"); 452 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#D:IsAutoIncrement_IsNull"); 453 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#D:IsAutoIncrement_Value"); 454 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#D:BaseSchemaName_IsNull"); 455 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#D:BaseSchemaName_Value"); 456 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#D:BaseCatalogName_IsNull"); 457 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#D:BaseCatalogName_Value"); 458 Assert.IsTrue (pkRow.IsNull ("BaseTableName"), "#D:BaseTableName_IsNull"); 459 Assert.AreEqual (DBNull.Value, pkRow ["BaseTableName"], "#D:BaseTableName_Value"); 460 Assert.IsTrue (pkRow.IsNull ("BaseColumnName"), "#D:BaseColumnName_IsNull"); 461 Assert.AreEqual (DBNull.Value, pkRow ["BaseColumnName"], "#D:BaseColumnName_Value"); 462 463 cmd = conn.CreateCommand (); 464 cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee"; 465 cmd.Prepare (); 466 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo); 467 schema = reader.GetSchemaTable (); 468 reader.Close (); 469 470 AssertSchemaTableStructure (schema, "#E:"); 471 Assert.AreEqual (3, schema.Rows.Count, "#E:RowCount"); 472 pkRow = schema.Select ("ColumnName = 'id'") [0]; 473 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#E:ColumnName_IsNull"); 474 Assert.AreEqual ("id", pkRow ["ColumnName"], "#E:ColumnName_Value"); 475 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#E:ColumnOrdinal_IsNull"); 476 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#E:ColumnOrdinal_Value"); 477 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#E:ColumnSize_IsNull"); 478 Assert.AreEqual (4, pkRow ["ColumnSize"], "#E:ColumnSize_Value"); 479 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#E:NumericPrecision_IsNull"); 480 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#E:NumericPrecision_Value"); 481 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#E:NumericScale_IsNull"); 482 Assert.AreEqual (0, pkRow ["NumericScale"], "#E:NumericScale_Value"); 483 Assert.IsFalse (pkRow.IsNull ("DataType"), "#E:DataType_IsNull"); 484 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#E:DataType_Value"); 485 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#E:ProviderType_IsNull"); 486 Assert.AreEqual (10, pkRow ["ProviderType"], "#E:ProviderType_Value"); 487 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#E:IsLong_IsNull"); 488 Assert.AreEqual (false, pkRow ["IsLong"], "#E:IsLong_Value"); 489 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#E:AllowDBNull_IsNull"); 490 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#E:AllowDBNull_Value"); 491 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#E:IsReadOnly_IsNull"); 492 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#E:IsReadOnly_Value"); 493 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#E:IsRowVersion_IsNull"); 494 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#E:IsRowVersion_Value"); 495 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#E:IsUnique_IsNull"); 496 Assert.AreEqual (true, pkRow ["IsUnique"], "#E:IsUnique_Value"); 497 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#E:IsKey_IsNull"); 498 Assert.AreEqual (true, pkRow ["IsKey"], "#E:IsKey_Value"); 499 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#E:IsAutoIncrement_IsNull"); 500 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#E:IsAutoIncrement_Value"); 501 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#E:BaseSchemaName_IsNull"); 502 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#E:BaseSchemaName_Value"); 503 Assert.IsFalse (pkRow.IsNull ("BaseCatalogName"), "#E:BaseCatalogName_IsNull"); 504 Assert.AreEqual (ConnectionManager.Instance.DatabaseName, pkRow ["BaseCatalogName"], "#E:BaseCatalogName_Value"); 505 Assert.IsFalse (pkRow.IsNull ("BaseTableName"), "#E:BaseTableName_IsNull"); 506 Assert.AreEqual ("employee", pkRow ["BaseTableName"], "#E:BaseTableName_Value"); 507 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#E:BaseColumnName_IsNull"); 508 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#E:BaseColumnName_Value"); 509 510 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly); 511 schema = reader.GetSchemaTable (); 512 reader.Close (); 513 514 AssertSchemaTableStructure (schema, "#F:"); 515 Assert.AreEqual (3, schema.Rows.Count, "#F:RowCount"); 516 pkRow = schema.Select ("ColumnName = 'id'") [0]; 517 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#F:ColumnName_IsNull"); 518 Assert.AreEqual ("id", pkRow ["ColumnName"], "#F:ColumnName_Value"); 519 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#F:ColumnOrdinal_IsNull"); 520 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#F:ColumnOrdinal_Value"); 521 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#F:ColumnSize_IsNull"); 522 Assert.AreEqual (4, pkRow ["ColumnSize"], "#F:ColumnSize_Value"); 523 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#F:NumericPrecision_IsNull"); 524 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#F:NumericPrecision_Value"); 525 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#F:NumericScale_IsNull"); 526 Assert.AreEqual (0, pkRow ["NumericScale"], "#F:NumericScale_Value"); 527 Assert.IsFalse (pkRow.IsNull ("DataType"), "#F:DataType_IsNull"); 528 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#F:DataType_Value"); 529 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#F:ProviderType_IsNull"); 530 Assert.AreEqual (10, pkRow ["ProviderType"], "#F:ProviderType_Value"); 531 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#F:IsLong_IsNull"); 532 Assert.AreEqual (false, pkRow ["IsLong"], "#F:IsLong_Value"); 533 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#F:AllowDBNull_IsNull"); 534 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#F:AllowDBNull_Value"); 535 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#F:IsReadOnly_IsNull"); 536 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#F:IsReadOnly_Value"); 537 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#F:IsRowVersion_IsNull"); 538 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#F:IsRowVersion_Value"); 539 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#F:IsUnique_IsNull"); 540 Assert.AreEqual (false, pkRow ["IsUnique"], "#F:IsUnique_Value"); 541 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#F:IsKey_IsNull"); 542 Assert.AreEqual (false, pkRow ["IsKey"], "#F:IsKey_Value"); 543 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#F:IsAutoIncrement_IsNull"); 544 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#F:IsAutoIncrement_Value"); 545 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#F:BaseSchemaName_IsNull"); 546 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#F:BaseSchemaName_Value"); 547 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#F:BaseCatalogName_IsNull"); 548 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#F:BaseCatalogName_Value"); 549 Assert.IsTrue (pkRow.IsNull ("BaseTableName"), "#F:BaseTableName_IsNull"); 550 Assert.AreEqual (DBNull.Value, pkRow ["BaseTableName"], "#F:BaseTableName_Value"); 551 Assert.IsTrue (pkRow.IsNull ("BaseColumnName"), "#F:BaseColumnName_IsNull"); 552 Assert.AreEqual (DBNull.Value, pkRow ["BaseColumnName"], "#F:BaseColumnName_Value"); 553 554 reader = cmd.ExecuteReader (CommandBehavior.KeyInfo); 555 schema = reader.GetSchemaTable (); 556 reader.Close (); 557 558 AssertSchemaTableStructure (schema, "#G:"); 559 Assert.AreEqual (3, schema.Rows.Count, "#G:RowCount"); 560 pkRow = schema.Select ("ColumnName = 'id'") [0]; 561 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#G:ColumnName_IsNull"); 562 Assert.AreEqual ("id", pkRow ["ColumnName"], "#G:ColumnName_Value"); 563 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#G:ColumnOrdinal_IsNull"); 564 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#G:ColumnOrdinal_Value"); 565 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#G:ColumnSize_IsNull"); 566 Assert.AreEqual (4, pkRow ["ColumnSize"], "#G:ColumnSize_Value"); 567 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#G:NumericPrecision_IsNull"); 568 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#G:NumericPrecision_Value"); 569 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#G:NumericScale_IsNull"); 570 Assert.AreEqual (0, pkRow ["NumericScale"], "#G:NumericScale_Value"); 571 Assert.IsFalse (pkRow.IsNull ("DataType"), "#G:DataType_IsNull"); 572 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#G:DataType_Value"); 573 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#G:ProviderType_IsNull"); 574 Assert.AreEqual (10, pkRow ["ProviderType"], "#G:ProviderType_Value"); 575 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#G:IsLong_IsNull"); 576 Assert.AreEqual (false, pkRow ["IsLong"], "#G:IsLong_Value"); 577 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#G:AllowDBNull_IsNull"); 578 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#G:AllowDBNull_Value"); 579 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#G:IsReadOnly_IsNull"); 580 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#G:IsReadOnly_Value"); 581 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#G:IsRowVersion_IsNull"); 582 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#G:IsRowVersion_Value"); 583 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#G:IsUnique_IsNull"); 584 Assert.AreEqual (true, pkRow ["IsUnique"], "#G:IsUnique_Value"); 585 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#G:IsKey_IsNull"); 586 Assert.AreEqual (true, pkRow ["IsKey"], "#G:IsKey_Value"); 587 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#G:IsAutoIncrement_IsNull"); 588 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#G:IsAutoIncrement_Value"); 589 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#G:BaseSchemaName_IsNull"); 590 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#G:BaseSchemaName_Value"); 591 Assert.IsFalse (pkRow.IsNull ("BaseCatalogName"), "#G:BaseCatalogName_IsNull"); 592 Assert.AreEqual (ConnectionManager.Instance.DatabaseName, pkRow ["BaseCatalogName"], "#G:BaseCatalogName_Value"); 593 Assert.IsFalse (pkRow.IsNull ("BaseTableName"), "#G:BaseTableName_IsNull"); 594 Assert.AreEqual ("employee", pkRow ["BaseTableName"], "#G:BaseTableName_Value"); 595 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#G:BaseColumnName_IsNull"); 596 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#G:BaseColumnName_Value"); 597 598 reader = cmd.ExecuteReader (); 599 schema = reader.GetSchemaTable (); 600 reader.Close (); 601 602 AssertSchemaTableStructure (schema, "#H:"); 603 Assert.AreEqual (3, schema.Rows.Count, "#H:RowCount"); 604 pkRow = schema.Select ("ColumnName = 'id'") [0]; 605 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#H:ColumnName_IsNull"); 606 Assert.AreEqual ("id", pkRow ["ColumnName"], "#H:ColumnName_Value"); 607 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#H:ColumnOrdinal_IsNull"); 608 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#H:ColumnOrdinal_Value"); 609 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#H:ColumnSize_IsNull"); 610 Assert.AreEqual (4, pkRow ["ColumnSize"], "#H:ColumnSize_Value"); 611 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#H:NumericPrecision_IsNull"); 612 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#H:NumericPrecision_Value"); 613 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#H:NumericScale_IsNull"); 614 Assert.AreEqual (0, pkRow ["NumericScale"], "#H:NumericScale_Value"); 615 Assert.IsFalse (pkRow.IsNull ("DataType"), "#H:DataType_IsNull"); 616 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#H:DataType_Value"); 617 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#H:ProviderType_IsNull"); 618 Assert.AreEqual (10, pkRow ["ProviderType"], "#H:ProviderType_Value"); 619 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#H:IsLong_IsNull"); 620 Assert.AreEqual (false, pkRow ["IsLong"], "#H:IsLong_Value"); 621 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#H:AllowDBNull_IsNull"); 622 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#H:AllowDBNull_Value"); 623 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#H:IsReadOnly_IsNull"); 624 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#H:IsReadOnly_Value"); 625 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#H:IsRowVersion_IsNull"); 626 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#H:IsRowVersion_Value"); 627 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#H:IsUnique_IsNull"); 628 Assert.AreEqual (false, pkRow ["IsUnique"], "#H:IsUnique_Value"); 629 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#H:IsKey_IsNull"); 630 Assert.AreEqual (false, pkRow ["IsKey"], "#H:IsKey_Value"); 631 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#H:IsAutoIncrement_IsNull"); 632 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#H:IsAutoIncrement_Value"); 633 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#H:BaseSchemaName_IsNull"); 634 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#H:BaseSchemaName_Value"); 635 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#H:BaseCatalogName_IsNull"); 636 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#H:BaseCatalogName_Value"); 637 Assert.IsTrue (pkRow.IsNull ("BaseTableName"), "#H:BaseTableName_IsNull"); 638 Assert.AreEqual (DBNull.Value, pkRow ["BaseTableName"], "#H:BaseTableName_Value"); 639 Assert.IsTrue (pkRow.IsNull ("BaseColumnName"), "#H:BaseColumnName_IsNull"); 640 Assert.AreEqual (DBNull.Value, pkRow ["BaseColumnName"], "#H:BaseColumnName_Value"); 641 642 cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee where id = ?"; 643 IDbDataParameter param = cmd.CreateParameter (); 644 cmd.Parameters.Add (param); 645 param.DbType = DbType.Int32; 646 param.Value = 2; 647 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo); 648 schema = reader.GetSchemaTable (); 649 reader.Close (); 650 651 AssertSchemaTableStructure (schema, "#I:"); 652 Assert.AreEqual (3, schema.Rows.Count, "#I:RowCount"); 653 pkRow = schema.Select ("ColumnName = 'id'") [0]; 654 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#I:ColumnName_IsNull"); 655 Assert.AreEqual ("id", pkRow ["ColumnName"], "#I:ColumnName_Value"); 656 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#I:ColumnOrdinal_IsNull"); 657 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#I:ColumnOrdinal_Value"); 658 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#I:ColumnSize_IsNull"); 659 Assert.AreEqual (4, pkRow ["ColumnSize"], "#I:ColumnSize_Value"); 660 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#I:NumericPrecision_IsNull"); 661 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#I:NumericPrecision_Value"); 662 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#I:NumericScale_IsNull"); 663 Assert.AreEqual (0, pkRow ["NumericScale"], "#I:NumericScale_Value"); 664 Assert.IsFalse (pkRow.IsNull ("DataType"), "#I:DataType_IsNull"); 665 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#I:DataType_Value"); 666 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#I:ProviderType_IsNull"); 667 Assert.AreEqual (10, pkRow ["ProviderType"], "#I:ProviderType_Value"); 668 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#I:IsLong_IsNull"); 669 Assert.AreEqual (false, pkRow ["IsLong"], "#I:IsLong_Value"); 670 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#I:AllowDBNull_IsNull"); 671 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#I:AllowDBNull_Value"); 672 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#I:IsReadOnly_IsNull"); 673 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#I:IsReadOnly_Value"); 674 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#I:IsRowVersion_IsNull"); 675 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#I:IsRowVersion_Value"); 676 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#I:IsUnique_IsNull"); 677 Assert.AreEqual (true, pkRow ["IsUnique"], "#I:IsUnique_Value"); 678 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#I:IsKey_IsNull"); 679 Assert.AreEqual (true, pkRow ["IsKey"], "#I:IsKey_Value"); 680 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#I:IsAutoIncrement_IsNull"); 681 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#I:IsAutoIncrement_Value"); 682 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#I:BaseSchemaName_IsNull"); 683 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#I:BaseSchemaName_Value"); 684 Assert.IsFalse (pkRow.IsNull ("BaseCatalogName"), "#I:BaseCatalogName_IsNull"); 685 Assert.AreEqual (ConnectionManager.Instance.DatabaseName, pkRow ["BaseCatalogName"], "#I:BaseCatalogName_Value"); 686 Assert.IsFalse (pkRow.IsNull ("BaseTableName"), "#I:BaseTableName_IsNull"); 687 Assert.AreEqual ("employee", pkRow ["BaseTableName"], "#I:BaseTableName_Value"); 688 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#I:BaseColumnName_IsNull"); 689 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#I:BaseColumnName_Value"); 690 691 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly); 692 schema = reader.GetSchemaTable (); 693 reader.Close (); 694 695 AssertSchemaTableStructure (schema, "#J:"); 696 Assert.AreEqual (3, schema.Rows.Count, "#J:RowCount"); 697 pkRow = schema.Select ("ColumnName = 'id'") [0]; 698 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#J:ColumnName_IsNull"); 699 Assert.AreEqual ("id", pkRow ["ColumnName"], "#J:ColumnName_Value"); 700 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#J:ColumnOrdinal_IsNull"); 701 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#J:ColumnOrdinal_Value"); 702 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#J:ColumnSize_IsNull"); 703 Assert.AreEqual (4, pkRow ["ColumnSize"], "#J:ColumnSize_Value"); 704 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#J:NumericPrecision_IsNull"); 705 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#J:NumericPrecision_Value"); 706 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#J:NumericScale_IsNull"); 707 Assert.AreEqual (0, pkRow ["NumericScale"], "#J:NumericScale_Value"); 708 Assert.IsFalse (pkRow.IsNull ("DataType"), "#J:DataType_IsNull"); 709 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#J:DataType_Value"); 710 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#J:ProviderType_IsNull"); 711 Assert.AreEqual (10, pkRow ["ProviderType"], "#J:ProviderType_Value"); 712 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#J:IsLong_IsNull"); 713 Assert.AreEqual (false, pkRow ["IsLong"], "#J:IsLong_Value"); 714 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#J:AllowDBNull_IsNull"); 715 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#J:AllowDBNull_Value"); 716 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#J:IsReadOnly_IsNull"); 717 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#J:IsReadOnly_Value"); 718 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#J:IsRowVersion_IsNull"); 719 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#J:IsRowVersion_Value"); 720 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#J:IsUnique_IsNull"); 721 Assert.AreEqual (false, pkRow ["IsUnique"], "#J:IsUnique_Value"); 722 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#J:IsKey_IsNull"); 723 Assert.AreEqual (false, pkRow ["IsKey"], "#J:IsKey_Value"); 724 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#J:IsAutoIncrement_IsNull"); 725 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#J:IsAutoIncrement_Value"); 726 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#J:BaseSchemaName_IsNull"); 727 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#J:BaseSchemaName_Value"); 728 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#J:BaseCatalogName_IsNull"); 729 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#J:BaseCatalogName_Value"); 730 Assert.IsTrue (pkRow.IsNull ("BaseTableName"), "#J:BaseTableName_IsNull"); 731 Assert.AreEqual (DBNull.Value, pkRow ["BaseTableName"], "#J:BaseTableName_Value"); 732 Assert.IsTrue (pkRow.IsNull ("BaseColumnName"), "#J:BaseColumnName_IsNull"); 733 Assert.AreEqual (DBNull.Value, pkRow ["BaseColumnName"], "#J:BaseColumnName_Value"); 734 735 reader = cmd.ExecuteReader (CommandBehavior.KeyInfo); 736 schema = reader.GetSchemaTable (); 737 reader.Close (); 738 739 AssertSchemaTableStructure (schema, "#K:"); 740 Assert.AreEqual (3, schema.Rows.Count, "#K:RowCount"); 741 pkRow = schema.Select ("ColumnName = 'id'") [0]; 742 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#K:ColumnName_IsNull"); 743 Assert.AreEqual ("id", pkRow ["ColumnName"], "#K:ColumnName_Value"); 744 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#K:ColumnOrdinal_IsNull"); 745 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#K:ColumnOrdinal_Value"); 746 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#K:ColumnSize_IsNull"); 747 Assert.AreEqual (4, pkRow ["ColumnSize"], "#K:ColumnSize_Value"); 748 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#K:NumericPrecision_IsNull"); 749 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#K:NumericPrecision_Value"); 750 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#K:NumericScale_IsNull"); 751 Assert.AreEqual (0, pkRow ["NumericScale"], "#K:NumericScale_Value"); 752 Assert.IsFalse (pkRow.IsNull ("DataType"), "#K:DataType_IsNull"); 753 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#K:DataType_Value"); 754 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#K:ProviderType_IsNull"); 755 Assert.AreEqual (10, pkRow ["ProviderType"], "#K:ProviderType_Value"); 756 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#K:IsLong_IsNull"); 757 Assert.AreEqual (false, pkRow ["IsLong"], "#K:IsLong_Value"); 758 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#K:AllowDBNull_IsNull"); 759 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#K:AllowDBNull_Value"); 760 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#K:IsReadOnly_IsNull"); 761 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#K:IsReadOnly_Value"); 762 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#K:IsRowVersion_IsNull"); 763 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#K:IsRowVersion_Value"); 764 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#K:IsUnique_IsNull"); 765 Assert.AreEqual (true, pkRow ["IsUnique"], "#K:IsUnique_Value"); 766 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#K:IsKey_IsNull"); 767 Assert.AreEqual (true, pkRow ["IsKey"], "#K:IsKey_Value"); 768 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#K:IsAutoIncrement_IsNull"); 769 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#K:IsAutoIncrement_Value"); 770 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#K:BaseSchemaName_IsNull"); 771 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#K:BaseSchemaName_Value"); 772 Assert.IsFalse (pkRow.IsNull ("BaseCatalogName"), "#K:BaseCatalogName_IsNull"); 773 Assert.AreEqual (ConnectionManager.Instance.DatabaseName, pkRow ["BaseCatalogName"], "#K:BaseCatalogName_Value"); 774 Assert.IsFalse (pkRow.IsNull ("BaseTableName"), "#K:BaseTableName_IsNull"); 775 Assert.AreEqual ("employee", pkRow ["BaseTableName"], "#K:BaseTableName_Value"); 776 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#K:BaseColumnName_IsNull"); 777 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#K:BaseColumnName_Value"); 778 779 reader = cmd.ExecuteReader (); 780 schema = reader.GetSchemaTable (); 781 reader.Close (); 782 783 AssertSchemaTableStructure (schema, "#L:"); 784 Assert.AreEqual (3, schema.Rows.Count, "#L:RowCount"); 785 pkRow = schema.Select ("ColumnName = 'id'") [0]; 786 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#L:ColumnName_IsNull"); 787 Assert.AreEqual ("id", pkRow ["ColumnName"], "#L:ColumnName_Value"); 788 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#L:ColumnOrdinal_IsNull"); 789 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#L:ColumnOrdinal_Value"); 790 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#L:ColumnSize_IsNull"); 791 Assert.AreEqual (4, pkRow ["ColumnSize"], "#L:ColumnSize_Value"); 792 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#L:NumericPrecision_IsNull"); 793 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#L:NumericPrecision_Value"); 794 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#L:NumericScale_IsNull"); 795 Assert.AreEqual (0, pkRow ["NumericScale"], "#L:NumericScale_Value"); 796 Assert.IsFalse (pkRow.IsNull ("DataType"), "#L:DataType_IsNull"); 797 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#L:DataType_Value"); 798 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#L:ProviderType_IsNull"); 799 Assert.AreEqual (10, pkRow ["ProviderType"], "#L:ProviderType_Value"); 800 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#L:IsLong_IsNull"); 801 Assert.AreEqual (false, pkRow ["IsLong"], "#L:IsLong_Value"); 802 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#L:AllowDBNull_IsNull"); 803 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#L:AllowDBNull_Value"); 804 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#L:IsReadOnly_IsNull"); 805 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#L:IsReadOnly_Value"); 806 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#L:IsRowVersion_IsNull"); 807 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#L:IsRowVersion_Value"); 808 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#L:IsUnique_IsNull"); 809 Assert.AreEqual (false, pkRow ["IsUnique"], "#L:IsUnique_Value"); 810 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#L:IsKey_IsNull"); 811 Assert.AreEqual (false, pkRow ["IsKey"], "#L:IsKey_Value"); 812 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#L:IsAutoIncrement_IsNull"); 813 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#L:IsAutoIncrement_Value"); 814 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#L:BaseSchemaName_IsNull"); 815 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#L:BaseSchemaName_Value"); 816 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#L:BaseCatalogName_IsNull"); 817 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#L:BaseCatalogName_Value"); 818 Assert.IsTrue (pkRow.IsNull ("BaseTableName"), "#L:BaseTableName_IsNull"); 819 Assert.AreEqual (DBNull.Value, pkRow ["BaseTableName"], "#L:BaseTableName_Value"); 820 Assert.IsTrue (pkRow.IsNull ("BaseColumnName"), "#L:BaseColumnName_IsNull"); 821 Assert.AreEqual (DBNull.Value, pkRow ["BaseColumnName"], "#L:BaseColumnName_Value"); 822 } finally { 823 if (reader != null) 824 reader.Close (); 825 } 826 } 827 828 [Test] OutputParametersTest()829 public void OutputParametersTest () 830 { 831 // MySQL currently does not support output parameters 832 // in its ODBC connector: 833 // http://www.paragon-cs.com/mag/issue3.pdf 834 if (ConnectionManager.Instance.Odbc.EngineConfig.Type != EngineType.SQLServer) 835 Assert.Ignore ("MySQL does not (yet) support output parameters using ODBC."); 836 837 IDataReader reader = null; 838 839 try { 840 cmd.CommandText = "{? = CALL sp_get_age (?, ?)}"; 841 842 OdbcParameter ret = new OdbcParameter ("ret", OdbcType.Int); 843 cmd.Parameters.Add (ret); 844 ret.Direction = ParameterDirection.ReturnValue; 845 846 OdbcParameter name = new OdbcParameter ("fname", OdbcType.VarChar); 847 cmd.Parameters.Add (name); 848 name.Direction = ParameterDirection.Input; 849 name.Value = "suresh"; 850 851 OdbcParameter age = new OdbcParameter ("age", OdbcType.Int); 852 cmd.Parameters.Add (age); 853 age.Direction = ParameterDirection.Output; 854 855 reader = cmd.ExecuteReader (); 856 reader.Close (); 857 858 /* FIXME: we don't support output/return parameters */ 859 if (!RunningOnMono) { 860 Assert.IsTrue (((int) (age.Value)) > 0, "#1"); 861 Assert.IsTrue (((int) ret.Value) > 0, "#2"); 862 } 863 } finally { 864 if (reader != null) 865 reader.Close (); 866 } 867 } 868 869 [Test] LongTextTest()870 public void LongTextTest () 871 { 872 IDataReader reader = null; 873 874 try { 875 cmd.CommandText = "Select type_text from string_family where id=2"; 876 877 reader = cmd.ExecuteReader (); 878 reader.Read (); 879 reader.GetValue (0); 880 }finally { 881 if (reader != null) 882 reader.Close (); 883 } 884 } 885 886 [Test] Bug82135Test()887 public void Bug82135Test () 888 { 889 const string drop_table = "drop table odbcnodatatest"; 890 891 // cleanup in case of previously failed test 892 DBHelper.ExecuteNonQuery (conn, drop_table); 893 894 cmd = new OdbcCommand ("create table odbcnodatatest (ID int not null, Val1 text)", 895 conn); 896 cmd.ExecuteNonQuery (); 897 cmd = new OdbcCommand ("delete from odbcnodatatest", conn); 898 Assert.AreEqual (0, cmd.ExecuteNonQuery ()); 899 900 // cleanup 901 cmd = new OdbcCommand (drop_table, conn); 902 cmd.ExecuteNonQuery (); 903 } 904 905 [Test] Bug82560Test()906 public void Bug82560Test () 907 { 908 string drop_table = "DROP TABLE odbc_alias_test"; 909 910 // cleanup in case of previously failed test 911 DBHelper.ExecuteNonQuery (conn, drop_table); 912 913 DoExecuteNonQuery (conn, "CREATE TABLE odbc_alias_test" + 914 "(ifld INT NOT NULL PRIMARY KEY, sfld VARCHAR(20))"); 915 DoExecuteNonQuery (conn, "INSERT INTO odbc_alias_test" + 916 "(ifld, sfld) VALUES (1, '1111')"); 917 DoExecuteScalar (conn, "SELECT A.ifld FROM odbc_alias_test " + 918 "A WHERE A.ifld = 1"); 919 DoExecuteNonQuery (conn, drop_table); 920 } 921 922 [Test] FindZeroInToStringTest()923 public void FindZeroInToStringTest () 924 { 925 if (ConnectionManager.Instance.Odbc.EngineConfig.Type != EngineType.MySQL) 926 Assert.Ignore ("Only applies to MySQL."); 927 928 IDataReader reader = null; 929 930 try { 931 // Create table 932 cmd.CommandText = "Create table foo ( bar long varchar )"; 933 cmd.ExecuteNonQuery(); 934 cmd.Dispose (); 935 936 // Insert a record into foo 937 cmd = conn.CreateCommand (); 938 cmd.CommandText = "Insert into foo (bar) values ( '" 939 + "This string has more than 255 characters" 940 + "This string has more than 255 characters" 941 + "This string has more than 255 characters" 942 + "This string has more than 255 characters" 943 + "This string has more than 255 characters" 944 + "This string has more than 255 characters" 945 + "This string has more than 255 characters" 946 + "This string has more than 255 characters" 947 + "This string has more than 255 characters" 948 + "This string has more than 255 characters" 949 + "This string has more than 255 characters" 950 + "This string has more than 255 characters" 951 + "This string has more than 255 characters" 952 + "This string has more than 255 characters" 953 + "This string has more than 255 characters" 954 + "This string has more than 255 characters" 955 + "This string has more than 255 characters" 956 + "This string has more than 255 characters" 957 + "This string has more than 255 characters" 958 + "This string has more than 255 characters" 959 + "This string has more than 255 characters" 960 + "This string has more than 255 characters" 961 + "This string has more than 255 characters" 962 + "This string has more than 255 characters" 963 + "' )"; 964 cmd.ExecuteNonQuery(); 965 cmd.Dispose (); 966 967 // Now, get the record back - try and read it two different ways. 968 cmd = conn.CreateCommand (); 969 cmd.CommandText = "SELECT bar FROM foo" ; 970 reader = cmd.ExecuteReader (); 971 string readAsString = ""; 972 while (reader.Read ()) { 973 readAsString = reader[0].ToString(); 974 } 975 reader.Close(); 976 cmd.Dispose (); 977 978 // Now, read it using GetBytes 979 cmd = conn.CreateCommand (); 980 cmd.CommandText = "SELECT bar FROM foo"; 981 reader = cmd.ExecuteReader (); 982 byte[] buffer = new byte [2048]; 983 long total = 0; 984 while (reader.Read ()) { 985 total = reader.GetBytes (0, 0, buffer, 0, 2048); 986 } 987 reader.Close(); 988 // Convert bytes read to string - look for binary zero - there is none (OK) 989 string readAsBytes = Encoding.Default.GetString (buffer, 0, (int) total); 990 Assert.AreEqual (readAsBytes, readAsString, "#1 ReadAsString is not same as ReadAsBytes"); 991 } finally { 992 if (reader != null) 993 reader.Close (); 994 DBHelper.ExecuteNonQuery (conn, "Drop table foo"); 995 } 996 } 997 998 [Test] Bug332404Test()999 public void Bug332404Test () 1000 { 1001 if (ConnectionManager.Instance.Odbc.EngineConfig.Type != EngineType.MySQL) 1002 Assert.Ignore ("Only applies to MySQL."); 1003 1004 cmd = new OdbcCommand ("DROP TABLE IF EXISTS odbc_test"); 1005 cmd.Connection = conn; 1006 cmd.ExecuteNonQuery (); 1007 1008 cmd = new OdbcCommand ("CREATE TABLE odbc_test (id_test INTEGER NOT NULL, payload DECIMAL (14,4) NOT NULL)"); 1009 cmd.Connection = conn; 1010 cmd.ExecuteNonQuery (); 1011 1012 cmd = new OdbcCommand ("INSERT INTO odbc_test (id_test, payload) VALUES (1, 1.23456789)"); 1013 cmd.Connection = conn; 1014 cmd.ExecuteNonQuery (); 1015 1016 OdbcDataAdapter Adaptador = new OdbcDataAdapter (); 1017 1018 DataSet Lector = new DataSet (); 1019 1020 Adaptador.SelectCommand = new OdbcCommand ("SELECT * FROM odbc_test WHERE id_test=1", (OdbcConnection) conn); 1021 Adaptador.Fill (Lector); 1022 Assert.AreEqual (Lector.Tables[0].Rows[0]["payload"], 1.2346); 1023 } 1024 1025 [Test] Bug332400Test()1026 public void Bug332400Test () 1027 { 1028 if (ConnectionManager.Instance.Odbc.EngineConfig.Type != EngineType.MySQL) 1029 Assert.Ignore ("Only applies to MySQL."); 1030 1031 cmd = new OdbcCommand ("DROP TABLE IF EXISTS blob_test"); 1032 cmd.Connection = conn; 1033 cmd.ExecuteNonQuery (); 1034 1035 cmd = new OdbcCommand ("CREATE TABLE blob_test (id_test INTEGER NOT NULL, payload LONGBLOB NOT NULL)"); 1036 cmd.Connection = conn; 1037 cmd.ExecuteNonQuery (); 1038 1039 cmd = new OdbcCommand ("INSERT INTO blob_test (id_test, payload) VALUES (1, 'test')"); 1040 cmd.Connection = conn; 1041 cmd.ExecuteNonQuery (); 1042 1043 OdbcDataAdapter Adaptador = new OdbcDataAdapter(); 1044 DataSet Lector = new DataSet(); 1045 1046 Adaptador.SelectCommand = new OdbcCommand("SELECT * FROM blob_test WHERE id_test=1", (OdbcConnection) conn); 1047 Adaptador.Fill(Lector); 1048 } 1049 1050 [Test] Bug419224Test()1051 public void Bug419224Test () 1052 { 1053 cmd = new OdbcCommand ("DROP TABLE IF EXISTS odbc_test"); 1054 cmd.Connection = conn; 1055 cmd.ExecuteNonQuery (); 1056 1057 cmd = new OdbcCommand ("CREATE TABLE odbc_test (id_test INTEGER NOT NULL, payload TINYBLOB NOT NULL)"); 1058 cmd.Connection = conn; 1059 cmd.ExecuteNonQuery (); 1060 1061 cmd = new OdbcCommand ("INSERT INTO odbc_test (id_test, payload) VALUES (1, 'test for bug419224')"); 1062 cmd.Connection = conn; 1063 cmd.ExecuteNonQuery (); 1064 1065 OdbcDataAdapter adaptador = new OdbcDataAdapter (); 1066 DataSet lector = new DataSet (); 1067 1068 adaptador.SelectCommand = new OdbcCommand ("SELECT * FROM odbc_test WHERE id_test=1", (OdbcConnection) conn); 1069 adaptador.Fill (lector); 1070 var payload = (byte[])lector.Tables[0].Rows[0]["payload"]; 1071 Assert.AreEqual ("test for bug419224", Encoding.UTF8.GetString(payload)); 1072 1073 OdbcDataReader newRdr = cmd.ExecuteReader(); 1074 1075 // tinyblob column index: 1076 int TinyblobIdx = 1; 1077 1078 bool read = newRdr.Read(); 1079 1080 if (read) 1081 { 1082 bool ret = newRdr.IsDBNull(TinyblobIdx); 1083 Assert.AreEqual (ret, false); 1084 } 1085 } 1086 DoExecuteNonQuery(OdbcConnection conn, string sql)1087 static void DoExecuteNonQuery (OdbcConnection conn, string sql) 1088 { 1089 IDbCommand cmd = new OdbcCommand (sql, conn); 1090 cmd.ExecuteNonQuery (); 1091 } 1092 DoExecuteScalar(OdbcConnection conn, string sql)1093 static void DoExecuteScalar (OdbcConnection conn, string sql) 1094 { 1095 IDbCommand cmd = new OdbcCommand (sql, conn); 1096 cmd.ExecuteScalar (); 1097 } 1098 AssertSchemaTableStructure(DataTable schemaTable, string prefix)1099 static void AssertSchemaTableStructure (DataTable schemaTable, string prefix) 1100 { 1101 object [] [] columns = { 1102 new object [] { "ColumnName", typeof (string) }, 1103 new object [] { "ColumnOrdinal", typeof (int) }, 1104 new object [] { "ColumnSize", typeof (int) }, 1105 new object [] { "NumericPrecision", typeof (short) }, 1106 new object [] { "NumericScale", typeof (short) }, 1107 new object [] { "DataType", typeof (object) }, 1108 new object [] { "ProviderType", typeof (int) }, 1109 new object [] { "IsLong", typeof (bool) }, 1110 new object [] { "AllowDBNull", typeof (bool) }, 1111 new object [] { "IsReadOnly", typeof (bool) }, 1112 new object [] { "IsRowVersion", typeof (bool) }, 1113 new object [] { "IsUnique", typeof (bool) }, 1114 new object [] { "IsKey", typeof (bool) }, 1115 new object [] { "IsAutoIncrement", typeof (bool) }, 1116 new object [] { "BaseSchemaName", typeof (string) }, 1117 new object [] { "BaseCatalogName", typeof (string) }, 1118 new object [] { "BaseTableName", typeof (string) }, 1119 new object [] { "BaseColumnName", typeof (string) } 1120 }; 1121 1122 Assert.AreEqual (columns.Length, schemaTable.Columns.Count, prefix); 1123 1124 for (int i = 0; i < columns.Length; i++) { 1125 DataColumn col = schemaTable.Columns [i]; 1126 Assert.IsTrue (col.AllowDBNull, prefix + "AllowDBNull (" + i + ")"); 1127 Assert.AreEqual (columns [i] [0], col.ColumnName, prefix + "ColumnName (" + i + ")"); 1128 Assert.AreEqual (columns [i] [1], col.DataType, prefix + "DataType (" + i + ")"); 1129 } 1130 } 1131 1132 static bool RunningOnMono { 1133 get { 1134 return (Type.GetType ("System.MonoType", false) != null); 1135 } 1136 } 1137 } 1138 } 1139 1140 #endif