mcs/class/IBM.Data.DB2/IBM.Data.DB2/DB2DataReader.cs

   1
   2 //
   3 // Permission is hereby granted, free of charge, to any person obtaining
   4 // a copy of this software and associated documentation files (the
   5 // "Software"), to deal in the Software without restriction, including
   6 // without limitation the rights to use, copy, modify, merge, publish,
   7 // distribute, sublicense, and/or sell copies of the Software, and to
   8 // permit persons to whom the Software is furnished to do so, subject to
   9 // the following conditions:
  10 //
  11 // The above copyright notice and this permission notice shall be
  12 // included in all copies or substantial portions of the Software.
  13 //
  14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  15 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  16 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  17 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  18 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  19 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  20 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21 //
  22 using System;
  23 using System.Collections;
  24 using System.Data;
  25 using System.Runtime.InteropServices;
  26 using System.Globalization;
  27 using System.Text;
  28
  29 namespace IBM.Data.DB2
  30 {
  31         /// <summary>
  32         /// Summary description for DB2ClientDataReader.
  33         /// DB2ClientDataReader.
  34         /// </summary>
  35         public sealed class DB2DataReader : MarshalByRefObject, IDataReader
  36         {
  37                 private struct ColumnInfo
  38                 {
  39                         public string   Colname;
  40                         public int              Sqltype;
  41                 }
  42
  43                 private object[] _resultSet;
  44                 private ColumnInfo[] columnInfo;
  45                 private Hashtable columnsNames;
  46                 private const int internalBufferSize = 100;
  47                 private IntPtr internalBuffer;
  48                 internal DB2Connection db2Conn;
  49                 internal DB2Command db2Comm;
  50                 internal IntPtr hwndStmt;
  51                 private int recordsAffected;
  52                 private bool hasData = false;
  53                 private int fieldCount = -1;
  54                 private CommandBehavior behavior;
  55                 private bool hasRows;
  56                 private bool skipReadOnce;
  57
  58
  59                 #region Constructors and destructors
  60                 /// <summary>
  61                 ///
  62                 /// </summary>
  63                 /// <param name="con"></Connection object to Db2>
  64                 /// <param name="com"></Command object>
  65                 internal DB2DataReader(DB2Connection con, DB2Command com, CommandBehavior behavior)
  66                 {
  67                         db2Conn = con;
  68                         db2Comm = com;
  69                         this.behavior = behavior;
  70                         hwndStmt = com.statementHandle;    //We have access to the results through the statement handle
  71
  72                         _resultSet = null;
  73
  74                         GetFieldCountAndAffectedRows();
  75                         internalBuffer = Marshal.AllocHGlobal(internalBufferSize);
  76
  77                         isClosed = false;
  78                 }
  79
  80                 #endregion
  81
  82                 private void GetFieldCountAndAffectedRows()
  83                 {
  84                         short sqlRet;
  85                         recordsAffected = -1;
  86                         if((behavior & CommandBehavior.SchemaOnly) == 0)
  87                         {
  88                                 //How many rows affected.  numRows will be -1 if we aren't dealing with an Insert, Delete or Update, or if the statement did not execute successfully
  89                                 sqlRet = DB2CLIWrapper.SQLRowCount(hwndStmt, out recordsAffected);
  90                                 DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "SQLExecDirect error.", db2Conn);
  91                         }
  92                         short colCount;
  93                         sqlRet = DB2CLIWrapper.SQLNumResultCols(hwndStmt, out colCount);
  94                         DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "DB2ClientDataReader - SQLNumResultCols", db2Conn);
  95                         fieldCount = colCount;
  96                 }
  97
  98                 #region Properties
  99
 100                 #region Depth property
 101                 ///
 102                 ///Depth of nesting for the current row, need to figure out what this translates into
 103                 ///with DB2.
 104                 ///
 105                 private int depth = 0;
 106                 public int Depth
 107                 {
 108                         get
 109                         {
 110                                 if(isClosed)
 111                                 {
 112                                         throw new InvalidOperationException("Reader is closed");
 113                                 }
 114                                 return depth;
 115                         }
 116                 }
 117                 #endregion
 118
 119                 #region IsClosed property
 120                 /// <summary>
 121                 /// True if the reader is closed.
 122                 /// </summary>
 123                 private bool isClosed = true;
 124                 public bool IsClosed
 125                 {
 126                         get
 127                         {
 128                                 return isClosed;
 129                         }
 130                 }
 131                 #endregion
 132
 133                 #region RecordsAffected property
 134                 ///
 135                 /// Number of records affected by this operation.  Will be zero until we close the
 136                 /// reader
 137                 ///
 138
 139                 public int RecordsAffected
 140                 {
 141                         get
 142                         {
 143                                 return recordsAffected;
 144                         }
 145                 }
 146                 #endregion
 147
 148                 #endregion
 149
 150                 #region Methods
 151
 152
 153
 154                 #region Close method
 155
 156                 public void Close()
 157                 {
 158                         Dispose();
 159                 }
 160
 161                 public void Dispose()
 162                 {
 163                         Dispose(true);
 164                         GC.SuppressFinalize(this);
 165                 }
 166
 167                 void Dispose(bool disposing)
 168                 {
 169                         if(!isClosed)
 170                         {
 171                                 if(disposing)
 172                                 {
 173                                         short sqlRet;
 174                                         do
 175                                         {
 176                                                 sqlRet = DB2CLIWrapper.SQLMoreResults(this.hwndStmt);
 177                                                 DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "Db2ClientDataReader - SQLMoreResults", db2Conn);
 178                                         } while(sqlRet != DB2Constants.SQL_NO_DATA_FOUND);
 179
 180                                         _resultSet = null;
 181                                         hasData = false;
 182                                         isClosed=true;
 183
 184                                         if(db2Comm != null)
 185                                         {
 186                                                 db2Comm.DataReaderClosed();
 187                                                 db2Comm = null;
 188                                         }
 189                                 }
 190                                 Marshal.FreeHGlobal(internalBuffer);
 191                         }
 192                         isClosed = true;
 193                 }
 194
 195                 ~DB2DataReader()
 196                 {
 197                         Dispose(false);
 198                 }
 199
 200                 #endregion
 201
 202                 #region GetSchemaTable
 203
 204                 public DataTable GetSchemaTable()
 205                 {
 206                         if(isClosed)
 207                         {
 208                                 throw new InvalidOperationException("No data exists for the row/column.");
 209                         }
 210
 211                         DataTable _schemaTable = BuildNewSchemaTable();
 212
 213                         short sqlRet;
 214                         IntPtr ptrCharacterAttribute = IntPtr.Zero;
 215                         InitMem(256, ref ptrCharacterAttribute);
 216                         short buflen = 256;
 217                         short strlen = 256;
 218                         int numericattr = 0;
 219                         int colsize;
 220                         string colname;
 221                         int sqltype;
 222                         int precision;
 223                         int scale;
 224                         int nullable;
 225                         int updatable;
 226                         int isautoincrement;
 227                         string baseschemaname;
 228                         //string basecatalogname;
 229                         string basetablename;
 230                         string basecolumnname;
 231
 232                         string previousTableName = null;
 233                         string previousSchemaName = null;
 234                         bool differentTablesUsed = false;
 235
 236                         for (short i=1; i<=fieldCount; i++)
 237                         {
 238                                 sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_COLUMN_NAME, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
 239                                 DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
 240                                 colname = Marshal.PtrToStringUni(ptrCharacterAttribute);
 241
 242                                 sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_CONCISE_TYPE, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
 243                                 DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
 244                                 sqltype = numericattr;
 245
 246                                 sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_OCTET_LENGTH, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
 247                                 DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
 248                                 colsize = numericattr;
 249
 250                                 sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_PRECISION, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
 251                                 DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
 252                                 precision = numericattr;
 253
 254                                 sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_SCALE, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
 255                                 DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
 256                                 scale = numericattr;
 257
 258                                 sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_NULLABLE, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
 259                                 DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
 260                                 nullable = numericattr;
 261
 262                                 sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_UPDATABLE, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
 263                                 DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
 264                                 updatable = numericattr;
 265
 266                                 sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_AUTO_UNIQUE_VALUE, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
 267                                 DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
 268                                 isautoincrement = numericattr;
 269
 270                                 sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_BASE_COLUMN_NAME, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
 271                                 DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
 272                                 basecolumnname = Marshal.PtrToStringUni(ptrCharacterAttribute);
 273
 274                                 sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_BASE_TABLE_NAME, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
 275                                 DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
 276                                 basetablename = Marshal.PtrToStringUni(ptrCharacterAttribute);
 277
 278                                 sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_SCHEMA_NAME, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
 279                                 DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
 280                                 baseschemaname = Marshal.PtrToStringUni(ptrCharacterAttribute);
 281                                 DataRow r = _schemaTable.NewRow();
 282
 283                                 r["ColumnName"] = colname;
 284                                 r["ColumnOrdinal"] = i - 1;
 285                                 r["ColumnSize"] = colsize;
 286                                 r["NumericPrecision"] = precision;
 287                                 r["NumericScale"] = scale;
 288                                 r["DataType"] = GetManagedType((short)sqltype);
 289                                 r["ProviderType"] = sqltype;
 290                                 r["IsLong"] = IsLong((short)sqltype);
 291                                 r["AllowDBNull"] = (nullable==0) ? false : true;
 292                                 r["IsReadOnly"] = (basecolumnname == null) || (basecolumnname == "");
 293                                 r["IsRowVersion"] = false;
 294                                 r["IsUnique"] = false;
 295                                 r["IsKeyColumn"] = false;
 296                                 r["IsAutoIncrement"] = (isautoincrement==0) ? false : true;
 297                                 r["BaseSchemaName"] = baseschemaname;
 298                                 r["BaseCatalogName"] = "";
 299                                 r["BaseTableName"] = basetablename;
 300                                 r["BaseColumnName"] = basecolumnname;
 301
 302                                 _schemaTable.Rows.Add(r);
 303
 304                                 if(!differentTablesUsed)
 305                                 {
 306                                         if(((previousSchemaName == baseschemaname) && (previousTableName == basetablename)) ||
 307                                                 (previousTableName == null))
 308                                         {
 309                                                 previousTableName = basetablename;
 310                                                 previousSchemaName = baseschemaname;
 311                                         }
 312                                         else
 313                                         {
 314                                                 differentTablesUsed = true;
 315                                         }
 316                                 }
 317                         }
 318                         if(!differentTablesUsed &&
 319                                 ((behavior & CommandBehavior.KeyInfo) != 0) &&
 320                                 (db2Comm.Transaction == null) &&
 321                                 (previousTableName != null) &&
 322                                 (previousTableName != ""))
 323                         {
 324                                 DB2Command schemaInfoCommand = db2Conn.CreateCommand();
 325                                 schemaInfoCommand.CommandText =
 326                                         "select concat(concat(INDSCHEMA,'.'),INDNAME), COLNAMES, UNIQUERULE from syscat.INDEXES " +
 327                                         "where TABSCHEMA=? and TABNAME=? and uniquerule in ('P','U') order by UNIQUERULE";
 328                                 schemaInfoCommand.Parameters.Add("TABSCHEMA", previousSchemaName);
 329                                 schemaInfoCommand.Parameters.Add("TABNAME", previousTableName);
 330                                 using(DB2DataReader reader = schemaInfoCommand.ExecuteReader())
 331                                 {
 332                                         bool keyColumnSet = false;
 333                                         while(reader.Read())
 334                                         {
 335                                                 string indexName = reader.GetString(0);
 336                                                 string[] indexColumns = reader.GetString(1).TrimStart('-', '+').Split('-', '+');
 337                                                 bool primary = reader.GetString(2) == "P";
 338
 339                                                 bool allColumnsFound = true;
 340                                                 for(int i= 0; i < indexColumns.Length; i++)
 341                                                 {
 342                                                         int ordinal = FieldNameLookup(_schemaTable, indexColumns[i]);
 343                                                         if(ordinal < 0)
 344                                                         {
 345                                                                 allColumnsFound = false;
 346                                                                 break;
 347                                                         }
 348                                                         if(indexColumns.Length == 1)
 349                                                                 _schemaTable.Rows[ordinal]["IsUnique"] = true;
 350                                                 }
 351                                                 if(allColumnsFound && !keyColumnSet)
 352                                                 {
 353                                                         for(int i= 0; i < indexColumns.Length; i++)
 354                                                                 _schemaTable.Rows[FieldNameLookup(_schemaTable, indexColumns[i])]["IsKeyColumn"] = true;
 355                                                         keyColumnSet = true;
 356                                                 }
 357                                         }
 358                                 }
 359                                 if(db2Conn.openConnection.MajorVersion >= 8)
 360                                 {
 361                                         try
 362                                         {
 363                                                 schemaInfoCommand.CommandText =
 364                                                         "select COLNAME from SYSCAT.COLIDENTATTRIBUTES where TABSCHEMA=? and TABNAME=?";
 365                                                 using(DB2DataReader reader = schemaInfoCommand.ExecuteReader())
 366                                                 {
 367                                                         while(reader.Read())
 368                                                         {
 369                                                                 string columnName = reader.GetString(0);
 370
 371                                                                 int ordinal = FieldNameLookup(_schemaTable, columnName);
 372                                                                 if(ordinal >= 0)
 373                                                                         _schemaTable.Rows[ordinal]["IsAutoIncrement"] = true;
 374                                                         }
 375                                                 }
 376                                         }
 377                                         catch{}
 378                                 }
 379                         }
 380                         return _schemaTable;
 381                 }
 382                 #endregion
 383
 384                 #region NextResult
 385
 386                 public bool NextResult()
 387                 {
 388                         hasRows = false;
 389                         skipReadOnce = false;
 390                         hasData = false;
 391                         columnInfo = null;
 392                         _resultSet = null;
 393
 394                         if((behavior & (CommandBehavior.SchemaOnly | CommandBehavior.SingleResult)) != 0)
 395                                 return false;
 396
 397                         short sqlRet = DB2CLIWrapper.SQLMoreResults(this.hwndStmt);
 398                         if(sqlRet == DB2Constants.SQL_NO_DATA_FOUND)
 399                                 return false;
 400                         DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "Db2ClientDataReader - SQLMoreResults", db2Conn);
 401                         return true;
 402                 }
 403                 #endregion
 404
 405                 #region Read
 406
 407 #if !NET_1_0
 408                 public bool HasRows
 409                 {
 410                         get
 411                         {
 412                                 if(hasData)
 413                                         return true;
 414
 415                                 hasRows = Read();
 416                                 hasData = false;
 417                                 skipReadOnce = true;
 418                                 return hasRows;
 419                         }
 420                 }
 421 #endif
 422
 423                 public bool Read()
 424                 {
 425                         if (isClosed)
 426                                 throw new InvalidOperationException("Reader is closed");
 427                         if((behavior & CommandBehavior.SchemaOnly) != 0)
 428                                 return false;
 429
 430                         if(skipReadOnce)
 431                         {
 432                                 skipReadOnce = false;
 433                                 hasData = hasRows;
 434                                 return hasRows;
 435                         }
 436
 437                         _resultSet = null;
 438                         hasData = false;
 439
 440                         short sqlRet = DB2CLIWrapper.SQLFetch(hwndStmt);
 441                         if(sqlRet == DB2Constants.SQL_NO_DATA_FOUND)
 442                                 return false;
 443                         DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "DB2ClientDataReader - SQLFetch 1", db2Conn);
 444
 445                         hasData = true;
 446                         return true;
 447                 }
 448                 #endregion
 449
 450                 #region GetColumnInfo
 451                 private void GetColumnInfo()
 452                 {
 453                         if(isClosed)
 454                                 throw new InvalidOperationException("Reader is closed");
 455                         if(fieldCount <= 0)
 456                                 throw new InvalidOperationException("No Fields found"); // TODO: check error
 457                         if(columnInfo != null)
 458                                 return;
 459
 460                         columnInfo = new ColumnInfo[fieldCount];
 461                         columnsNames = new Hashtable(fieldCount);
 462
 463                         StringBuilder sb = new StringBuilder(400);
 464                         for(int i = 0; i < columnInfo.Length; i++)
 465                         {
 466                                 short sqlRet;
 467                                 short strlen;
 468                                 int numericAttribute;
 469
 470                                 sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)(i + 1), (short)DB2Constants.SQL_DESC_BASE_COLUMN_NAME, sb, (short)sb.Capacity, out strlen, out numericAttribute);
 471                                 DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable");
 472                                 columnInfo[i].Colname = sb.ToString();
 473                                 columnsNames[columnInfo[i].Colname.ToUpper()] = i;
 474
 475                                 sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)(i + 1), (short)DB2Constants.SQL_DESC_CONCISE_TYPE, sb, (short)sb.Capacity, out strlen, out columnInfo[i].Sqltype);
 476                                 DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable");
 477
 478
 479                         }
 480                 }
 481                 #endregion
 482
 483                 #region Describe/Bind/Fetch functions
 484                 ///
 485                 ///Broke these out so that we can use different paths for Immediate executions and Prepared executions
 486                 /// <summary>
 487                 /// Does the describe and bind steps for the query result set.  Called for both immediate and prepared queries.
 488                 /// </summary>
 489
 490 /// <summary>
 491 /// FetchResults does  what it says.
 492 /// </summary>
 493 /// <param name="dbVals"></param>
 494 /// <param name="sqlLen_or_IndPtr"></param>
 495 /// <param name="_resultSet"></param>
 496                 private int FieldNameLookup(DataTable _schemaTable, string name)
 497                 {
 498                         for(int i = 0; i < _schemaTable.Rows.Count; i++)
 499                         {
 500                                 if(CultureInfo.CurrentCulture.CompareInfo.Compare(name, (string)_schemaTable.Rows[i]["BaseColumnName"],
 501                                         CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth | CompareOptions.IgnoreCase) == 0)
 502                                 {
 503                                         return i;
 504                                 }
 505                         }
 506                         return -1;
 507                 }
 508
 509                 #endregion
 510
 511                 #region IDataRecord Interface
 512                 ///Code for the IDataRecord interface
 513                 ///
 514                 #region FieldCount
 515                 ///
 516                 ///
 517                 public int FieldCount
 518                 {
 519                         get
 520                         {
 521                                 if (isClosed)
 522                                         throw new InvalidOperationException("Reader is closed");
 523
 524                                 return fieldCount;
 525                         }
 526                 }
 527                 #endregion
 528
 529                 #region Item accessors
 530                 public object this[string name]
 531                 {
 532                         get
 533                         {
 534                                 int ordinal = GetOrdinal(name);
 535                                 return this[ordinal];
 536                         }
 537                 }
 538                 public object this[int col]
 539                 {
 540                         get
 541                         {
 542                                 if(columnInfo == null)
 543                                 {
 544                                         GetColumnInfo();
 545                                 }
 546                                 switch(columnInfo[col].Sqltype)
 547                                 {
 548                                         case DB2Constants.SQL_INTEGER:
 549                                                 return GetInt32Internal(col);
 550                                         case DB2Constants.SQL_SMALLINT:
 551                                                 return GetInt16Internal(col);
 552                                         case DB2Constants.SQL_BIGINT:
 553                                                 return GetInt64Internal(col);
 554                                         case DB2Constants.SQL_DOUBLE:
 555                                                 return GetDoubleInternal(col);
 556                                         case DB2Constants.SQL_REAL:
 557                                                 return GetFloatInternal(col);
 558                                         case DB2Constants.SQL_DECIMAL:
 559                                                 return GetDecimalInternal(col);
 560                                         case DB2Constants.SQL_DATETIME:
 561                                         case DB2Constants.SQL_TYPE_TIMESTAMP:
 562                                                 return GetDateTimeInternal(col);
 563                                         case DB2Constants.SQL_TYPE_DATE:
 564                                                 return GetDateInternal(col);
 565                                         case DB2Constants.SQL_TYPE_TIME:
 566                                                 return GetTimeInternal(col);
 567                                         case DB2Constants.SQL_TYPE_CLOB:
 568                                         case DB2Constants.SQL_CHAR:
 569                                         case DB2Constants.SQL_VARCHAR:
 570                                                 return GetStringInternal(col);
 571                                         case DB2Constants.SQL_TYPE_BLOB:
 572                                         case DB2Constants.SQL_TYPE_BINARY:
 573                                         case DB2Constants.SQL_LONGVARBINARY:
 574                                         case DB2Constants.SQL_VARBINARY:
 575                                                 return GetBlobDataInternal(col);
 576                                 }
 577                                 throw new NotImplementedException("Unknown SQL type " + columnInfo[col].Sqltype);
 578                         }
 579                 }
 580                 #endregion
 581
 582                 #region GetBytes
 583                 ///
 584                 ///  GetBytes, return a stream of bytes
 585                 ///
 586                 public long GetBytes(int col, long fieldOffset, byte[] buffer, int bufferOffset, int length)
 587                 {
 588                         // TODO: need better implementation for big BLOBs
 589
 590                         byte[] sourceArray = (byte[])this[col];
 591 #if NET_1_0
 592                         if(buffer == null)
 593                         {
 594                                 Array.Copy(sourceArray, (int)fieldOffset, buffer, bufferOffset, length);
 595                         }
 596                         return sourceArray.Length;
 597 #else
 598                         if(buffer == null)
 599                         {
 600                                 Array.Copy(sourceArray, fieldOffset, buffer, bufferOffset, length);
 601                         }
 602                         return sourceArray.LongLength;
 603 #endif
 604                 }
 605                 #endregion
 606
 607                 #region GetChars
 608                 ///
 609                 ///GetChars, returns char array
 610                 ///
 611                 public long GetChars(int col, long fieldOffset, char[] buffer, int bufferOffset, int length)
 612                 {
 613                         // TODO: need better implementation for big CLOBs
 614
 615                         string sourceString = GetString(col);
 616                         if(buffer == null)
 617                         {
 618                                 sourceString.CopyTo((int)fieldOffset, buffer, bufferOffset, length);
 619                         }
 620                         return (long)sourceString.Length;
 621                 }
 622                 #endregion
 623
 624                 #region GetBoolean method
 625
 626                 public Boolean GetBoolean(int col)
 627                 {
 628                         return (Boolean)GetBooleanInternal(col);
 629                 }
 630                 internal object GetBooleanInternal(int col)
 631                 {
 632                         if((col < 0) || (col >= fieldCount))
 633                         {
 634                                 throw new IndexOutOfRangeException("col");
 635                         }
 636                         if(!hasData)
 637                         {
 638                                 throw new InvalidOperationException("No data");
 639                         }
 640                         if(_resultSet == null)
 641                         {
 642                                 _resultSet = new object[fieldCount];
 643                         }
 644                         if(_resultSet[col] == null)
 645                         {
 646                                 int len;
 647                                 short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_BIT, internalBuffer, internalBufferSize, out len);
 648                                 if(len == DB2Constants.SQL_NULL_DATA)
 649                                 {
 650                                         _resultSet[col] = DBNull.Value;
 651                                 }
 652                                 else
 653                                 {
 654                                         _resultSet[col] = Marshal.ReadByte(internalBuffer) != 0;
 655                                 }
 656                         }
 657                         return _resultSet[col];
 658                 }
 659                 #endregion
 660
 661                 #region GetGuid
 662                 ///
 663                 /// GetDateTime method
 664                 ///
 665                 public Guid GetGuid(int col)
 666                 {
 667                         return (Guid)GetGuidInternal(col);
 668                 }
 669                 internal object GetGuidInternal(int col)
 670                 {
 671                         if((col < 0) || (col >= fieldCount))
 672                         {
 673                                 throw new IndexOutOfRangeException("col");
 674                         }
 675                         if(!hasData)
 676                         {
 677                                 throw new InvalidOperationException("No data");
 678                         }
 679                         if(_resultSet == null)
 680                         {
 681                                 _resultSet = new object[fieldCount];
 682                         }
 683                         if(_resultSet[col] == null)
 684                         {
 685                                 int len;
 686                                 short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_GUID, internalBuffer, internalBufferSize, out len);
 687                                 if(len == DB2Constants.SQL_NULL_DATA)
 688                                 {
 689                                         _resultSet[col] = DBNull.Value;
 690                                 }
 691                                 else
 692                                 {
 693                                         _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(Guid));
 694                                 }
 695                         }
 696                         return _resultSet[col];
 697                 }
 698
 699                 #endregion
 700
 701                 #region GetByte
 702                 ///
 703                 ///GetByte
 704                 ///
 705                 public Byte GetByte(int col)
 706                 {
 707                         return (Byte)GetByteInternal(col);
 708                 }
 709                 internal object GetByteInternal(int col)
 710                 {
 711                         if((col < 0) || (col >= fieldCount))
 712                         {
 713                                 throw new IndexOutOfRangeException("col");
 714                         }
 715                         if(!hasData)
 716                         {
 717                                 throw new InvalidOperationException("No data");
 718                         }
 719                         if(_resultSet == null)
 720                         {
 721                                 _resultSet = new object[fieldCount];
 722                         }
 723                         if(_resultSet[col] == null)
 724                         {
 725                                 int len;
 726                                 short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_UTINYINT, internalBuffer, 10, out len);
 727                                 if(len == DB2Constants.SQL_NULL_DATA)
 728                                 {
 729                                         _resultSet[col] = DBNull.Value;
 730                                 }
 731                                 else
 732                                 {
 733                                         _resultSet[col] = Marshal.ReadByte(internalBuffer);
 734                                 }
 735                         }
 736                         return _resultSet[col];
 737                 }
 738                 #endregion
 739
 740                 #region GetChar
 741                 ///
 742                 ///GetChar, return column as a char
 743                 ///
 744                 public Char GetChar(int col)
 745                 {
 746                         return (Char)GetCharInternal(col);
 747                 }
 748                 internal object GetCharInternal(int col)
 749                 {
 750                         if((col < 0) || (col >= fieldCount))
 751                         {
 752                                 throw new IndexOutOfRangeException("col");
 753                         }
 754                         if(!hasData)
 755                         {
 756                                 throw new InvalidOperationException("No data");
 757                         }
 758                         if(_resultSet == null)
 759                         {
 760                                 _resultSet = new object[fieldCount];
 761                         }
 762                         if(_resultSet[col] == null)
 763                         {
 764                                 int len;
 765                                 short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_WCHAR, internalBuffer, 10, out len);
 766                                 if(len == DB2Constants.SQL_NULL_DATA)
 767                                 {
 768                                         _resultSet[col] = DBNull.Value;
 769                                 }
 770                                 else
 771                                 {
 772                                         _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(char));
 773                                 }
 774                         }
 775                         return _resultSet[col];
 776                 }
 777                 #endregion
 778
 779                 #region GetData
 780                 ///
 781                 /// GetData method
 782                 ///
 783                 public IDataReader GetData(int col)
 784                 {
 785                         //Have to research this one, not quite sure what the docs mean
 786                         //DB2 does have some structured data types, is that what this is for?
 787                         throw new NotSupportedException();
 788                 }
 789                 #endregion
 790
 791                 #region GetDataTypeName
 792                 ///
 793                 ///GetDataTypeName return the type of data
 794                 ///
 795                 public string GetDataTypeName(int col)
 796                 {
 797                         if(columnInfo == null)
 798                         {
 799                                 GetColumnInfo();
 800                         }
 801                         switch(columnInfo[col].Sqltype)
 802                         {
 803                                 case DB2Constants.SQL_INTEGER:
 804                                         return "INTEGER";
 805                                 case DB2Constants.SQL_SMALLINT:
 806                                         return "SMALLINT";
 807                                 case DB2Constants.SQL_BIGINT:
 808                                         return "BIGINT";
 809                                 case DB2Constants.SQL_DOUBLE:
 810                                         return "DOUBLE";
 811                                 case DB2Constants.SQL_REAL:
 812                                         return "REAL";
 813                                 case DB2Constants.SQL_DECIMAL:
 814                                         return "DECIMAL";
 815                                 case DB2Constants.SQL_DATETIME:
 816                                         return "DATETIME";
 817                                 case DB2Constants.SQL_TYPE_TIMESTAMP:
 818                                         return "TIMESTAMP";
 819                                 case DB2Constants.SQL_TYPE_DATE:
 820                                         return "DATE";
 821                                 case DB2Constants.SQL_TYPE_TIME:
 822                                         return "TIME";
 823                                 case DB2Constants.SQL_TYPE_CLOB:
 824                                         return "CLOB";
 825                                 case DB2Constants.SQL_CHAR:
 826                                         return "CHAR";
 827                                 case DB2Constants.SQL_VARCHAR:
 828                                         return "VARCHAR";
 829                                 case DB2Constants.SQL_TYPE_BLOB:
 830                                         return "BLOB";
 831                                 case DB2Constants.SQL_TYPE_BINARY:
 832                                         return "BINARY";
 833                                 case DB2Constants.SQL_LONGVARBINARY:
 834                                         return "LONGVARBINARY";
 835                                 case DB2Constants.SQL_VARBINARY:
 836                                         return "VARBINARY";
 837                         }
 838                         throw new NotImplementedException("Unknown SQL type " + columnInfo[col].Sqltype);
 839                 }
 840                 #endregion
 841
 842                 #region GetDateTime
 843                 ///
 844                 /// GetDateTime method
 845                 ///
 846
 847                 public DateTime GetDateTime(int col)
 848                 {
 849                         return (DateTime)GetDateTimeInternal(col);
 850                 }
 851                 internal object GetDateTimeInternal(int col)
 852                 {
 853                         if((col < 0) || (col >= fieldCount))
 854                         {
 855                                 throw new IndexOutOfRangeException("col");
 856                         }
 857                         if(!hasData)
 858                         {
 859                                 throw new InvalidOperationException("No data");
 860                         }
 861                         if(_resultSet == null)
 862                         {
 863                                 _resultSet = new object[fieldCount];
 864                         }
 865                         if(_resultSet[col] == null)
 866                         {
 867                                 int len;
 868                                 short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_TYPE_TIMESTAMP, internalBuffer, internalBufferSize, out len);
 869                                 if(len == DB2Constants.SQL_NULL_DATA)
 870                                 {
 871                                         _resultSet[col] = DBNull.Value;
 872                                 }
 873                                 else
 874                                 {
 875                                         DateTime ret = new DateTime(
 876                                                 Marshal.ReadInt16(internalBuffer, 0),  // year
 877                                                 Marshal.ReadInt16(internalBuffer, 2),  // month
 878                                                 Marshal.ReadInt16(internalBuffer, 4),  // day
 879                                                 Marshal.ReadInt16(internalBuffer, 6),  // hour
 880                                                 Marshal.ReadInt16(internalBuffer, 8),  // minute
 881                                                 Marshal.ReadInt16(internalBuffer, 10));// second
 882                                         _resultSet[col] = ret.AddTicks(Marshal.ReadInt32(internalBuffer, 12) / 100); // nanoseconds
 883                                 }
 884                         }
 885                         return _resultSet[col];
 886                 }
 887                 #endregion
 888
 889                 #region GetDate
 890                 ///
 891                 /// GetDate method
 892                 ///
 893                 public DateTime GetDate(int col)
 894                 {
 895                         return (DateTime)GetDateInternal(col);
 896                 }
 897                 internal object GetDateInternal(int col)
 898                 {
 899                         if((col < 0) || (col >= fieldCount))
 900                         {
 901                                 throw new IndexOutOfRangeException("col");
 902                         }
 903                         if(!hasData)
 904                         {
 905                                 throw new InvalidOperationException("No data");
 906                         }
 907                         if(_resultSet == null)
 908                         {
 909                                 _resultSet = new object[fieldCount];
 910                         }
 911                         if(_resultSet[col] == null)
 912                         {
 913                                 int len;
 914                                 short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_TYPE_DATE, internalBuffer, internalBufferSize, out len);
 915                                 if(len == DB2Constants.SQL_NULL_DATA)
 916                                 {
 917                                         _resultSet[col] = DBNull.Value;
 918                                 }
 919                                 else
 920                                 {
 921                                         _resultSet[col] = new DateTime(
 922                                                 Marshal.ReadInt16(internalBuffer, 0),  // year
 923                                                 Marshal.ReadInt16(internalBuffer, 2),  // month
 924                                                 Marshal.ReadInt16(internalBuffer, 4));  // day
 925                                 }
 926                         }
 927                         return _resultSet[col];
 928                 }
 929
 930                 #endregion
 931
 932                 #region GetTime
 933                 ///
 934                 /// GetTime method
 935                 ///
 936                 public TimeSpan GetTimeSpan(int col)
 937                 {
 938                         return (TimeSpan)GetTimeInternal(col);
 939                 }
 940                 public TimeSpan GetTime(int col)
 941                 {
 942                         return (TimeSpan)GetTimeInternal(col);
 943                 }
 944                 internal object GetTimeInternal(int col)
 945                 {
 946                         if((col < 0) || (col >= fieldCount))
 947                         {
 948                                 throw new IndexOutOfRangeException("col");
 949                         }
 950                         if(!hasData)
 951                         {
 952                                 throw new InvalidOperationException("No data");
 953                         }
 954                         if(_resultSet == null)
 955                         {
 956                                 _resultSet = new object[fieldCount];
 957                         }
 958                         if(_resultSet[col] == null)
 959                         {
 960                                 int len;
 961                                 short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_TYPE_TIME, internalBuffer, internalBufferSize, out len);
 962                                 if(len == DB2Constants.SQL_NULL_DATA)
 963                                 {
 964                                         _resultSet[col] = DBNull.Value;
 965                                 }
 966                                 else
 967                                 {
 968                                         _resultSet[col] = new TimeSpan(
 969                                                 Marshal.ReadInt16(internalBuffer, 0),  // Hour
 970                                                 Marshal.ReadInt16(internalBuffer, 2),  // Minute
 971                                                 Marshal.ReadInt16(internalBuffer, 4)); // Second
 972                                 }
 973                         }
 974                         return _resultSet[col];
 975                 }
 976
 977                 #endregion
 978
 979
 980                 #region GetDecimal
 981                 ///
 982                 ///GetDecimal method
 983                 ///
 984
 985                 public Decimal GetDecimal(int col)
 986                 {
 987                         return (Decimal)GetDecimalInternal(col);
 988                 }
 989                 internal object GetDecimalInternal(int col)
 990                 {
 991                         object tmp = GetStringInternal(col);
 992                         if(tmp is string)
 993                         {
 994                                 _resultSet[col] = decimal.Parse(((string)_resultSet[col]).Replace(',','.'),     // sometimes we get a '.' and sometimes we get a ','
 995                                         System.Globalization.CultureInfo.InvariantCulture);
 996                         }
 997                         //                      if((col < 0) || (col >= fieldCount))    // only works on windows UDB DB2 V8?
 998                         //                      {
 999                         //                              throw new IndexOutOfRangeException("col");
1000                         //                      }
1001                         //                      if(!hasData)
1002                         //                      {
1003                         //                              throw new InvalidOperationException("No data");
1004                         //                      }
1005                         //                      if(_resultSet == null)
1006                         //                      {
1007                         //                              _resultSet = new object[fieldCount];
1008                         //                      }
1009                         //                      if(_resultSet[col] == null)
1010                         //                      {
1011                         //                              int len;
1012                         //                              short sqlRet = Db2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)Db2Constants.SQL_C_DECIMAL_OLEDB, internalBuffer, internalBufferSize, out len);
1013                         //                              if(len == Db2Constants.SQL_NULL_DATA)
1014                         //                              {
1015                         //                                      _resultSet[col] = DBNull.Value;
1016                         //                              }
1017                         //                              else
1018                         //                              {
1019                         //                                      _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(decimal));
1020                         //                              }
1021                         //                      }
1022                         return _resultSet[col];
1023                 }
1024                 #endregion
1025
1026                 #region GetDouble
1027                 ///
1028                 /// GetDouble
1029                 ///
1030                 public Double GetDouble(int col)
1031                 {
1032                         return (Double)GetDoubleInternal(col);
1033                 }
1034                 internal object GetDoubleInternal(int col)
1035                 {
1036                         if((col < 0) || (col >= fieldCount))
1037                         {
1038                                 throw new IndexOutOfRangeException("col");
1039                         }
1040                         if(!hasData)
1041                         {
1042                                 throw new InvalidOperationException("No data");
1043                         }
1044                         if(_resultSet == null)
1045                         {
1046                                 _resultSet = new object[fieldCount];
1047                         }
1048                         if(_resultSet[col] == null)
1049                         {
1050                                 int len;
1051                                 short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_DOUBLE, internalBuffer, internalBufferSize, out len);
1052                                 if(len == DB2Constants.SQL_NULL_DATA)
1053                                 {
1054                                         _resultSet[col] = DBNull.Value;
1055                                 }
1056                                 else
1057                                 {
1058                                         _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(double));
1059                                 }
1060                         }
1061                         return _resultSet[col];
1062                 }
1063                 #endregion
1064
1065                 #region GetFieldType
1066                 ///
1067                 /// Type GetFieldType
1068                 ///
1069                 public Type GetFieldType(int col)
1070                 {
1071                         if(columnInfo == null)
1072                         {
1073                                 GetColumnInfo();
1074                         }
1075                         return GetManagedType(columnInfo[col].Sqltype);
1076                 }
1077                 #endregion
1078
1079                 #region GetFloat
1080                 ///
1081                 /// GetFloat
1082                 ///
1083                 public float GetFloat(int col)
1084                 {
1085                         return (float)GetFloatInternal(col);
1086                 }
1087                 internal object GetFloatInternal(int col)
1088                 {
1089                         if((col < 0) || (col >= fieldCount))
1090                         {
1091                                 throw new IndexOutOfRangeException("col");
1092                         }
1093                         if(!hasData)
1094                         {
1095                                 throw new InvalidOperationException("No data");
1096                         }
1097                         if(_resultSet == null)
1098                         {
1099                                 _resultSet = new object[fieldCount];
1100                         }
1101                         if(_resultSet[col] == null)
1102                         {
1103                                 int len;
1104                                 short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_TYPE_REAL, internalBuffer, internalBufferSize, out len);
1105                                 if(len == DB2Constants.SQL_NULL_DATA)
1106                                 {
1107                                         _resultSet[col] = DBNull.Value;
1108                                 }
1109                                 else
1110                                 {
1111                                         _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(float));
1112                                 }
1113                         }
1114                         return _resultSet[col];
1115                 }
1116                 #endregion
1117
1118                 #region The GetInt?? series
1119                 ///
1120                 ///GetInt16
1121                 ///
1122                 public short GetInt16(int col)
1123                 {
1124                         return (short)GetInt16Internal(col);
1125                 }
1126
1127                 internal object GetInt16Internal(int col)
1128                 {
1129                         if((col < 0) || (col >= fieldCount))
1130                         {
1131                                 throw new IndexOutOfRangeException("col");
1132                         }
1133                         if(!hasData)
1134                         {
1135                                 throw new InvalidOperationException("No data");
1136                         }
1137                         if(_resultSet == null)
1138                         {
1139                                 _resultSet = new object[fieldCount];
1140                         }
1141                         if(_resultSet[col] == null)
1142                         {
1143                                 int len;
1144                                 short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_SSHORT, internalBuffer, internalBufferSize, out len);
1145                                 if(len == DB2Constants.SQL_NULL_DATA)
1146                                 {
1147                                         _resultSet[col] = DBNull.Value;
1148                                 }
1149                                 else
1150                                 {
1151                                         _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(short));
1152                                 }
1153                         }
1154                         return _resultSet[col];
1155                 }
1156                 ///
1157                 ///GetInt32
1158                 ///
1159                 public int GetInt32(int col)
1160                 {
1161                         return (int)GetInt32Internal(col);
1162                 }
1163
1164                 internal object GetInt32Internal(int col)
1165                 {
1166                         if((col < 0) || (col >= fieldCount))
1167                         {
1168                                 throw new IndexOutOfRangeException("col");
1169                         }
1170                         if(!hasData)
1171                         {
1172                                 throw new InvalidOperationException("No data");
1173                         }
1174                         if(_resultSet == null)
1175                         {
1176                                 _resultSet = new object[fieldCount];
1177                         }
1178                         if(_resultSet[col] == null)
1179                         {
1180                                 int len;
1181                                 short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_SLONG, internalBuffer, internalBufferSize, out len);
1182                                 if(len == DB2Constants.SQL_NULL_DATA)
1183                                 {
1184                                         _resultSet[col] = DBNull.Value;
1185                                 }
1186                                 else
1187                                 {
1188                                         _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(int));
1189                                 }
1190                         }
1191                         return _resultSet[col];
1192                 }
1193
1194                 ///
1195                 ///GetInt64
1196                 ///
1197                 public long GetInt64(int col)
1198                 {
1199                         return (long)GetInt64Internal(col);
1200                 }
1201
1202                 internal object GetInt64Internal(int col)
1203                 {
1204                         if((col < 0) || (col >= fieldCount))
1205                         {
1206                                 throw new IndexOutOfRangeException("col");
1207                         }
1208                         if(!hasData)
1209                         {
1210                                 throw new InvalidOperationException("No data");
1211                         }
1212                         if(_resultSet == null)
1213                         {
1214                                 _resultSet = new object[fieldCount];
1215                         }
1216                         if(_resultSet[col] == null)
1217                         {
1218                                 int len;
1219                                 short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_SBIGINT, internalBuffer, internalBufferSize, out len);
1220                                 if(len == DB2Constants.SQL_NULL_DATA)
1221                                 {
1222                                         _resultSet[col] = DBNull.Value;
1223                                 }
1224                                 else
1225                                 {
1226                                         _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(long));
1227                                 }
1228                         }
1229                         return _resultSet[col];
1230                 }
1231
1232                 #endregion
1233
1234                 #region GetName
1235                 ///
1236                 ///GetName, returns the name of the field
1237                 ///
1238                 public string GetName(int col)
1239                 {
1240                         if(columnInfo == null)
1241                         {
1242                                 GetColumnInfo();
1243                         }
1244                         return columnInfo[col].Colname;
1245                 }
1246                 #endregion
1247
1248                 #region GetOrdinal
1249                 ///
1250                 /// GetOrdinal, return the index of the named column
1251                 ///
1252                 public int GetOrdinal(string name)
1253                 {
1254                         if(columnInfo == null)
1255                         {
1256                                 GetColumnInfo();
1257                         }
1258                         object ordinal = columnsNames[name.ToUpper()];
1259                         if(ordinal == null)
1260                         {
1261                                 throw new IndexOutOfRangeException("name");
1262                         }
1263                         return (int)ordinal;
1264                 }
1265                 #endregion
1266
1267                 #region GetString
1268                 ///
1269                 /// GetString returns a string
1270                 ///
1271                 public string GetString(int col)
1272                 {
1273                         return (string)GetStringInternal(col);
1274                 }
1275
1276                 public object GetStringInternal(int col)
1277                 {
1278                         if((col < 0) || (col >= fieldCount))
1279                         {
1280                                 throw new IndexOutOfRangeException("col");
1281                         }
1282                         if(!hasData)
1283                         {
1284                                 throw new InvalidOperationException("No data");
1285                         }
1286                         if(_resultSet == null)
1287                         {
1288                                 _resultSet = new object[fieldCount];
1289                         }
1290                         if(_resultSet[col] == null)
1291                         {
1292                                 int length;
1293                                 short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_WCHAR, (StringBuilder)null, 0, out length);
1294                                 if(length == DB2Constants.SQL_NULL_DATA)
1295                                 {
1296                                         _resultSet[col] = DBNull.Value;
1297                                 }
1298                                 else
1299                                 {
1300                                         IntPtr mem = Marshal.AllocHGlobal(length + 2);
1301                                         sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_WCHAR, mem, length + 2, out length);
1302                                         _resultSet[col] = Marshal.PtrToStringUni(mem);
1303                                         Marshal.FreeHGlobal(mem);
1304                                 }
1305                         }
1306                         return _resultSet[col];
1307                 }
1308                 #endregion
1309
1310                 #region GetValue
1311                 ///
1312                 /// GetVCalue, returns an object
1313                 ///
1314                 public object GetValue(int col)
1315                 {
1316                         return this[col];
1317                 }
1318                 #endregion
1319
1320                 #region GetValues
1321                 ///
1322                 /// GetValues returns all columns in the row through the argument, and the number of columns in the return value
1323                 ///
1324                 public int GetValues(object[] values)
1325                 {
1326                         int count = Math.Min(fieldCount, values.Length);
1327
1328                         for (int i = 0; i < count; i++)
1329                         {
1330                                 values[i] = this[i];
1331
1332                         }
1333
1334                         return count;
1335                 }
1336                 #endregion
1337
1338                 #region IsDBNull
1339                 ///
1340                 /// IsDBNull Is the column null
1341                 ///
1342                 public bool IsDBNull(int col)
1343                 {
1344                         //Proper implementation once I get the SQLDescribe/SQLBind/SQLFetch stuff in place
1345                         return Convert.IsDBNull(this[col]);
1346                 }
1347                 #endregion
1348
1349                 #endregion  ///For IDataRecord
1350
1351                 #region private methods
1352
1353                 private DataTable BuildNewSchemaTable()
1354                 {
1355                         DataTable schemaTable = new DataTable("SchemaTable");
1356
1357                         schemaTable.Columns.Add(new DataColumn("ColumnName", typeof(string)));
1358                         schemaTable.Columns.Add(new DataColumn("ColumnOrdinal", typeof(int)));
1359                         schemaTable.Columns.Add(new DataColumn("ColumnSize", typeof(int)));
1360                         schemaTable.Columns.Add(new DataColumn("NumericPrecision", typeof(short)));
1361                         schemaTable.Columns.Add(new DataColumn("NumericScale", typeof(short)));
1362                         schemaTable.Columns.Add(new DataColumn("DataType", typeof(System.Type)));
1363                         schemaTable.Columns.Add(new DataColumn("ProviderType", typeof(int)));
1364                         schemaTable.Columns.Add(new DataColumn("IsLong", typeof(bool)));
1365                         schemaTable.Columns.Add(new DataColumn("AllowDBNull", typeof(bool)));
1366                         schemaTable.Columns.Add(new DataColumn("IsReadOnly", typeof(bool)));
1367                         schemaTable.Columns.Add(new DataColumn("IsRowVersion", typeof(bool)));
1368                         schemaTable.Columns.Add(new DataColumn("IsUnique", typeof(bool)));
1369                         schemaTable.Columns.Add(new DataColumn("IsKey", typeof(bool)));
1370                         schemaTable.Columns.Add(new DataColumn("IsKeyColumn", typeof(bool)));
1371                         schemaTable.Columns.Add(new DataColumn("IsAutoIncrement", typeof(bool)));
1372                         schemaTable.Columns.Add(new DataColumn("BaseSchemaName", typeof(string)));
1373                         schemaTable.Columns.Add(new DataColumn("BaseCatalogName", typeof(string)));
1374                         schemaTable.Columns.Add(new DataColumn("BaseTableName", typeof(string)));
1375                         schemaTable.Columns.Add(new DataColumn("BaseColumnName", typeof(string)));
1376
1377                         return schemaTable;
1378                 }
1379                 #endregion
1380
1381                 private void InitMem(int memSize, ref IntPtr ptr){
1382                         if (ptr.ToInt32() == 0){
1383                                 unsafe{
1384                                         fixed(byte* arr = new byte[memSize]){
1385                                                 ptr = new IntPtr(arr);
1386                                         }
1387                                 }
1388                         }
1389                 }
1390
1391                 private Type GetManagedType(int sql_type)
1392                 {
1393                         switch(sql_type)
1394                         {
1395                                 case DB2Constants.SQL_INTEGER:
1396                                         return typeof(int);
1397                                 case DB2Constants.SQL_SMALLINT:
1398                                         return typeof(short);
1399                                 case DB2Constants.SQL_BIGINT:
1400                                         return typeof(long);
1401                                 case DB2Constants.SQL_DOUBLE:
1402                                         return typeof(double);
1403                                 case DB2Constants.SQL_DECIMAL:
1404                                         return typeof(decimal);
1405                                 case DB2Constants.SQL_DATETIME:
1406                                 case DB2Constants.SQL_TYPE_DATE:
1407                                 case DB2Constants.SQL_TYPE_TIMESTAMP:
1408                                         return typeof(DateTime);
1409                                 case DB2Constants.SQL_TYPE_TIME:
1410                                         return typeof(TimeSpan);
1411                                 case DB2Constants.SQL_CHAR:
1412                                 case DB2Constants.SQL_VARCHAR:
1413                                 case DB2Constants.SQL_TYPE_CLOB:
1414                                         return typeof(string);
1415                                 case DB2Constants.SQL_TYPE_BLOB:
1416                                 case DB2Constants.SQL_TYPE_BINARY:
1417                                 case DB2Constants.SQL_LONGVARBINARY:
1418                                 case DB2Constants.SQL_VARBINARY:
1419                                         return typeof(byte[]);
1420                         }
1421                         throw new NotImplementedException("Unknown SQL type " + sql_type);
1422                 }
1423
1424                 private bool IsLong(short sql_type)
1425                 {
1426                         switch(sql_type)
1427                         {
1428                                 case DB2Constants.SQL_TYPE_CLOB:
1429                                 case DB2Constants.SQL_TYPE_BLOB:
1430                                         return true;
1431                         }
1432                         return false;
1433                 }
1434                 private object GetBlobDataInternal(int col)
1435                 {
1436                         if((col < 0) || (col >= fieldCount))
1437                         {
1438                                 throw new IndexOutOfRangeException("col");
1439                         }
1440                         if(!hasData)
1441                         {
1442                                 throw new InvalidOperationException("No data");
1443                         }
1444                         if(_resultSet == null)
1445                         {
1446                                 _resultSet = new object[fieldCount];
1447                         }
1448                         if(_resultSet[col] == null)
1449                         {
1450                                 int length;
1451                                 short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_TYPE_BINARY, (StringBuilder)null, 0, out length);
1452                                 if(length == DB2Constants.SQL_NULL_DATA)
1453                                 {
1454                                         _resultSet[col] = DBNull.Value;
1455                                 }
1456                                 else
1457                                 {
1458                                         byte[] result = new byte[length];
1459                                         sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_TYPE_BINARY, result, length, out length);
1460                                         _resultSet[col] = result;
1461                                 }
1462                         }
1463                         return _resultSet[col];
1464                 }
1465         }
1466
1467 }
1468 #endregion