Files
mono/mcs/class/System.Data/System.Data.Odbc/OdbcDataReader.cs
T
Sureshkumar T 807abd8d52 2005-08-08 Sureshkumar T <[email protected]>
* OdbcDataReader.cs: Implemented Dispose pattern. Cache
	schematable for same result set. don't free command's statements
	if the command is prepared.

	* OdbcCommand.cs:
	- Implemented Dispose pattern
	- Streamlined the allocation and de-allocation of statement
	handles.


svn path=/trunk/mcs/; revision=48120
2005-08-08 13:02:16 +00:00

1010 lines
30 KiB
C#

//
// System.Data.Odbc.OdbcDataReader
//
// Author:
// Brian Ritchie ([email protected])
// Daniel Morgan <[email protected]>
// Sureshkumar T <[email protected]> (2004)
//
// Copyright (C) Brian Ritchie, 2002
// Copyright (C) Daniel Morgan, 2002
//
//
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
//
// 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.Collections;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
#if NET_2_0
using System.Data.ProviderBase;
#endif // NET_2_0
using System.Text;
namespace System.Data.Odbc
{
#if NET_2_0
public sealed class OdbcDataReader : DbDataReaderBase
#else
public sealed class OdbcDataReader : MarshalByRefObject, IDataReader, IDisposable, IDataRecord, IEnumerable
#endif
{
#region Fields
private OdbcCommand command;
private bool open;
private int currentRow;
private OdbcColumn[] cols;
private IntPtr hstmt;
private int _recordsAffected = -1;
bool disposed = false;
private DataTable _dataTableSchema;
#if ONLY_1_1
private CommandBehavior behavior;
#endif // ONLY_1_1
#endregion
#region Constructors
internal OdbcDataReader (OdbcCommand command, CommandBehavior behavior)
#if NET_2_0
: base (behavior)
#endif // NET_2_0
{
this.command = command;
#if ONLY_1_1
this.CommandBehavior=behavior;
#endif // ONLY_1_1
open = true;
currentRow = -1;
hstmt=command.hStmt;
// Init columns array;
short colcount=0;
libodbc.SQLNumResultCols(hstmt, ref colcount);
cols=new OdbcColumn[colcount];
GetSchemaTable ();
}
internal OdbcDataReader (OdbcCommand command, CommandBehavior behavior,
int recordAffected) : this (command, behavior)
{
_recordsAffected = recordAffected;
}
#endregion
#region Properties
#if ONLY_1_1
private CommandBehavior CommandBehavior
{
get { return behavior; }
set { value = behavior; }
}
#endif // ONLY_1_1
#if NET_2_0
[MonoTODO]
public override int VisibleFieldCount
{
get { throw new NotImplementedException (); }
}
[MonoTODO]
protected override bool IsValidRow
{
get { throw new NotImplementedException (); }
}
#endif // NET_2_0
public
#if NET_2_0
override
#endif // NET_2_0
int Depth {
get {
return 0; // no nested selects supported
}
}
public
#if NET_2_0
override
#endif // NET_2_0
int FieldCount {
get {
return cols.Length;
}
}
public
#if NET_2_0
override
#endif // NET_2_0
bool IsClosed {
get {
return !open;
}
}
public
#if NET_2_0
override
#endif // NET_2_0
object this[string name] {
get {
int pos;
if (currentRow == -1)
throw new InvalidOperationException ();
pos = ColIndex(name);
if (pos == -1)
throw new IndexOutOfRangeException ();
return this[pos];
}
}
public
#if NET_2_0
override
#endif // NET_2_0
object this[int index] {
get {
return (object) GetValue (index);
}
}
[MonoTODO]
public
#if NET_2_0
override
#endif // NET_2_0
int RecordsAffected {
get {
return _recordsAffected;
}
}
[MonoTODO]
public
#if NET_2_0
override
#endif // NET_2_0
bool HasRows {
get { throw new NotImplementedException(); }
}
#endregion
#region Methods
private int ColIndex(string colname)
{
int i=0;
foreach (OdbcColumn col in cols)
{
if (col != null) {
if (col.ColumnName == colname)
return i;
if (String.Compare (col.ColumnName, colname, true) == 0)
return i;
}
i++;
}
return -1;
}
// Dynamically load column descriptions as needed.
private OdbcColumn GetColumn(int ordinal)
{
if (cols[ordinal]==null)
{
short bufsize=255;
byte[] colname_buffer=new byte[bufsize];
string colname;
short colname_size=0;
uint ColSize=0;
short DecDigits=0, Nullable=0, dt=0;
OdbcReturn ret=libodbc.SQLDescribeCol(hstmt, Convert.ToUInt16(ordinal+1),
colname_buffer, bufsize, ref colname_size, ref dt, ref ColSize,
ref DecDigits, ref Nullable);
if ((ret!=OdbcReturn.Success) && (ret!=OdbcReturn.SuccessWithInfo))
throw new OdbcException(new OdbcError("SQLDescribeCol",OdbcHandleType.Stmt,hstmt));
colname=System.Text.Encoding.Default.GetString(colname_buffer);
colname=colname.Replace((char) 0,' ').Trim();
OdbcColumn c=new OdbcColumn(colname, (SQL_TYPE) dt);
c.AllowDBNull=(Nullable!=0);
c.Digits=DecDigits;
if (c.IsStringType)
c.MaxLength=(int)ColSize;
cols[ordinal]=c;
}
return cols[ordinal];
}
public
#if NET_2_0
override
#endif // NET_2_0
void Close ()
{
// FIXME : have to implement output parameter binding
open = false;
currentRow = -1;
this.command.FreeIfNotPrepared ();
if ((this.CommandBehavior & CommandBehavior.CloseConnection)==CommandBehavior.CloseConnection) {
this.command.Connection.Close();
}
}
~OdbcDataReader ()
{
this.Dispose (false);
}
public
#if NET_2_0
override
#endif // NET_2_0
bool GetBoolean (int ordinal)
{
return (bool) GetValue(ordinal);
}
public
#if NET_2_0
override
#endif // NET_2_0
byte GetByte (int ordinal)
{
return (byte) Convert.ToByte(GetValue(ordinal));
}
public
#if NET_2_0
override
#endif // NET_2_0
long GetBytes (int ordinal, long dataIndex, byte[] buffer, int bufferIndex, int length)
{
OdbcReturn ret = OdbcReturn.Error;
bool copyBuffer = false;
int returnVal = 0, outsize = 0;
byte [] tbuff = new byte [length+1];
length = buffer == null ? 0 : length;
ret=libodbc.SQLGetData (hstmt, (ushort) (ordinal+1), SQL_C_TYPE.BINARY, tbuff, length,
ref outsize);
if (ret == OdbcReturn.NoData)
return 0;
if ( (ret != OdbcReturn.Success) && (ret != OdbcReturn.SuccessWithInfo))
throw new OdbcException (new OdbcError ("SQLGetData", OdbcHandleType.Stmt, hstmt));
OdbcError odbcErr = null;
if ( (ret == OdbcReturn.SuccessWithInfo))
odbcErr = new OdbcError ("SQLGetData", OdbcHandleType.Stmt, hstmt);
if (buffer == null)
return outsize; //if buffer is null,return length of the field
if (ret == OdbcReturn.SuccessWithInfo) {
if (outsize == (int) OdbcLengthIndicator.NoTotal)
copyBuffer = true;
else if (outsize == (int) OdbcLengthIndicator.NullData) {
copyBuffer = false;
returnVal = -1;
} else {
string sqlstate = odbcErr.SQLState;
//SQLState: String Data, Right truncated
if (sqlstate != libodbc.SQLSTATE_RIGHT_TRUNC)
throw new OdbcException ( odbcErr);
copyBuffer = true;
}
} else {
copyBuffer = outsize == -1 ? false : true;
returnVal = outsize;
}
if (copyBuffer) {
int i = 0;
while (tbuff [i] != libodbc.C_NULL) {
buffer [bufferIndex + i] = tbuff [i];
i++;
}
returnVal = i;
}
return returnVal;
}
[MonoTODO]
public
#if NET_2_0
override
#endif // NET_2_0
char GetChar (int ordinal)
{
throw new NotImplementedException ();
}
[MonoTODO]
public
#if NET_2_0
override
#endif // NET_2_0
long GetChars (int ordinal, long dataIndex, char[] buffer, int bufferIndex, int length)
{
throw new NotImplementedException ();
}
[MonoTODO]
[EditorBrowsableAttribute (EditorBrowsableState.Never)]
public
#if NET_2_0
new
#endif // NET_2_0
IDataReader GetData (int ordinal)
{
throw new NotImplementedException ();
}
public
#if NET_2_0
override
#endif // NET_2_0
string GetDataTypeName (int index)
{
return GetColumn(index).OdbcType.ToString();
}
public DateTime GetDate(int ordinal) {
return GetDateTime(ordinal);
}
public
#if NET_2_0
override
#endif // NET_2_0
DateTime GetDateTime (int ordinal)
{
return (DateTime) GetValue(ordinal);
}
[MonoTODO]
public
#if NET_2_0
override
#endif // NET_2_0
decimal GetDecimal (int ordinal)
{
throw new NotImplementedException ();
}
public
#if NET_2_0
override
#endif // NET_2_0
double GetDouble (int ordinal)
{
return (double) GetValue(ordinal);
}
public
#if NET_2_0
override
#endif // NET_2_0
Type GetFieldType (int index)
{
return GetColumn(index).DataType;
}
public
#if NET_2_0
override
#endif // NET_2_0
float GetFloat (int ordinal)
{
return (float) GetValue(ordinal);
}
[MonoTODO]
public
#if NET_2_0
override
#endif // NET_2_0
Guid GetGuid (int ordinal)
{
throw new NotImplementedException ();
}
public
#if NET_2_0
override
#endif // NET_2_0
short GetInt16 (int ordinal)
{
return (short) GetValue(ordinal);
}
public
#if NET_2_0
override
#endif // NET_2_0
int GetInt32 (int ordinal)
{
return (int) GetValue(ordinal);
}
public
#if NET_2_0
override
#endif // NET_2_0
long GetInt64 (int ordinal)
{
return (long) GetValue(ordinal);
}
public
#if NET_2_0
override
#endif // NET_2_0
string GetName (int index)
{
return GetColumn(index).ColumnName;
}
public
#if NET_2_0
override
#endif // NET_2_0
int GetOrdinal (string name)
{
int i=ColIndex(name);
if (i==-1)
throw new IndexOutOfRangeException ();
else
return i;
}
[MonoTODO]
public
#if NET_2_0
override
#endif // NET_2_0
DataTable GetSchemaTable()
{
// FIXME :
// * Map OdbcType to System.Type and assign to DataType.
// This will eliminate the need for IsStringType in
// OdbcColumn.
if (_dataTableSchema != null)
return _dataTableSchema;
DataTable dataTableSchema = null;
// Only Results from SQL SELECT Queries
// get a DataTable for schema of the result
// otherwise, DataTable is null reference
if(cols.Length > 0)
{
string [] keys = GetPrimaryKeys ();
dataTableSchema = new DataTable ();
dataTableSchema.Columns.Add ("ColumnName", typeof (string));
dataTableSchema.Columns.Add ("ColumnOrdinal", typeof (int));
dataTableSchema.Columns.Add ("ColumnSize", typeof (int));
dataTableSchema.Columns.Add ("NumericPrecision", typeof (int));
dataTableSchema.Columns.Add ("NumericScale", typeof (int));
dataTableSchema.Columns.Add ("IsUnique", typeof (bool));
dataTableSchema.Columns.Add ("IsKey", typeof (bool));
DataColumn dc = dataTableSchema.Columns["IsKey"];
dc.AllowDBNull = true; // IsKey can have a DBNull
dataTableSchema.Columns.Add ("BaseCatalogName", typeof (string));
dataTableSchema.Columns.Add ("BaseColumnName", typeof (string));
dataTableSchema.Columns.Add ("BaseSchemaName", typeof (string));
dataTableSchema.Columns.Add ("BaseTableName", typeof (string));
dataTableSchema.Columns.Add ("DataType", typeof(Type));
dataTableSchema.Columns.Add ("AllowDBNull", typeof (bool));
dataTableSchema.Columns.Add ("ProviderType", typeof (int));
dataTableSchema.Columns.Add ("IsAliased", typeof (bool));
dataTableSchema.Columns.Add ("IsExpression", typeof (bool));
dataTableSchema.Columns.Add ("IsIdentity", typeof (bool));
dataTableSchema.Columns.Add ("IsAutoIncrement", typeof (bool));
dataTableSchema.Columns.Add ("IsRowVersion", typeof (bool));
dataTableSchema.Columns.Add ("IsHidden", typeof (bool));
dataTableSchema.Columns.Add ("IsLong", typeof (bool));
dataTableSchema.Columns.Add ("IsReadOnly", typeof (bool));
DataRow schemaRow;
for (int i = 0; i < cols.Length; i += 1 )
{
string baseTableName = String.Empty;
bool isKey = false;
OdbcColumn col=GetColumn(i);
schemaRow = dataTableSchema.NewRow ();
dataTableSchema.Rows.Add (schemaRow);
schemaRow["ColumnName"] = col.ColumnName;
schemaRow["ColumnOrdinal"] = i;
schemaRow["ColumnSize"] = col.MaxLength;
schemaRow["NumericPrecision"] = GetColumnAttribute (i+1, FieldIdentifier.Precision);
schemaRow["NumericScale"] = GetColumnAttribute (i+1, FieldIdentifier.Scale);
schemaRow["IsUnique"] = false;
schemaRow["IsKey"] = DBNull.Value;
for (int j=0; j < keys.Length; j++) {
if (keys [j] == col.ColumnName) {
schemaRow ["IsUnique"] = true;
schemaRow ["IsKey"] = (isKey = true);
col.AllowDBNull = false;
}
}
schemaRow["BaseCatalogName"] = "";
schemaRow["BaseColumnName"] = "";
schemaRow["BaseSchemaName"] = "";
try {
baseTableName = GetColumnAttributeStr (i+1, FieldIdentifier.BaseTableName);
schemaRow["BaseColumnName"] = GetColumnAttributeStr (i+1, FieldIdentifier.BaseColumnName);
} catch (Exception) {}
schemaRow["BaseTableName"] = baseTableName;
schemaRow["DataType"] = col.DataType;
schemaRow["AllowDBNull"] = isKey ? false : true ;
schemaRow["ProviderType"] = (int) col.OdbcType;
// TODO: all of these
schemaRow["IsAliased"] = false;
schemaRow["IsExpression"] = baseTableName == String.Empty;
schemaRow["IsIdentity"] = false;
schemaRow["IsAutoIncrement"] = GetColumnAttribute (i+1, FieldIdentifier.AutoUniqueValue) == 1;
schemaRow["IsRowVersion"] = false;
schemaRow["IsHidden"] = false;
schemaRow["IsLong"] = false;
schemaRow["IsReadOnly"] = false;
// FIXME: according to Brian,
// this does not work on MS .NET
// however, we need it for Mono
// for now
schemaRow.AcceptChanges();
}
dataTableSchema.AcceptChanges();
}
return (_dataTableSchema = dataTableSchema);
}
public
#if NET_2_0
override
#endif // NET_2_0
string GetString (int ordinal)
{
return (string) GetValue(ordinal);
}
[MonoTODO]
public TimeSpan GetTime (int ordinal)
{
throw new NotImplementedException ();
}
public
#if NET_2_0
override
#endif // NET_2_0
object GetValue (int ordinal)
{
if (currentRow == -1)
throw new IndexOutOfRangeException ();
if (ordinal>cols.Length-1 || ordinal<0)
throw new IndexOutOfRangeException ();
OdbcReturn ret;
int outsize=0, bufsize;
byte[] buffer;
OdbcColumn col=GetColumn(ordinal);
object DataValue=null;
ushort ColIndex=Convert.ToUInt16(ordinal+1);
// Check cached values
if (col.Value==null) {
// odbc help file
// mk:@MSITStore:C:\program%20files\Microsoft%20Data%20Access%20SDK\Docs\odbc.chm::/htm/odbcc_data_types.htm
switch (col.OdbcType) {
case OdbcType.Bit:
short bit_data = 0;
ret=libodbc.SQLGetData(hstmt, ColIndex, col.SqlCType, ref bit_data, 0, ref outsize);
if (outsize != (int) OdbcLengthIndicator.NullData)
DataValue = bit_data == 0 ? "False" : "True";
break;
case OdbcType.Numeric:
case OdbcType.Decimal:
bufsize=50;
buffer=new byte[bufsize]; // According to sqlext.h, use SQL_CHAR for decimal.
ret=libodbc.SQLGetData(hstmt, ColIndex, col.SqlCType, buffer, bufsize, ref outsize);
if (outsize!=-1) {
byte[] temp = new byte[outsize];
for (int i=0;i<outsize;i++)
temp[i]=buffer[i];
DataValue=Decimal.Parse(System.Text.Encoding.Default.GetString(temp));
}
break;
case OdbcType.TinyInt:
short short_data=0;
ret=libodbc.SQLGetData(hstmt, ColIndex, col.SqlCType, ref short_data, 0, ref outsize);
DataValue=System.Convert.ToByte(short_data);
break;
case OdbcType.Int:
int int_data=0;
ret=libodbc.SQLGetData(hstmt, ColIndex, col.SqlCType, ref int_data, 0, ref outsize);
DataValue=int_data;
break;
case OdbcType.SmallInt:
short sint_data=0;
ret=libodbc.SQLGetData(hstmt, ColIndex, col.SqlCType, ref sint_data, 0, ref outsize);
DataValue=sint_data;
break;
case OdbcType.BigInt:
long long_data=0;
ret=libodbc.SQLGetData(hstmt, ColIndex, col.SqlCType, ref long_data, 0, ref outsize);
DataValue=long_data;
break;
case OdbcType.NVarChar:
bufsize=col.MaxLength*2+1; // Unicode is double byte
buffer=new byte[bufsize];
ret=libodbc.SQLGetData(hstmt, ColIndex, col.SqlCType, buffer, bufsize, ref outsize);
if (outsize!=-1)
DataValue=System.Text.Encoding.Unicode.GetString(buffer,0,outsize);
break;
case OdbcType.VarChar:
bufsize=col.MaxLength+1;
buffer=new byte[bufsize]; // According to sqlext.h, use SQL_CHAR for both char and varchar
ret=libodbc.SQLGetData(hstmt, ColIndex, col.SqlCType, buffer, bufsize, ref outsize);
if (outsize!=-1)
DataValue=System.Text.Encoding.Default.GetString(buffer,0,outsize);
break;
case OdbcType.Real:
float float_data=0;
ret=libodbc.SQLGetData(hstmt, ColIndex, col.SqlCType, ref float_data, 0, ref outsize);
DataValue=float_data;
break;
case OdbcType.Double:
double double_data=0;
ret=libodbc.SQLGetData(hstmt, ColIndex, col.SqlCType, ref double_data, 0, ref outsize);
DataValue=double_data;
break;
case OdbcType.Timestamp:
case OdbcType.DateTime:
case OdbcType.Date:
case OdbcType.Time:
OdbcTimestamp ts_data=new OdbcTimestamp();
ret=libodbc.SQLGetData(hstmt, ColIndex, col.SqlCType, ref ts_data, 0, ref outsize);
if (outsize!=-1) // This means SQL_NULL_DATA
DataValue=new DateTime(ts_data.year,ts_data.month,ts_data.day,ts_data.hour,
ts_data.minute,ts_data.second,Convert.ToInt32(ts_data.fraction));
break;
case OdbcType.Binary :
case OdbcType.Image :
bufsize = col.MaxLength + 1;
buffer = new byte [bufsize];
long read = GetBytes (ordinal, 0, buffer, 0, bufsize);
ret = OdbcReturn.Success;
DataValue = buffer;
break;
default:
bufsize=255;
buffer=new byte[bufsize];
ret=libodbc.SQLGetData(hstmt, ColIndex, SQL_C_TYPE.CHAR, buffer, bufsize, ref outsize);
if (outsize != (int) OdbcLengthIndicator.NullData)
if (! (ret == OdbcReturn.SuccessWithInfo
&& outsize == (int) OdbcLengthIndicator.NoTotal))
DataValue=System.Text.Encoding.Default.GetString(buffer, 0, outsize);
break;
}
if ((ret!=OdbcReturn.Success) && (ret!=OdbcReturn.SuccessWithInfo))
throw new OdbcException(new OdbcError("SQLGetData",OdbcHandleType.Stmt,hstmt));
if (outsize==-1) // This means SQL_NULL_DATA
col.Value=DBNull.Value;
else
col.Value=DataValue;
}
return col.Value;
}
public
#if NET_2_0
override
#endif // NET_2_0
int GetValues (object[] values)
{
int numValues = 0;
// copy values
for (int i = 0; i < values.Length; i++) {
if (i < FieldCount) {
values[i] = GetValue(i);
}
else {
values[i] = null;
}
}
// get number of object instances in array
if (values.Length < FieldCount)
numValues = values.Length;
else if (values.Length == FieldCount)
numValues = FieldCount;
else
numValues = FieldCount;
return numValues;
}
#if ONLY_1_1
[MonoTODO]
IDataReader IDataRecord.GetData (int ordinal)
{
throw new NotImplementedException ();
}
#if ONLY_1_1
void IDisposable.Dispose ()
{
Dispose (true);
GC.SuppressFinalize (this);
}
#else
public override void Dispose ()
{
Dispose (true);
GC.SuppressFinalize (this);
}
#endif
IEnumerator IEnumerable.GetEnumerator ()
{
return new DbEnumerator (this);
}
#endif // ONLY_1_1
private void Dispose (bool disposing)
{
if (disposed)
return;
if (disposing) {
// dispose managed resources
Close ();
}
command = null;
cols = null;
_dataTableSchema = null;
disposed = true;
}
public
#if NET_2_0
override
#endif // NET_2_0
bool IsDBNull (int ordinal)
{
return (GetValue(ordinal) is DBNull);
}
/// <remarks>
/// Move to the next result set.
/// </remarks>
public
#if NET_2_0
override
#endif // NET_2_0
bool NextResult ()
{
OdbcReturn ret = OdbcReturn.Success;
ret = libodbc.SQLMoreResults (hstmt);
if (ret == OdbcReturn.Success) {
short colcount = 0;
libodbc.SQLNumResultCols (hstmt, ref colcount);
cols = new OdbcColumn [colcount];
_dataTableSchema = null; // force fresh creation
GetSchemaTable ();
}
return (ret==OdbcReturn.Success);
}
/// <remarks>
/// Load the next row in the current result set.
/// </remarks>
private bool NextRow ()
{
OdbcReturn ret=libodbc.SQLFetch (hstmt);
if (ret != OdbcReturn.Success)
currentRow = -1;
else
currentRow++;
// Clear cached values from last record
foreach (OdbcColumn col in cols)
{
if (col != null)
col.Value = null;
}
return (ret == OdbcReturn.Success);
}
private int GetColumnAttribute (int column, FieldIdentifier fieldId)
{
OdbcReturn ret = OdbcReturn.Error;
byte [] buffer = new byte [255];
int outsize = 0;
int val = 0;
ret = libodbc.SQLColAttribute (hstmt, column, fieldId,
buffer, buffer.Length,
ref outsize, ref val);
if (ret != OdbcReturn.Success && ret != OdbcReturn.SuccessWithInfo)
throw new OdbcException (new OdbcError ("SQLColAttribute",
OdbcHandleType.Stmt,
hstmt)
);
return val;
}
private string GetColumnAttributeStr (int column, FieldIdentifier fieldId)
{
OdbcReturn ret = OdbcReturn.Error;
byte [] buffer = new byte [255];
int outsize = 0;
int val = 0;
ret = libodbc.SQLColAttribute (hstmt, column, fieldId,
buffer, buffer.Length,
ref outsize, ref val);
if (ret != OdbcReturn.Success && ret != OdbcReturn.SuccessWithInfo)
throw new OdbcException (new OdbcError ("SQLColAttribute",
OdbcHandleType.Stmt,
hstmt)
);
string value = "";
if (outsize > 0)
value = Encoding.Default.GetString (buffer, 0, outsize);
return value;
}
private string [] GetPrimaryKeys ()
{
if (cols.Length <= 0)
return new string [0];
ArrayList keys = new ArrayList ();
IntPtr handle = IntPtr.Zero;
OdbcReturn ret = OdbcReturn.Error;
try {
ret=libodbc.SQLAllocHandle(OdbcHandleType.Stmt,
command.Connection.hDbc, ref handle);
if ((ret!=OdbcReturn.Success) && (ret!=OdbcReturn.SuccessWithInfo))
throw new OdbcException(new OdbcError("SQLAllocHandle",
OdbcHandleType.Dbc,
command.Connection.hDbc));
string tableName = GetColumnAttributeStr (1, FieldIdentifier.TableName);
string schemaName = GetColumnAttributeStr (1, FieldIdentifier.SchemaName);
string catalogName = GetColumnAttributeStr (1, FieldIdentifier.CatelogName);
ret = libodbc.SQLPrimaryKeys (handle, catalogName, -3,
schemaName, -3,
tableName, -3);
if (ret != OdbcReturn.Success && ret != OdbcReturn.SuccessWithInfo)
throw new OdbcException (new OdbcError ("SQLPrimaryKeys", OdbcHandleType.Stmt, handle));
int length = 0;
byte [] primaryKey = new byte [255];
ret = libodbc.SQLBindCol (handle, 4, SQL_C_TYPE.CHAR, primaryKey, primaryKey.Length, ref length);
if (ret != OdbcReturn.Success && ret != OdbcReturn.SuccessWithInfo)
throw new OdbcException (new OdbcError ("SQLBindCol", OdbcHandleType.Stmt, handle));
int i = 0;
while (true) {
ret = libodbc.SQLFetch (handle);
if (ret != OdbcReturn.Success && ret != OdbcReturn.SuccessWithInfo)
break;
string pkey = Encoding.Default.GetString (primaryKey, 0, length);
keys.Add (pkey);
}
} catch (OdbcException){
// FIXME: Try using SQLStatistics
} finally {
if (handle != IntPtr.Zero) {
ret = libodbc.SQLFreeStmt (handle, libodbc.SQLFreeStmtOptions.Close);
if ((ret!=OdbcReturn.Success) && (ret!=OdbcReturn.SuccessWithInfo))
throw new OdbcException(new OdbcError("SQLFreeStmt",OdbcHandleType.Stmt,handle));
ret = libodbc.SQLFreeHandle( (ushort) OdbcHandleType.Stmt, handle);
if ((ret!=OdbcReturn.Success) && (ret!=OdbcReturn.SuccessWithInfo))
throw new OdbcException(new OdbcError("SQLFreeHandle",OdbcHandleType.Stmt,handle));
}
}
return (string []) keys.ToArray (typeof (string));
}
public
#if NET_2_0
override
#endif // NET_2_0
bool Read ()
{
return NextRow ();
}
#if NET_2_0
[MonoTODO]
public override object GetProviderSpecificValue (int i)
{
throw new NotImplementedException ();
}
[MonoTODO]
public override int GetProviderSpecificValues (object[] values)
{
throw new NotImplementedException ();
}
[MonoTODO]
public override Type GetFieldProviderSpecificType (int i)
{
throw new NotImplementedException ();
}
#endif // NET_2_0
#endregion
}
}