Files
mono/mcs/class/System.Data/System.Data.SqlClient/SqlDataReader.cs
T
Tim Coleman db177b4a47 2002-11-26 Tim Coleman <[email protected]>
* System.Data.SqlClient/SqlCommand.cs:
        * System.Data.SqlClient/SqlConnection.cs:
        * System.Data.SqlClient/SqlDataReader.cs:
        * System.Data.SqlClient/SqlParameter.cs:
        * System.Data.SqlClient/SqlParameterCollection.cs:
        * System.Data.SqlClient/SqlTransaction.cs:
                Many changes around restructuring of parameter
                information so that the Sybase provider supports
                PREPAREs too.

svn path=/trunk/mcs/; revision=9193
2002-11-26 06:33:28 +00:00

767 lines
20 KiB
C#

//
// System.Data.SqlClient.SqlDataReader.cs
//
// Author:
// Rodrigo Moya ([email protected])
// Daniel Morgan ([email protected])
// Tim Coleman ([email protected])
//
// (C) Ximian, Inc 2002
// (C) Daniel Morgan 2002
// Copyright (C) Tim Coleman, 2002
//
using Mono.Data.Tds.Protocol;
using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using System.Data.SqlTypes;
namespace System.Data.SqlClient {
public sealed class SqlDataReader : MarshalByRefObject, IEnumerable, IDataReader, IDisposable, IDataRecord
{
#region Fields
SqlCommand command;
ArrayList dataTypeNames;
bool disposed = false;
int fieldCount;
bool isClosed;
bool isSelect;
bool moreResults;
int resultsRead;
int rowsRead;
DataTable schemaTable;
#endregion // Fields
#region Constructors
internal SqlDataReader (SqlCommand command)
{
this.command = command;
schemaTable = ConstructSchemaTable ();
resultsRead = 0;
fieldCount = 0;
isClosed = false;
isSelect = (command.CommandText.Trim ().ToUpper ().StartsWith ("SELECT"));
command.Tds.RecordsAffected = 0;
NextResult ();
}
#endregion // Constructors
#region Properties
public int Depth {
get { return 0; }
}
public int FieldCount {
get { return fieldCount; }
}
public bool IsClosed {
get { return isClosed; }
}
public object this [int i] {
get { return GetValue (i); }
}
public object this [string name] {
get { return GetValue (GetOrdinal (name)); }
}
public int RecordsAffected {
get {
if (isSelect)
return -1;
else
return command.Tds.RecordsAffected;
}
}
#endregion // Properties
#region Methods
public void Close ()
{
isClosed = true;
command.CloseDataReader (moreResults);
}
private static DataTable ConstructSchemaTable ()
{
Type booleanType = Type.GetType ("System.Boolean");
Type stringType = Type.GetType ("System.String");
Type intType = Type.GetType ("System.Int32");
Type typeType = Type.GetType ("System.Type");
Type shortType = Type.GetType ("System.Int16");
DataTable schemaTable = new DataTable ("SchemaTable");
schemaTable.Columns.Add ("ColumnName", stringType);
schemaTable.Columns.Add ("ColumnOrdinal", intType);
schemaTable.Columns.Add ("ColumnSize", intType);
schemaTable.Columns.Add ("NumericPrecision", shortType);
schemaTable.Columns.Add ("NumericScale", shortType);
schemaTable.Columns.Add ("IsUnique", booleanType);
schemaTable.Columns.Add ("IsKey", booleanType);
schemaTable.Columns.Add ("BaseServerName", stringType);
schemaTable.Columns.Add ("BaseCatalogName", stringType);
schemaTable.Columns.Add ("BaseColumnName", stringType);
schemaTable.Columns.Add ("BaseSchemaName", stringType);
schemaTable.Columns.Add ("BaseTableName", stringType);
schemaTable.Columns.Add ("DataType", typeType);
schemaTable.Columns.Add ("AllowDBNull", booleanType);
schemaTable.Columns.Add ("ProviderType", intType);
schemaTable.Columns.Add ("IsAliased", booleanType);
schemaTable.Columns.Add ("IsExpression", booleanType);
schemaTable.Columns.Add ("IsIdentity", booleanType);
schemaTable.Columns.Add ("IsAutoIncrement", booleanType);
schemaTable.Columns.Add ("IsRowVersion", booleanType);
schemaTable.Columns.Add ("IsHidden", booleanType);
schemaTable.Columns.Add ("IsLong", booleanType);
schemaTable.Columns.Add ("IsReadOnly", booleanType);
return schemaTable;
}
private void Dispose (bool disposing)
{
if (!disposed) {
if (disposing) {
schemaTable.Dispose ();
Close ();
}
disposed = true;
}
}
public bool GetBoolean (int i)
{
object value = GetValue (i);
if (!(value is bool))
throw new InvalidCastException ();
return (bool) value;
}
public byte GetByte (int i)
{
object value = GetValue (i);
if (!(value is byte))
throw new InvalidCastException ();
return (byte) value;
}
public long GetBytes (int i, long dataIndex, byte[] buffer, int bufferIndex, int length)
{
object value = GetValue (i);
if (!(value is byte []))
throw new InvalidCastException ();
Array.Copy ((byte []) value, (int) dataIndex, buffer, bufferIndex, length);
return ((byte []) value).Length - dataIndex;
}
public char GetChar (int i)
{
object value = GetValue (i);
if (!(value is char))
throw new InvalidCastException ();
return (char) value;
}
public long GetChars (int i, long dataIndex, char[] buffer, int bufferIndex, int length)
{
object value = GetValue (i);
if (!(value is char[]))
throw new InvalidCastException ();
Array.Copy ((char []) value, (int) dataIndex, buffer, bufferIndex, length);
return ((char []) value).Length - dataIndex;
}
[MonoTODO ("Implement GetData")]
public IDataReader GetData (int i)
{
throw new NotImplementedException ();
}
public string GetDataTypeName (int i)
{
return (string) dataTypeNames [i];
}
public DateTime GetDateTime (int i)
{
object value = GetValue (i);
if (!(value is DateTime))
throw new InvalidCastException ();
return (DateTime) value;
}
public decimal GetDecimal (int i)
{
object value = GetValue (i);
if (!(value is decimal))
throw new InvalidCastException ();
return (decimal) value;
}
public double GetDouble (int i)
{
object value = GetValue (i);
if (!(value is double))
throw new InvalidCastException ();
return (double) value;
}
public Type GetFieldType (int i)
{
return (Type) schemaTable.Rows[i]["DataType"];
}
public float GetFloat (int i)
{
object value = GetValue (i);
if (!(value is float))
throw new InvalidCastException ();
return (float) value;
}
public Guid GetGuid (int i)
{
object value = GetValue (i);
if (!(value is Guid))
throw new InvalidCastException ();
return (Guid) value;
}
public short GetInt16 (int i)
{
object value = GetValue (i);
if (!(value is short))
throw new InvalidCastException ();
return (short) value;
}
public int GetInt32 (int i)
{
object value = GetValue (i);
if (!(value is int))
throw new InvalidCastException ();
return (int) value;
}
public long GetInt64 (int i)
{
object value = GetValue (i);
if (!(value is long))
throw new InvalidCastException ();
return (long) value;
}
public string GetName (int i)
{
return (string) schemaTable.Rows[i]["ColumnName"];
}
public int GetOrdinal (string name)
{
foreach (DataRow schemaRow in schemaTable.Rows)
if (((string) schemaRow ["ColumnName"]).Equals (name))
return (int) schemaRow ["ColumnOrdinal"];
foreach (DataRow schemaRow in schemaTable.Rows)
if (String.Compare (((string) schemaRow ["ColumnName"]), name, true) == 0)
return (int) schemaRow ["ColumnOrdinal"];
throw new IndexOutOfRangeException ();
}
public DataTable GetSchemaTable ()
{
if (schemaTable.Rows != null && schemaTable.Rows.Count > 0)
return schemaTable;
if (!moreResults)
return null;
fieldCount = 0;
dataTypeNames = new ArrayList ();
foreach (TdsSchemaInfo schema in command.Tds.Schema) {
DataRow row = schemaTable.NewRow ();
row ["ColumnName"] = GetSchemaValue (schema, "ColumnName");
row ["ColumnSize"] = GetSchemaValue (schema, "ColumnSize");
row ["ColumnOrdinal"] = GetSchemaValue (schema, "ColumnOrdinal");
row ["NumericPrecision"] = GetSchemaValue (schema, "NumericPrecision");
row ["NumericScale"] = GetSchemaValue (schema, "NumericScale");
row ["IsUnique"] = GetSchemaValue (schema, "IsUnique");
row ["IsKey"] = GetSchemaValue (schema, "IsKey");
row ["BaseServerName"] = GetSchemaValue (schema, "BaseServerName");
row ["BaseCatalogName"] = GetSchemaValue (schema, "BaseCatalogName");
row ["BaseColumnName"] = GetSchemaValue (schema, "BaseColumnName");
row ["BaseSchemaName"] = GetSchemaValue (schema, "BaseSchemaName");
row ["BaseTableName"] = GetSchemaValue (schema, "BaseTableName");
row ["AllowDBNull"] = GetSchemaValue (schema, "AllowDBNull");
row ["IsAliased"] = GetSchemaValue (schema, "IsAliased");
row ["IsExpression"] = GetSchemaValue (schema, "IsExpression");
row ["IsIdentity"] = GetSchemaValue (schema, "IsIdentity");
row ["IsAutoIncrement"] = GetSchemaValue (schema, "IsAutoIncrement");
row ["IsRowVersion"] = GetSchemaValue (schema, "IsRowVersion");
row ["IsHidden"] = GetSchemaValue (schema, "IsHidden");
row ["IsReadOnly"] = GetSchemaValue (schema, "IsReadOnly");
// We don't always get the base column name.
if (row ["BaseColumnName"] == DBNull.Value)
row ["BaseColumnName"] = row ["ColumnName"];
switch ((TdsColumnType) schema ["ColumnType"]) {
case TdsColumnType.Int1:
case TdsColumnType.Int2:
case TdsColumnType.Int4:
case TdsColumnType.IntN:
switch ((int) schema ["ColumnSize"]) {
case 1:
dataTypeNames.Add ("tinyint");
row ["ProviderType"] = (int) SqlDbType.TinyInt;
row ["DataType"] = typeof (byte);
row ["IsLong"] = false;
break;
case 2:
dataTypeNames.Add ("smallint");
row ["ProviderType"] = (int) SqlDbType.SmallInt;
row ["DataType"] = typeof (short);
row ["IsLong"] = false;
break;
case 4:
dataTypeNames.Add ("int");
row ["ProviderType"] = (int) SqlDbType.Int;
row ["DataType"] = typeof (int);
row ["IsLong"] = false;
break;
case 8:
dataTypeNames.Add ("bigint");
row ["ProviderType"] = (int) SqlDbType.BigInt;
row ["DataType"] = typeof (long);
row ["IsLong"] = false;
break;
}
break;
case TdsColumnType.Real:
case TdsColumnType.Float8:
case TdsColumnType.FloatN:
switch ((int) schema ["ColumnSize"]) {
case 4:
dataTypeNames.Add ("real");
row ["ProviderType"] = (int) SqlDbType.Real;
row ["DataType"] = typeof (float);
row ["IsLong"] = false;
break;
case 8:
dataTypeNames.Add ("float");
row ["ProviderType"] = (int) SqlDbType.Float;
row ["DataType"] = typeof (double);
row ["IsLong"] = false;
break;
}
break;
case TdsColumnType.Image :
dataTypeNames.Add ("image");
row ["ProviderType"] = (int) SqlDbType.Image;
row ["DataType"] = typeof (byte[]);
row ["IsLong"] = true;
break;
case TdsColumnType.Text :
dataTypeNames.Add ("text");
row ["ProviderType"] = (int) SqlDbType.Text;
row ["DataType"] = typeof (string);
row ["IsLong"] = true;
break;
case TdsColumnType.UniqueIdentifier :
dataTypeNames.Add ("uniqueidentifier");
row ["ProviderType"] = (int) SqlDbType.UniqueIdentifier;
row ["DataType"] = typeof (Guid);
row ["IsLong"] = false;
break;
case TdsColumnType.VarBinary :
case TdsColumnType.BigVarBinary :
dataTypeNames.Add ("varbinary");
row ["ProviderType"] = (int) SqlDbType.VarBinary;
row ["DataType"] = typeof (byte[]);
row ["IsLong"] = true;
break;
case TdsColumnType.VarChar :
case TdsColumnType.BigVarChar :
dataTypeNames.Add ("varchar");
row ["ProviderType"] = (int) SqlDbType.VarChar;
row ["DataType"] = typeof (string);
row ["IsLong"] = false;
break;
case TdsColumnType.Binary :
case TdsColumnType.BigBinary :
dataTypeNames.Add ("binary");
row ["ProviderType"] = (int) SqlDbType.Binary;
row ["DataType"] = typeof (byte[]);
row ["IsLong"] = true;
break;
case TdsColumnType.Char :
case TdsColumnType.BigChar :
dataTypeNames.Add ("char");
row ["ProviderType"] = (int) SqlDbType.Char;
row ["DataType"] = typeof (string);
row ["IsLong"] = false;
break;
case TdsColumnType.Bit :
case TdsColumnType.BitN :
dataTypeNames.Add ("bit");
row ["ProviderType"] = (int) SqlDbType.Bit;
row ["DataType"] = typeof (bool);
row ["IsLong"] = false;
break;
case TdsColumnType.DateTime4 :
case TdsColumnType.DateTime :
case TdsColumnType.DateTimeN :
dataTypeNames.Add ("datetime");
row ["ProviderType"] = (int) SqlDbType.DateTime;
row ["DataType"] = typeof (DateTime);
row ["IsLong"] = false;
break;
case TdsColumnType.Money :
case TdsColumnType.MoneyN :
case TdsColumnType.Money4 :
dataTypeNames.Add ("money");
row ["ProviderType"] = (int) SqlDbType.Money;
row ["DataType"] = typeof (decimal);
row ["IsLong"] = false;
break;
case TdsColumnType.NText :
dataTypeNames.Add ("ntext");
row ["ProviderType"] = (int) SqlDbType.NText;
row ["DataType"] = typeof (string);
row ["IsLong"] = true;
break;
case TdsColumnType.NVarChar :
dataTypeNames.Add ("nvarchar");
row ["ProviderType"] = (int) SqlDbType.NVarChar;
row ["DataType"] = typeof (string);
row ["IsLong"] = false;
break;
case TdsColumnType.Decimal :
case TdsColumnType.Numeric :
dataTypeNames.Add ("decimal");
row ["ProviderType"] = (int) SqlDbType.Decimal;
row ["DataType"] = typeof (decimal);
row ["IsLong"] = false;
break;
case TdsColumnType.NChar :
dataTypeNames.Add ("nchar");
row ["ProviderType"] = (int) SqlDbType.NChar;
row ["DataType"] = typeof (string);
row ["IsLong"] = false;
break;
case TdsColumnType.SmallMoney :
dataTypeNames.Add ("smallmoney");
row ["ProviderType"] = (int) SqlDbType.SmallMoney;
row ["DataType"] = typeof (decimal);
row ["IsLong"] = false;
break;
default :
dataTypeNames.Add ("variant");
row ["ProviderType"] = (int) SqlDbType.Variant;
row ["DataType"] = typeof (object);
row ["IsLong"] = false;
break;
}
schemaTable.Rows.Add (row);
fieldCount += 1;
}
return schemaTable;
}
private static object GetSchemaValue (TdsSchemaInfo schema, object key)
{
if (schema.ContainsKey (key) && schema [key] != null)
return schema [key];
return DBNull.Value;
}
public SqlBinary GetSqlBinary (int i)
{
throw new NotImplementedException ();
}
public SqlBoolean GetSqlBoolean (int i)
{
object value = GetSqlValue (i);
if (!(value is SqlBoolean))
throw new InvalidCastException ();
return (SqlBoolean) value;
}
public SqlByte GetSqlByte (int i)
{
object value = GetSqlValue (i);
if (!(value is SqlByte))
throw new InvalidCastException ();
return (SqlByte) value;
}
public SqlDateTime GetSqlDateTime (int i)
{
object value = GetSqlValue (i);
if (!(value is SqlDateTime))
throw new InvalidCastException ();
return (SqlDateTime) value;
}
public SqlDecimal GetSqlDecimal (int i)
{
object value = GetSqlValue (i);
if (!(value is SqlDecimal))
throw new InvalidCastException ();
return (SqlDecimal) value;
}
public SqlDouble GetSqlDouble (int i)
{
object value = GetSqlValue (i);
if (!(value is SqlDouble))
throw new InvalidCastException ();
return (SqlDouble) value;
}
public SqlGuid GetSqlGuid (int i)
{
object value = GetSqlValue (i);
if (!(value is SqlGuid))
throw new InvalidCastException ();
return (SqlGuid) value;
}
public SqlInt16 GetSqlInt16 (int i)
{
object value = GetSqlValue (i);
if (!(value is SqlInt16))
throw new InvalidCastException ();
return (SqlInt16) value;
}
public SqlInt32 GetSqlInt32 (int i)
{
object value = GetSqlValue (i);
if (!(value is SqlInt32))
throw new InvalidCastException ();
return (SqlInt32) value;
}
public SqlInt64 GetSqlInt64 (int i)
{
object value = GetSqlValue (i);
if (!(value is SqlInt64))
throw new InvalidCastException ();
return (SqlInt64) value;
}
public SqlMoney GetSqlMoney (int i)
{
object value = GetSqlValue (i);
if (!(value is SqlMoney))
throw new InvalidCastException ();
return (SqlMoney) value;
}
public SqlSingle GetSqlSingle (int i)
{
object value = GetSqlValue (i);
if (!(value is SqlSingle))
throw new InvalidCastException ();
return (SqlSingle) value;
}
public SqlString GetSqlString (int i)
{
object value = GetSqlValue (i);
if (!(value is SqlString))
throw new InvalidCastException ();
return (SqlString) value;
}
[MonoTODO ("Implement TdsBigDecimal conversion. SqlDbType.Real fails tests?")]
public object GetSqlValue (int i)
{
SqlDbType type = (SqlDbType) (schemaTable.Rows [i]["ProviderType"]);
object value = GetValue (i);
switch (type) {
case SqlDbType.BigInt:
if (value == null)
return SqlInt64.Null;
return (SqlInt64) ((long) value);
case SqlDbType.Binary:
case SqlDbType.Image:
case SqlDbType.VarBinary:
case SqlDbType.Timestamp:
if (value == null)
return SqlBinary.Null;
return (SqlBinary) ((byte[]) value);
case SqlDbType.Bit:
if (value == null)
return SqlBoolean.Null;
return (SqlBoolean) ((bool) value);
case SqlDbType.Char:
case SqlDbType.NChar:
case SqlDbType.NText:
case SqlDbType.NVarChar:
case SqlDbType.Text:
case SqlDbType.VarChar:
if (value == null)
return SqlString.Null;
return (SqlString) ((string) value);
case SqlDbType.DateTime:
case SqlDbType.SmallDateTime:
if (value == null)
return SqlDateTime.Null;
return (SqlDateTime) ((DateTime) value);
case SqlDbType.Decimal:
if (value == null)
return SqlDecimal.Null;
if (value is TdsBigDecimal)
return SqlDecimal.FromTdsBigDecimal ((TdsBigDecimal) value);
return (SqlDecimal) ((decimal) value);
case SqlDbType.Float:
if (value == null)
return SqlDouble.Null;
return (SqlDouble) ((double) value);
case SqlDbType.Int:
if (value == null)
return SqlInt32.Null;
return (SqlInt32) ((int) value);
case SqlDbType.Money:
case SqlDbType.SmallMoney:
if (value == null)
return SqlMoney.Null;
return (SqlMoney) ((decimal) value);
case SqlDbType.Real:
if (value == null)
return SqlSingle.Null;
return (SqlSingle) ((float) value);
case SqlDbType.UniqueIdentifier:
if (value == null)
return SqlGuid.Null;
return (SqlGuid) ((Guid) value);
case SqlDbType.SmallInt:
if (value == null)
return SqlInt16.Null;
return (SqlInt16) ((short) value);
case SqlDbType.TinyInt:
if (value == null)
return SqlByte.Null;
return (SqlByte) ((byte) value);
}
throw new InvalidOperationException ("The type of this column is unknown.");
}
public int GetSqlValues (object[] values)
{
int count = 0;
int columnCount = schemaTable.Rows.Count;
int arrayCount = values.Length;
if (arrayCount > columnCount)
count = columnCount;
else
count = arrayCount;
for (int i = 0; i < count; i += 1)
values [i] = GetSqlValue (i);
return count;
}
public string GetString (int i)
{
object value = GetValue (i);
if (!(value is string))
throw new InvalidCastException ();
return (string) value;
}
public object GetValue (int i)
{
return command.Tds.ColumnValues [i];
}
public int GetValues (object[] values)
{
int len = values.Length;
int bigDecimalIndex = command.Tds.ColumnValues.BigDecimalIndex;
// If a four-byte decimal is stored, then we can't convert to
// a native type. Throw an OverflowException.
if (bigDecimalIndex >= 0 && bigDecimalIndex < len)
throw new OverflowException ();
command.Tds.ColumnValues.CopyTo (0, values, 0, len);
return (len > FieldCount ? len : FieldCount);
}
void IDisposable.Dispose ()
{
Dispose (true);
GC.SuppressFinalize (this);
}
IEnumerator IEnumerable.GetEnumerator ()
{
return new DbEnumerator (this);
}
public bool IsDBNull (int i)
{
return GetValue (i) == null;
}
public bool NextResult ()
{
if ((command.CommandBehavior & CommandBehavior.SingleResult) != 0 && resultsRead > 0)
return false;
if (command.Tds.DoneProc)
return false;
schemaTable.Rows.Clear ();
moreResults = command.Tds.NextResult ();
GetSchemaTable ();
rowsRead = 0;
resultsRead += 1;
return moreResults;
}
public bool Read ()
{
if ((command.CommandBehavior & CommandBehavior.SingleRow) != 0 && rowsRead > 0)
return false;
if ((command.CommandBehavior & CommandBehavior.SchemaOnly) != 0)
return false;
if (!moreResults)
return false;
bool result = command.Tds.NextRow ();
rowsRead += 1;
return result;
}
#endregion // Methods
}
}