mcs/class/Mono.Data.PostgreSqlClient/Mono.Data.PostgreSqlClient/PgSqlDataReader.cs

   1 //
   2 // Mono.Data.PostgreSqlClient.PgSqlDataReader.cs
   3 //
   4 // Author:
   5 //   Rodrigo Moya (rodrigo@ximian.com)
   6 //   Daniel Morgan (danmorg@sc.rr.com)
   7 //
   8 // (C) Ximian, Inc 2002
   9 // (C) Daniel Morgan 2002
  10 //
  11 // Credits:
  12 //    SQL and concepts were used from libgda 0.8.190 (GNOME Data Access)
  13 //    http://www.gnome-db.org/
  14 //    with permission from the authors of the
  15 //    PostgreSQL provider in libgda:
  16 //        Michael Lausch <michael@lausch.at>
  17 //        Rodrigo Moya <rodrigo@gnome-db.org>
  18 //        Vivien Malerba <malerba@gnome-db.org>
  19 //        Gonzalo Paniagua Javier <gonzalo@gnome-db.org>
  20 //
  21
  22 //
  23 // Permission is hereby granted, free of charge, to any person obtaining
  24 // a copy of this software and associated documentation files (the
  25 // "Software"), to deal in the Software without restriction, including
  26 // without limitation the rights to use, copy, modify, merge, publish,
  27 // distribute, sublicense, and/or sell copies of the Software, and to
  28 // permit persons to whom the Software is furnished to do so, subject to
  29 // the following conditions:
  30 //
  31 // The above copyright notice and this permission notice shall be
  32 // included in all copies or substantial portions of the Software.
  33 //
  34 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  35 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  36 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  37 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  38 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  39 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  40 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  41 //
  42
  43 // *** uncomment #define to get debug messages, comment for production ***
  44 //#define DEBUG_SqlDataReader
  45
  46
  47 using System;
  48 using System.Collections;
  49 using System.ComponentModel;
  50 using System.Data;
  51 using System.Data.Common;
  52
  53 namespace Mono.Data.PostgreSqlClient {
  54         /// <summary>
  55         /// Provides a means of reading one or more forward-only streams
  56         /// of result sets obtained by executing a command
  57         /// at a SQL database.
  58         /// </summary>
  59         public sealed class PgSqlDataReader : MarshalByRefObject,
  60                 IEnumerable, IDataReader, IDisposable, IDataRecord {
  61
  62                 #region Fields
  63
  64                 private PgSqlCommand cmd;
  65                 private DataTable table = null;
  66
  67                 // columns in a row
  68                 private object[] fields; // data value in a .NET type
  69                 private string[] types; // PostgreSQL Type
  70                 private bool[] isNull; // is NULL?
  71                 private int[] actualLength; // ActualLength of data
  72                 private DbType[] dbTypes; // DB data type
  73                 // actucalLength = -1 is variable-length
  74
  75                 private bool open = false;
  76                 IntPtr pgResult; // PGresult
  77                 private int rows;
  78                 private int cols;
  79
  80                 private int recordsAffected = -1; // TODO: get this value
  81
  82                 private int currentRow = -1; // no Read() has been done yet
  83
  84                 private bool disposed = false;
  85
  86                 #endregion // Fields
  87
  88                 #region Constructors
  89
  90                 internal PgSqlDataReader (PgSqlCommand sqlCmd) {
  91
  92                         cmd = sqlCmd;
  93                         open = true;
  94                         cmd.OpenReader(this);
  95                 }
  96
  97                 #endregion
  98
  99                 #region Public Methods
 100
 101                 [MonoTODO]
 102                 public void Close() {
 103                         open = false;
 104
 105                         // free PgSqlDataReader resources in PgSqlCommand
 106                         // and allow PgSqlConnection to be used again
 107                         cmd.CloseReader();
 108
 109                         // TODO: get parameters from result
 110
 111                         Dispose (true);
 112                 }
 113
 114                 [MonoTODO]
 115                 public DataTable GetSchemaTable() {
 116                         return table;
 117                 }
 118
 119                 [MonoTODO]
 120                 public bool NextResult() {
 121                         PgSqlResult res;
 122                         currentRow = -1;
 123                         bool resultReturned;
 124
 125                         // reset
 126                         table = null;
 127                         pgResult = IntPtr.Zero;
 128                         rows = 0;
 129                         cols = 0;
 130                         types = null;
 131                         recordsAffected = -1;
 132
 133                         res = cmd.NextResult();
 134                         resultReturned = res.ResultReturned;
 135
 136                         if(resultReturned == true) {
 137                                 table = res.Table;
 138                                 pgResult = res.PgResult;
 139                                 rows = res.RowCount;
 140                                 cols = res.FieldCount;
 141                                 types = res.PgTypes;
 142                                 recordsAffected = res.RecordsAffected;
 143                         }
 144
 145                         res = null;
 146                         return resultReturned;
 147                 }
 148
 149                 [MonoTODO]
 150                 public bool Read() {
 151
 152                         string dataValue;
 153                         int c = 0;
 154
 155                         if(currentRow < rows - 1)  {
 156
 157                                 currentRow++;
 158
 159                                 // re-init row
 160                                 fields = new object[cols];
 161                                 //dbTypes = new DbType[cols];
 162                                 actualLength = new int[cols];
 163                                 isNull = new bool[cols];
 164
 165                                 for(c = 0; c < cols; c++) {
 166
 167                                         // get data value
 168                                         dataValue = PostgresLibrary.
 169                                                 PQgetvalue(
 170                                                 pgResult,
 171                                                 currentRow, c);
 172
 173                                         // is column NULL?
 174                                         //isNull[c] = PostgresLibrary.
 175                                         //      PQgetisnull(pgResult,
 176                                         //      currentRow, c);
 177
 178                                         // get Actual Length
 179                                         actualLength[c] = PostgresLibrary.
 180                                                 PQgetlength(pgResult,
 181                                                 currentRow, c);
 182
 183                                         DbType dbType;
 184                                         dbType = PostgresHelper.
 185                                                 TypnameToSqlDbType(types[c]);
 186
 187                                         if(dataValue == null) {
 188                                                 fields[c] = null;
 189                                                 isNull[c] = true;
 190                                         }
 191                                         else if(dataValue.Equals("")) {
 192                                                 fields[c] = null;
 193                                                 isNull[c] = true;
 194                                         }
 195                                         else {
 196                                                 isNull[c] = false;
 197                                                 fields[c] = PostgresHelper.
 198                                                         ConvertDbTypeToSystem (
 199                                                         dbType,
 200                                                         dataValue);
 201                                         }
 202                                 }
 203                                 return true;
 204                         }
 205                         return false; // EOF
 206                 }
 207
 208                 [MonoTODO]
 209                 public byte GetByte(int i) {
 210                         throw new NotImplementedException ();
 211                 }
 212
 213                 [MonoTODO]
 214                 public long GetBytes(int i, long fieldOffset,
 215                         byte[] buffer, int bufferOffset,
 216                         int length) {
 217                         throw new NotImplementedException ();
 218                 }
 219
 220                 [MonoTODO]
 221                 public char GetChar(int i) {
 222                         throw new NotImplementedException ();
 223                 }
 224
 225                 [MonoTODO]
 226                 public long GetChars(int i, long fieldOffset,
 227                         char[] buffer, int bufferOffset,
 228                         int length) {
 229                         throw new NotImplementedException ();
 230                 }
 231
 232                 [MonoTODO]
 233                 public IDataReader GetData(int i) {
 234                         throw new NotImplementedException ();
 235                 }
 236
 237                 [MonoTODO]
 238                 public string GetDataTypeName(int i) {
 239                         return types[i];
 240                 }
 241
 242                 [MonoTODO]
 243                 public DateTime GetDateTime(int i) {
 244                         return (DateTime) fields[i];
 245                 }
 246
 247                 [MonoTODO]
 248                 public decimal GetDecimal(int i) {
 249                         return (decimal) fields[i];
 250                 }
 251
 252                 [MonoTODO]
 253                 public double GetDouble(int i) {
 254                         return (double) fields[i];
 255                 }
 256
 257                 [MonoTODO]
 258                 public Type GetFieldType(int i) {
 259
 260                         DataRow row = table.Rows[i];
 261                         return Type.GetType((string)row["DataType"]);
 262                 }
 263
 264                 [MonoTODO]
 265                 public float GetFloat(int i) {
 266                         return (float) fields[i];
 267                 }
 268
 269                 [MonoTODO]
 270                 public Guid GetGuid(int i) {
 271                         throw new NotImplementedException ();
 272                 }
 273
 274                 [MonoTODO]
 275                 public short GetInt16(int i) {
 276                         return (short) fields[i];
 277                 }
 278
 279                 [MonoTODO]
 280                 public int GetInt32(int i) {
 281                         return (int) fields[i];
 282                 }
 283
 284                 [MonoTODO]
 285                 public long GetInt64(int i) {
 286                         return (long) fields[i];
 287                 }
 288
 289                 [MonoTODO]
 290                 public string GetName(int i) {
 291
 292                         DataRow row = table.Rows[i];
 293                         return (string) row["ColumnName"];
 294                 }
 295
 296                 [MonoTODO]
 297                 public int GetOrdinal(string name) {
 298
 299                         int i;
 300                         DataRow row;
 301
 302                         for(i = 0; i < table.Rows.Count; i++) {
 303                                 row = table.Rows[i];
 304                                 if(((string) row["ColumnName"]).Equals(name))
 305                                         return i;
 306                         }
 307
 308                         for(i = 0; i < table.Rows.Count; i++) {
 309                                 string ta;
 310                                 string n;
 311
 312                                 row = table.Rows[i];
 313                                 ta = ((string) row["ColumnName"]).ToUpper();
 314                                 n = name.ToUpper();
 315
 316                                 if(ta.Equals(n)) {
 317                                         return i;
 318                                 }
 319                         }
 320
 321                         throw new MissingFieldException("Missing field: " + name);
 322                 }
 323
 324                 [MonoTODO]
 325                 public string GetString(int i) {
 326                         return (string) fields[i];
 327                 }
 328
 329                 [MonoTODO]
 330                 public object GetValue(int i) {
 331                         return fields[i];
 332                 }
 333
 334                 [MonoTODO]
 335                 public int GetValues(object[] values)
 336                 {
 337                         Array.Copy (fields, values, fields.Length);
 338                         return fields.Length;
 339                 }
 340
 341                 [MonoTODO]
 342                 public bool IsDBNull(int i) {
 343                         return isNull[i];
 344                 }
 345
 346                 [MonoTODO]
 347                 public bool GetBoolean(int i) {
 348                         return (bool) fields[i];
 349                 }
 350
 351                 [MonoTODO]
 352                 IEnumerator IEnumerable.GetEnumerator () {
 353                         return new DbEnumerator (this);
 354                 }
 355
 356                 #endregion // Public Methods
 357
 358                 #region Destructors
 359
 360                 private void Dispose(bool disposing) {
 361                         if(!this.disposed) {
 362                                 if(disposing) {
 363                                         // release any managed resources
 364                                         cmd = null;
 365                                         table = null;
 366                                         fields = null;
 367                                         types = null;
 368                                         isNull = null;
 369                                         actualLength = null;
 370                                         dbTypes = null;
 371                                 }
 372                                 // release any unmanaged resources
 373
 374                                 // clear unmanaged PostgreSQL result set
 375                                 if (pgResult != IntPtr.Zero) {
 376                                         PostgresLibrary.PQclear (pgResult);
 377                                         pgResult = IntPtr.Zero;
 378                                 }
 379
 380                                 // close any handles
 381                                 this.disposed = true;
 382                         }
 383                 }
 384
 385                 void IDisposable.Dispose() {
 386                         Dispose(true);
 387                 }
 388
 389                 ~PgSqlDataReader() {
 390                         Dispose(false);
 391                 }
 392
 393                 #endregion // Destructors
 394
 395                 #region Properties
 396
 397                 public int Depth {
 398                         [MonoTODO]
 399                         get {
 400                                 return 0; // always return zero, unless
 401                                           // this provider will allow
 402                                           // nesting of a row
 403                         }
 404                 }
 405
 406                 public bool IsClosed {
 407                         [MonoTODO]
 408                         get {
 409                                 if(open == false)
 410                                         return true;
 411                                 else
 412                                         return false;
 413                         }
 414                 }
 415
 416                 public int RecordsAffected {
 417                         [MonoTODO]
 418                         get {
 419                                 return recordsAffected;
 420                         }
 421                 }
 422
 423                 public int FieldCount {
 424                         [MonoTODO]
 425                         get {
 426                                 return cols;
 427                         }
 428                 }
 429
 430                 public object this[string name] {
 431                         [MonoTODO]
 432                         get {
 433                                 int i;
 434                                 DataRow row;
 435
 436                                 for(i = 0; i < table.Rows.Count; i++) {
 437                                         row = table.Rows[i];
 438                                         if(row["ColumnName"].Equals(name))
 439                                                 return fields[i];
 440                                 }
 441
 442                                 for(i = 0; i < table.Rows.Count; i++) {
 443                                         string ta;
 444                                         string n;
 445
 446                                         row = table.Rows[i];
 447                                         ta = ((string) row["ColumnName"]).ToUpper();
 448                                         n = name.ToUpper();
 449
 450                                         if(ta.Equals(n)) {
 451                                                 return fields[i];
 452                                         }
 453                                 }
 454
 455                                 throw new MissingFieldException("Missing field: " + name);
 456                         }
 457                 }
 458
 459                 public object this[int i] {
 460                         [MonoTODO]
 461                         get {
 462                                 return fields[i];
 463                         }
 464                 }
 465
 466                 #endregion // Properties
 467         }
 468 }