//
// SqlDataReaderTest.cs - NUnit Test Cases for testing the
// SqlDataReader class
// Author:
// Umadevi S (sumadevi@novell.com)
// Kornél Pál
// Sureshkumar T (tsureshkumar@novell.com)
// Senganal T (tsenganal@novell.com)
// Veerapuram Varadhan (vvaradhan@novell.com)
//
// Copyright (c) 2004 Novell Inc., and the individuals listed
// on the ChangeLog entries.
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Data;
using System.Data.Common;
using System.Data.SqlClient;
using System.Data.SqlTypes;
using System.Globalization;
using System.Text;
using NUnit.Framework;
namespace MonoTests.System.Data.SqlClient
{
[TestFixture]
[Category ("sqlserver")]
public class SqlDataReaderTest
{
static byte [] long_bytes = new byte [] {
0x00, 0x66, 0x06, 0x66, 0x97, 0x00, 0x66, 0x06, 0x66,
0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
0x06, 0x66, 0x06, 0x66, 0x98};
SqlConnection conn = null;
SqlCommand cmd = null;
SqlDataReader reader = null;
String query = "Select type_{0},type_{2},convert({1},null) from numeric_family where id=1";
DataSet sqlDataset = null;
EngineConfig engine;
DataTable numericDataTable =null;
DataTable stringDataTable =null;
DataTable binaryDataTable =null;
DataTable datetimeDataTable =null;
DataRow numericRow = null;
DataRow stringRow = null;
DataRow binaryRow = null;
DataRow datetimeRow = null;
[TestFixtureSetUp]
public void init ()
{
conn = new SqlConnection (ConnectionManager.Singleton.ConnectionString);
cmd = conn.CreateCommand ();
sqlDataset = (new DataProvider()).GetDataSet ();
numericDataTable = sqlDataset.Tables["numeric_family"];
stringDataTable = sqlDataset.Tables["string_family"];
binaryDataTable = sqlDataset.Tables["binary_family"];
datetimeDataTable = sqlDataset.Tables["datetime_family"];
numericRow = numericDataTable.Select ("id=1")[0];
stringRow = stringDataTable.Select ("id=1")[0];
binaryRow = binaryDataTable.Select ("id=1")[0];
datetimeRow = datetimeDataTable.Select ("id=1")[0];
}
[SetUp]
public void Setup ()
{
conn.Open ();
engine = ConnectionManager.Singleton.Engine;
}
[TearDown]
public void TearDown ()
{
if (reader != null)
reader.Close ();
conn.Close ();
}
[Test]
public void ReadEmptyNTextFieldTest ()
{
try {
DBHelper.ExecuteNonQuery (conn, "create table #tmp_monotest (name ntext)");
DBHelper.ExecuteNonQuery (conn, "insert into #tmp_monotest values ('')");
SqlCommand cmd = (SqlCommand) conn.CreateCommand ();
cmd.CommandText = "select * from #tmp_monotest";
SqlDataReader dr = cmd.ExecuteReader ();
if (dr.Read()) {
Assert.AreEqual("System.String",dr["NAME"].GetType().FullName);
}
Assert.AreEqual (false, dr.Read (), "#2");
} finally {
ConnectionManager.Singleton.CloseConnection ();
}
}
[Test]
public void ReadBigIntTest()
{
if (ClientVersion <= 7)
Assert.Ignore ("BigInt data type is not supported.");
try {
string query = "SELECT CAST(548967465189498 AS bigint) AS Value";
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandText = query;
SqlDataReader r = cmd.ExecuteReader();
using (r) {
Assert.AreEqual (true, r.Read(), "#1");
long id = r.GetInt64(0);
Assert.AreEqual(548967465189498, id, "#2");
id = r.GetSqlInt64(0).Value;
Assert.AreEqual(548967465189498, id, "#3");
}
} finally {
ConnectionManager.Singleton.CloseConnection ();
}
}
// This method just helps in Calling common tests among all the Get* Methods
// without replicating code
void CallGetMethod (string s, int i)
{
switch (s) {
case "Boolean" : reader.GetBoolean (i) ; break;
case "SqlBoolean": reader.GetSqlBoolean (i); break;
case "Int16" : reader.GetInt16 (i); break;
case "SqlInt16" : reader.GetSqlInt16 (i); break;
case "Int32" : reader.GetInt32 (i);break;
case "SqlInt32" : reader.GetSqlInt32(i);break;
case "Int64" : reader.GetInt64 (i);break;
case "SqlInt64" : reader.GetSqlInt64(i); break;
case "Decimal" : reader.GetDecimal(i);break;
case "SqlDecimal" : reader.GetSqlDecimal (i);break;
case "SqlMoney" : reader.GetSqlMoney (i);break;
case "Float" : reader.GetFloat (i);break;
case "SqlSingle" : reader.GetSqlSingle(i);break;
case "Double" : reader.GetDouble (i);break;
case "SqlDouble" : reader.GetSqlDouble(i);break;
case "Guid" : reader.GetGuid(i);break;
case "SqlGuid" : reader.GetSqlGuid(i);break;
case "String" : reader.GetString(i);break;
case "SqlString" : reader.GetSqlString(i);break;
case "Char" : reader.GetChar(i);break;
case "Byte" : reader.GetByte (i);break;
case "SqlByte" : reader.GetSqlByte(i); break;
case "DateTime" : reader.GetDateTime(i); break;
case "SqlDateTime" : reader.GetSqlDateTime(i); break;
case "SqlBinary" : reader.GetSqlBinary(i); break;
default : Console.WriteLine ("OOOOPSSSSSS {0}",s);break;
}
}
// This method just helps in Calling common tests among all the Get* Methods
// without replicating code
void GetMethodTests (string s)
{
try {
CallGetMethod (s, 1);
Assert.Fail ("#1[Get"+s+"] InvalidCastException must be thrown");
} catch (InvalidCastException e) {
Assert.AreEqual (typeof (InvalidCastException), e.GetType (),
"#2[Get"+s+"] Incorrect Exception : " + e);
}
// GetSql* Methods do not throw SqlNullValueException
// So, Testimg only for Get* Methods
if (!s.StartsWith("Sql")) {
try {
CallGetMethod (s, 2);
Assert.Fail ("#3[Get"+s+"] Exception must be thrown");
} catch (SqlNullValueException e) {
Assert.AreEqual (typeof (SqlNullValueException), e.GetType (),
"#4[Get"+s+"] Incorrect Exception : " + e);
}
}
try {
CallGetMethod (s, 3);
Assert.Fail ("#5[Get"+s+"] IndexOutOfRangeException must be thrown");
} catch (IndexOutOfRangeException e) {
Assert.AreEqual (typeof (IndexOutOfRangeException), e.GetType (),
"#6[Get"+s+"] Incorrect Exception : " + e);
}
}
[Test]
public void GetBooleanTest ()
{
cmd.CommandText = string.Format (query, "bit", "bit", "int");
reader = cmd.ExecuteReader ();
reader.Read ();
// Test for standard exceptions
GetMethodTests("Boolean");
// Test if data is returned correctly
Assert.AreEqual (numericRow ["type_bit"], reader.GetBoolean (0),
"#2 DataValidation Failed");
// Test for standard exceptions
GetMethodTests("SqlBoolean");
// Test if data is returned correctly
Assert.AreEqual (numericRow["type_bit"], reader.GetSqlBoolean(0).Value,
"#4 DataValidation Failed");
reader.Close ();
}
[Test]
public void GetByteTest ()
{
cmd.CommandText = string.Format (query, "tinyint", "tinyint", "int");
reader = cmd.ExecuteReader ();
reader.Read ();
// Test for standard exceptions
GetMethodTests("Byte");
// Test if data is returned correctly
Assert.AreEqual (numericRow["type_tinyint"], reader.GetByte(0),
"#2 DataValidation Failed");
// Test for standard exceptions
GetMethodTests("SqlByte");
// Test if data is returned correctly
Assert.AreEqual (numericRow["type_tinyint"], reader.GetSqlByte(0).Value,
"#4 DataValidation Failed");
reader.Close ();
}
[Test]
public void GetInt16Test ()
{
cmd.CommandText = string.Format (query, "smallint", "smallint", "int");
reader = cmd.ExecuteReader();
reader.Read ();
// Test for standard exceptions
GetMethodTests("Int16");
// Test if data is returned correctly
Assert.AreEqual (numericRow["type_smallint"], reader.GetInt16(0),
"#2 DataValidation Failed");
// Test for standard exceptions
GetMethodTests("SqlInt16");
// Test if data is returned correctly
Assert.AreEqual (numericRow["type_smallint"], reader.GetSqlInt16(0).Value,
"#4 DataValidation Failed");
reader.Close ();
}
[Test]
public void GetInt32Test ()
{
if (ClientVersion == 7)
cmd.CommandText = string.Format (query, "int", "int", "decimal1");
else
cmd.CommandText = string.Format (query, "int", "int", "bigint");
reader = cmd.ExecuteReader ();
reader.Read ();
// Test for standard exceptions
GetMethodTests("Int32");
// Test if data is returned correctly
Assert.AreEqual (numericRow["type_int"], reader.GetInt32(0),
"#2 DataValidation Failed");
// Test for standard exceptions
GetMethodTests("SqlInt32");
// Test if data is returned correctly
Assert.AreEqual (numericRow["type_int"], reader.GetSqlInt32(0).Value,
"#4 DataValidation Failed");
reader.Close ();
}
[Test]
public void GetInt64Test ()
{
if (ClientVersion == 7)
Assert.Ignore ("BigInt data type is not supported.");
cmd.CommandText = string.Format (query, "bigint", "bigint", "int");
reader = cmd.ExecuteReader ();
reader.Read ();
object value;
// Test for standard exceptions
GetMethodTests("Int64");
// Test if data is returned correctly
value = reader.GetInt64 (0);
Assert.AreEqual (numericRow ["type_bigint"], value, "#A");
// Test for standard exceptions
GetMethodTests("SqlInt64");
// Test if data is returned correctly
value = reader.GetSqlInt64 (0);
Assert.IsNotNull (value, "#B1");
Assert.AreEqual (typeof (SqlInt64), value.GetType (), "#B2");
SqlInt64 sqlValue = (SqlInt64) value;
Assert.IsFalse (sqlValue.IsNull, "#B3");
Assert.AreEqual (numericRow ["type_bigint"], sqlValue.Value, "#B4");
value = reader.GetValue (0);
Assert.IsNotNull (value, "#C1");
Assert.AreEqual (typeof (long), value.GetType (), "#C2");
Assert.AreEqual (numericRow ["type_bigint"], value, "#C3");
reader.Close ();
}
[Test]
public void GetDecimalTest ()
{
cmd.CommandText = string.Format (query, "decimal1", "decimal", "int");
reader = cmd.ExecuteReader ();
reader.Read ();
// Test for standard exceptions
GetMethodTests("Decimal");
// Test if data is returned correctly
Assert.AreEqual (numericRow["type_decimal1"], reader.GetDecimal(0),
"#2 DataValidation Failed");
// Test for standard exceptions
GetMethodTests("SqlDecimal");
// Test if data is returned correctly
Assert.AreEqual (numericRow["type_decimal1"], reader.GetSqlDecimal(0).Value,
"#4 DataValidation Failed");
reader.Close ();
}
//#613087, #620860 Test
[Test]
public void GetDecimalOfInt64Test_Max ()
{
string crTable = "CREATE TABLE #613087 (decimalint64 decimal(20,0))";
//string drTable = "drop table #613087";
cmd.CommandText = crTable;
cmd.CommandType = CommandType.Text;
cmd.ExecuteNonQuery ();
cmd.CommandText = "INSERT INTO #613087 VALUES (@decimalint64)";
SqlParameter param = new SqlParameter ();
param.ParameterName = "@decimalint64";
param.Value = new SqlDecimal ((long)Int64.MaxValue);
cmd.Parameters.Add (param);
cmd.ExecuteNonQuery ();
cmd.Parameters.Clear ();
cmd.CommandText = "Select * from #613087";
reader = cmd.ExecuteReader();
reader.Read ();
Assert.AreEqual (param.Value, reader.GetSqlDecimal (0), "SqlDecimalFromInt64_Max Test failed");
}
//#613087, #620860 Test
[Test]
public void GetDecimalOfInt64Test_Min ()
{
string crTable = "CREATE TABLE #613087 (decimalint64 decimal(20,0))";
//string drTable = "drop table #613087";
cmd.CommandText = crTable;
cmd.CommandType = CommandType.Text;
cmd.ExecuteNonQuery ();
cmd.CommandText = "INSERT INTO #613087 VALUES (@decimalint64)";
SqlParameter param = new SqlParameter ();
param.ParameterName = "@decimalint64";
param.Value = new SqlDecimal ((long)Int64.MinValue);
cmd.Parameters.Add (param);
cmd.ExecuteNonQuery ();
cmd.Parameters.Clear ();
cmd.CommandText = "Select * from #613087";
reader = cmd.ExecuteReader();
reader.Read ();
Assert.AreEqual (param.Value, reader.GetSqlDecimal (0), "SqlDecimalFromInt64_Min Test failed");
}
//#613087, #620860 Test
[Test]
public void GetDecimalOfInt64Test_Any ()
{
string crTable = "CREATE TABLE #613087 (decimalint64 decimal(20,0))";
//string drTable = "drop table #613087";
cmd.CommandText = crTable;
cmd.CommandType = CommandType.Text;
cmd.ExecuteNonQuery ();
cmd.CommandText = "INSERT INTO #613087 VALUES (@decimalint64)";
SqlParameter param = new SqlParameter ();
param.ParameterName = "@decimalint64";
param.DbType = DbType.Decimal;
param.Value = ulong.MaxValue;
cmd.Parameters.Add (param);
cmd.ExecuteNonQuery ();
cmd.Parameters.Clear ();
cmd.CommandText = "Select * from #613087";
reader = cmd.ExecuteReader();
reader.Read ();
Assert.AreEqual (param.Value, (ulong)reader.GetSqlDecimal (0).Value, "SqlDecimalFromInt64_Any Test failed");
}
[Test]
public void GetSqlMoneyTest ()
{
cmd.CommandText = string.Format (query, "money", "money", "int");
reader = cmd.ExecuteReader ();
reader.Read ();
// Test for standard exceptions
GetMethodTests("SqlMoney");
// Test if data is returned correctly
Assert.AreEqual (numericRow["type_money"], reader.GetSqlMoney(0).Value,
"#2 DataValidation Failed");
reader.Close ();
}
[Test]
public void GetFloatTest ()
{
cmd.CommandText = "select type_float,type_double,convert(real,null)";
cmd.CommandText += "from numeric_family where id=1";
reader = cmd.ExecuteReader ();
reader.Read ();
// Test for standard exceptions
GetMethodTests("Float");
// Test if data is returned correctly
Assert.AreEqual (numericRow["type_float"], reader.GetFloat(0),
"#2 DataValidation Failed");
// Test for standard exceptions
GetMethodTests("SqlSingle");
// Test if data is returned correctly
Assert.AreEqual (numericRow["type_float"], reader.GetSqlSingle(0).Value,
"#2 DataValidation Failed");
reader.Close ();
}
[Test]
public void GetDoubleTest ()
{
cmd.CommandText = "select type_double,type_float,convert(float,null)";
cmd.CommandText += " from numeric_family where id=1";
reader = cmd.ExecuteReader ();
reader.Read ();
// Test for standard exceptions
GetMethodTests("Double");
// Test if data is returned correctly
Assert.AreEqual (numericRow["type_double"], reader.GetDouble(0),
"#2 DataValidation Failed");
// Test for standard exceptions
GetMethodTests("SqlDouble");
// Test if data is returned correctly
Assert.AreEqual (numericRow["type_double"], reader.GetSqlDouble(0).Value,
"#4 DataValidation Failed");
reader.Close ();
}
[Test]
public void GetBytesTest ()
{
cmd.CommandText = "Select type_text,type_ntext,convert(text,null) ";
cmd.CommandText += "from string_family where id=1";
reader = cmd.ExecuteReader ();
reader.Read ();
try {
long totalsize = reader.GetBytes (0, 0, null, 0, 0);
Assert.AreEqual (4, totalsize, "#1");
} finally {
reader.Close ();
}
byte[] asciiArray = (new ASCIIEncoding ()).GetBytes ("text");
byte[] unicodeArray = (new UnicodeEncoding ()).GetBytes ("nt\u092d\u093ext");
byte[] buffer = null ;
long size = 0;
reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess);
reader.Read ();
size = reader.GetBytes (0,0,null,0,0);
Assert.AreEqual (asciiArray.Length, size, "#3 Data Incorrect");
buffer = new byte[size];
size = reader.GetBytes (0,0,buffer,0,(int)size);
for (int i=0;i 7)
Assert.AreEqual (8, row ["ColumnSize"], "Value");
else
Assert.AreEqual (17, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_Binary ()
{
cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (8, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_Bit ()
{
cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (1, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_Char ()
{
cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (10, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_Date ()
{
// TODO
}
[Test]
public void ColumnSize_DateTime ()
{
cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (8, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_Decimal ()
{
cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "#A:IsNull");
Assert.AreEqual (17, row ["ColumnSize"], "#A:Value");
}
cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "#B:IsNull");
Assert.AreEqual (17, row ["ColumnSize"], "#B:Value");
}
cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "#C:IsNull");
Assert.AreEqual (17, row ["ColumnSize"], "#C:Value");
}
cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "#D:IsNull");
Assert.AreEqual (17, row ["ColumnSize"], "#D:Value");
}
}
[Test]
public void ColumnSize_Float ()
{
cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (8, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_Image ()
{
cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (int.MaxValue, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_Int ()
{
cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (4, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_Money ()
{
cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (8, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_NChar ()
{
cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (10, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_NText ()
{
cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (1073741823, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_NVarChar ()
{
cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (10, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_Real ()
{
cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (4, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_SmallDateTime ()
{
cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (4, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_SmallInt ()
{
cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (2, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_SmallMoney ()
{
cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (4, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_Text ()
{
cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (2147483647, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_Time ()
{
// TODO
}
[Test]
public void ColumnSize_Timestamp ()
{
cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (8, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_TinyInt ()
{
cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (1, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_Udt ()
{
// TODO
}
[Test]
public void ColumnSize_UniqueIdentifier ()
{
cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (16, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_VarBinary ()
{
cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (255, row ["ColumnSize"], "Value");
}
}
[Test]
public void ColumnSize_VarChar ()
{
cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
Assert.AreEqual (10, row ["ColumnSize"], "Value");
}
}
[Test]
public void DataType_BigInt ()
{
if (ClientVersion <= 7)
Assert.Ignore ("BigInt data type is not supported.");
cmd.CommandText = "SELECT type_bigint FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (long), row ["DataType"], "Value");
}
}
[Test]
public void DataType_Binary ()
{
cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (byte []), row ["DataType"], "Value");
}
}
[Test]
public void DataType_Bit ()
{
cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (bool), row ["DataType"], "Value");
}
}
[Test]
public void DataType_Char ()
{
cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (string), row ["DataType"], "Value");
}
}
[Test]
public void DataType_Date ()
{
// TODO
}
[Test]
public void DataType_DateTime ()
{
cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (DateTime), row ["DataType"], "Value");
}
}
[Test]
public void DataType_Decimal ()
{
cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "#A:IsNull");
Assert.AreEqual (typeof (decimal), row ["DataType"], "#A:Value");
}
cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "#B:IsNull");
Assert.AreEqual (typeof (decimal), row ["DataType"], "#B:Value");
}
cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "#C:IsNull");
Assert.AreEqual (typeof (decimal), row ["DataType"], "#C:Value");
}
cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "#D:IsNull");
Assert.AreEqual (typeof (decimal), row ["DataType"], "#D:Value");
}
}
[Test]
public void DataType_Float ()
{
cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (double), row ["DataType"], "Value");
}
}
[Test]
public void DataType_Image ()
{
cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (byte []), row ["DataType"], "Value");
}
}
[Test]
public void DataType_Int ()
{
cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (int), row ["DataType"], "Value");
}
}
[Test]
public void DataType_Money ()
{
cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (decimal), row ["DataType"], "Value");
}
}
[Test]
public void DataType_NChar ()
{
cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (string), row ["DataType"], "Value");
}
}
[Test]
public void DataType_NText ()
{
cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (string), row ["DataType"], "Value");
}
}
[Test]
public void DataType_NVarChar ()
{
cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (string), row ["DataType"], "Value");
}
}
[Test]
public void DataType_Real ()
{
cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (float), row ["DataType"], "Value");
}
}
[Test]
public void DataType_SmallDateTime ()
{
cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (DateTime), row ["DataType"], "Value");
}
}
[Test]
public void DataType_SmallInt ()
{
cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (short), row ["DataType"], "Value");
}
}
[Test]
public void DataType_SmallMoney ()
{
cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (decimal), row ["DataType"], "Value");
}
}
[Test]
public void DataType_Text ()
{
cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (string), row ["DataType"], "Value");
}
}
[Test]
public void DataType_Time ()
{
// TODO
}
[Test]
public void DataType_Timestamp ()
{
cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (byte []), row ["DataType"], "Value");
}
}
[Test]
public void DataType_TinyInt ()
{
cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (byte), row ["DataType"], "Value");
}
}
[Test]
public void DataType_Udt ()
{
// TODO
}
[Test]
public void DataType_UniqueIdentifier ()
{
cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (Guid), row ["DataType"], "Value");
}
}
[Test]
public void DataType_VarBinary ()
{
cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (byte []), row ["DataType"], "Value");
}
}
[Test]
public void DataType_VarChar ()
{
cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
Assert.AreEqual (typeof (string), row ["DataType"], "Value");
}
}
[Test]
public void IsLong_BigInt ()
{
if (ClientVersion <= 7)
Assert.Ignore ("BigInt data type is not supported.");
cmd.CommandText = "SELECT type_bigint FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (false, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_Binary ()
{
cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (false, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_Bit ()
{
cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (false, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_Char ()
{
cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (false, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_Date ()
{
// TODO
}
[Test]
public void IsLong_DateTime ()
{
cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (false, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_Decimal ()
{
cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "#A:IsNull");
Assert.AreEqual (false, row ["IsLong"], "#A:Value");
}
cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "#B:IsNull");
Assert.AreEqual (false, row ["IsLong"], "#B:Value");
}
cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "#C:IsNull");
Assert.AreEqual (false, row ["IsLong"], "#C:Value");
}
cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "#D:IsNull");
Assert.AreEqual (false, row ["IsLong"], "#D:Value");
}
}
[Test]
public void IsLong_Float ()
{
cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (false, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_Image ()
{
cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (true, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_Int ()
{
cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (false, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_Money ()
{
cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (false, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_NChar ()
{
cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (false, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_NText ()
{
cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (true, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_NVarChar ()
{
cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (false, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_Real ()
{
cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (false, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_SmallDateTime ()
{
cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (false, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_SmallInt ()
{
cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (false, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_SmallMoney ()
{
cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (false, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_Text ()
{
cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (true, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_Time ()
{
// TODO
}
[Test]
public void IsLong_Timestamp ()
{
cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (false, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_TinyInt ()
{
cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (false, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_Udt ()
{
// TODO
}
[Test]
public void IsLong_UniqueIdentifier ()
{
cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (false, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_VarBinary ()
{
cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (false, row ["IsLong"], "Value");
}
}
[Test]
public void IsLong_VarChar ()
{
cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
Assert.AreEqual (false, row ["IsLong"], "Value");
}
}
[Test]
public void NumericPrecision_BigInt ()
{
if (ClientVersion <= 7)
Assert.Ignore ("BigInt data type is not supported.");
cmd.CommandText = "SELECT type_bigint FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (19, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_Binary ()
{
cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (255, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_Bit ()
{
cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (255, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_Char ()
{
cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (255, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_Date ()
{
// TODO
}
[Test]
public void NumericPrecision_DateTime ()
{
cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (23, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_Decimal ()
{
cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "#A:IsNull");
if (ClientVersion == 7)
Assert.AreEqual (28, row ["NumericPrecision"], "#A:Value");
else
Assert.AreEqual (38, row ["NumericPrecision"], "#A:Value");
}
cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "#B:IsNull");
Assert.AreEqual (10, row ["NumericPrecision"], "#B:Value");
}
cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "#C:IsNull");
if (ClientVersion == 7)
Assert.AreEqual (28, row ["NumericPrecision"], "#C:Value");
else
Assert.AreEqual (38, row ["NumericPrecision"], "#C:Value");
}
cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "#D:IsNull");
Assert.AreEqual (10, row ["NumericPrecision"], "#D:Value");
}
}
[Test]
public void NumericPrecision_Float ()
{
cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (15, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_Image ()
{
cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (255, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_Int ()
{
cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (10, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_Money ()
{
cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (19, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_NChar ()
{
cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (255, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_NText ()
{
cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (255, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_NVarChar ()
{
cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (255, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_Real ()
{
cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (7, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_SmallDateTime ()
{
cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (16, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_SmallInt ()
{
cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (5, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_SmallMoney ()
{
cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (10, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_Text ()
{
cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (255, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_Time ()
{
// TODO
}
[Test]
public void NumericPrecision_Timestamp ()
{
cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (255, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_TinyInt ()
{
cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (3, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_Udt ()
{
// TODO
}
[Test]
public void NumericPrecision_UniqueIdentifier ()
{
cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (255, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_VarBinary ()
{
cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (255, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_VarChar ()
{
cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericPrecision"], "Value");
else
Assert.AreEqual (255, row ["NumericPrecision"], "Value");
}
}
[Test]
public void NumericPrecision_Variant ()
{
// TODO
}
[Test]
public void NumericPrecision_Xml ()
{
// TODO
}
[Test]
public void NumericScale_BigInt ()
{
if (ClientVersion <= 7)
Assert.Ignore ("BigInt data type is not supported.");
cmd.CommandText = "SELECT type_bigint FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_Binary ()
{
cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_Bit ()
{
cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_Char ()
{
cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_Date ()
{
// TODO
}
[Test]
public void NumericScale_DateTime ()
{
cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (3, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_Decimal ()
{
cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "#A:IsNull");
Assert.AreEqual (0, row ["NumericScale"], "#A:Value");
}
cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "#B:IsNull");
Assert.AreEqual (3, row ["NumericScale"], "#B:Value");
}
cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "#C:IsNull");
Assert.AreEqual (0, row ["NumericScale"], "#C:Value");
}
cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "#D:IsNull");
Assert.AreEqual (3, row ["NumericScale"], "#D:Value");
}
}
[Test]
public void NumericScale_Float ()
{
cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_Image ()
{
cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_Int ()
{
cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_Money ()
{
cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_NChar ()
{
cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_NText ()
{
cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_NVarChar ()
{
cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_Real ()
{
cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_SmallDateTime ()
{
cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
Assert.AreEqual (0, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_SmallInt ()
{
cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_SmallMoney ()
{
cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_Text ()
{
cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_Time ()
{
// TODO
}
[Test]
public void NumericScale_Timestamp ()
{
cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_TinyInt ()
{
cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_Udt ()
{
// TODO
}
[Test]
public void NumericScale_UniqueIdentifier ()
{
cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_VarBinary ()
{
cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_VarChar ()
{
cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
if (ClientVersion > 7)
Assert.AreEqual (0, row ["NumericScale"], "Value");
else
Assert.AreEqual (255, row ["NumericScale"], "Value");
}
}
[Test]
public void NumericScale_Variant ()
{
// TODO
}
[Test]
public void NumericScale_Xml ()
{
// TODO
}
[Test]
public void ProviderType_BigInt ()
{
if (ClientVersion <= 7)
Assert.Ignore ("BigInt data type is not supported.");
cmd.CommandText = "SELECT type_bigint FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (0, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_Binary ()
{
cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (1, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_Bit ()
{
cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (2, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_Char ()
{
cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (3, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_Date ()
{
// TODO
}
[Test]
public void ProviderType_DateTime ()
{
cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (4, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_Decimal ()
{
cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "#A:IsNull");
Assert.AreEqual (5, row ["ProviderType"], "#A:Value");
}
cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "#B:IsNull");
Assert.AreEqual (5, row ["ProviderType"], "#B:Value");
}
cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "#C:IsNull");
Assert.AreEqual (5, row ["ProviderType"], "#C:Value");
}
cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "#D:IsNull");
Assert.AreEqual (5, row ["ProviderType"], "#D:Value");
}
}
[Test]
public void ProviderType_Float ()
{
cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (6, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_Image ()
{
cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (7, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_Int ()
{
cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (8, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_Money ()
{
cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (9, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_NChar ()
{
cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (10, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_NText ()
{
cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (11, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_NVarChar ()
{
cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (12, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_Real ()
{
cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (13, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_SmallDateTime ()
{
cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (15, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_SmallInt ()
{
cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (16, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_SmallMoney ()
{
cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (17, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_Text ()
{
cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (18, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_Time ()
{
// TODO
}
[Test]
public void ProviderType_Timestamp ()
{
cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
// we currently consider timestamp as binary (due to TDS 7.0?)
if (ClientVersion > 7)
Assert.AreEqual (1, row ["ProviderType"], "Value");
else
Assert.AreEqual (19, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_TinyInt ()
{
cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (20, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_Udt ()
{
// TODO
}
[Test]
public void ProviderType_UniqueIdentifier ()
{
cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (14, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_VarBinary ()
{
cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (21, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_VarChar ()
{
cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
DataTable schemaTable = rdr.GetSchemaTable ();
DataRow row = schemaTable.Rows [0];
Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
Assert.AreEqual (22, row ["ProviderType"], "Value");
}
}
[Test]
public void ProviderType_Variant ()
{
// TODO
}
[Test]
public void ProviderType_Xml ()
{
// TODO
}
private int ClientVersion {
get {
return (engine.ClientVersion);
}
}
}
}