class/IBM.Data.DB2/IBM.Data.DB2/DB2Connection.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.Collections.Specialized;
  25 using System.Data;
  26 using System.Runtime.InteropServices;
  27 using System.Text;
  28
  29 namespace IBM.Data.DB2
  30 {
  31
  32
  33         public class DB2Connection : System.ComponentModel.Component, IDbConnection, ICloneable
  34         {
  35                 #region private data members
  36
  37                 private ArrayList refCommands;
  38                 private WeakReference refTransaction;
  39                 private DB2ConnectionSettings connectionSettings = null;
  40                 private int connectionTimeout;
  41                 internal DB2OpenConnection openConnection;
  42                 private bool disposed = false;
  43
  44                 #endregion
  45
  46                 #region Constructors
  47
  48                 public DB2Connection()
  49                 {
  50                         connectionTimeout = 15;
  51
  52                 }
  53
  54                 public DB2Connection(string conString)
  55                 {
  56
  57                         SetConnectionString(conString);
  58                 }
  59
  60
  61                 #endregion
  62
  63                 #region ConnectionString property
  64
  65                 public string ConnectionString
  66                 {
  67                         get
  68                         {
  69                                 return connectionSettings.ConnectionString;
  70                         }
  71                         set
  72                         {
  73                                 SetConnectionString(value);
  74                         }
  75                 }
  76                 #endregion
  77
  78
  79                 #region ConnectionTimeout property
  80                 public int ConnectionTimeout
  81                 {
  82                         get
  83                         {
  84                                 return connectionTimeout;
  85                         }
  86                         set
  87                         {
  88                                 connectionTimeout = value;
  89                         }
  90                 }
  91                 #endregion
  92
  93                 #region Database property
  94                 public string Database
  95                 {
  96                         get
  97                         {
  98                                 return connectionSettings.DatabaseAlias;
  99                         }
 100                 }
 101                 #endregion
 102
 103                 #region State property
 104
 105
 106                 unsafe public ConnectionState State
 107                 {
 108                         get
 109                         {
 110                                 //if ((long)dbHandle.ToPointer() == DB2Constants.SQL_NULL_HANDLE)
 111                                 if (openConnection == null)
 112                                         return ConnectionState.Closed;
 113                                 return ConnectionState.Open;
 114                         }
 115                 }
 116                 #endregion
 117
 118                 #region events
 119
 120                 public event DB2InfoMessageEventHandler InfoMessage;
 121                 public event StateChangeEventHandler StateChange;
 122
 123                 internal void OnInfoMessage(short handleType, IntPtr handle)
 124                 {
 125                         if(InfoMessage != null)
 126                         {
 127                                 // Don't get error information until we know for sure someone is listening
 128                                 try
 129                                 {
 130                                         InfoMessage(this,
 131                                                 new DB2InfoMessageEventArgs(new DB2ErrorCollection(handleType, handle)));
 132                                 }
 133                                 catch(Exception)
 134                                 {}
 135                         }
 136                 }
 137
 138                 private void OnStateChange(StateChangeEventArgs args)
 139                 {
 140                         if(StateChange != null)
 141                                 StateChange(this, args);
 142                 }
 143
 144                 #endregion
 145
 146                 #region DBHandle
 147
 148                 internal IntPtr DBHandle
 149                 {
 150                         get
 151                         {
 152                                 return (openConnection == null) ? IntPtr.Zero : openConnection.DBHandle;
 153                         }
 154                 }
 155                 #endregion
 156
 157                 #region BeginTransaction Method
 158
 159                 IDbTransaction IDbConnection.BeginTransaction()
 160                 {
 161                         return BeginTransaction();
 162                 }
 163
 164                 IDbTransaction IDbConnection.BeginTransaction(IsolationLevel isolationL)
 165                 {
 166                         return BeginTransaction(isolationL);
 167                 }
 168
 169                 public DB2Transaction BeginTransaction()
 170                 {
 171                         return BeginTransaction(IsolationLevel.ReadCommitted);
 172                 }
 173
 174                 public DB2Transaction BeginTransaction(IsolationLevel isolationL)
 175                 {
 176                         if ((refTransaction != null) && (refTransaction.IsAlive))
 177                                 throw new InvalidOperationException("Cannot open another transaction");
 178                         if(State != ConnectionState.Open)
 179                                 throw new InvalidOperationException("BeginTransaction needs an open connection");
 180
 181                         if(refTransaction != null)
 182                         {
 183                                 if(refTransaction.IsAlive)
 184                                         throw new InvalidOperationException("Parallel transactions not supported");
 185
 186                                 openConnection.RollbackDeadTransaction();
 187                                 refTransaction = null;
 188                         }
 189                         openConnection.transactionOpen = true;
 190                         DB2Transaction tran = new DB2Transaction(this, isolationL);
 191                         refTransaction = new WeakReference(tran);
 192                         return tran;
 193                 }
 194
 195                 #endregion
 196
 197                 #region ChangeDatabase
 198                 unsafe public void ChangeDatabase(string newDBName)
 199                 {
 200                         if(connectionSettings == null)
 201                         {
 202                                 throw new InvalidOperationException("No connection string");
 203                         }
 204                         this.Close();
 205
 206                         SetConnectionString(connectionSettings.ConnectionString.Replace(connectionSettings.DatabaseAlias, newDBName));
 207
 208                         this.Open();
 209                 }
 210                 #endregion
 211
 212                 #region ReleaseObjectPool
 213                 public static void ReleaseObjectPool()
 214                 {
 215                         DB2Environment.Instance.Dispose();
 216                 }
 217                 #endregion
 218
 219                 #region Close
 220                 public void Close()
 221                 {
 222                         DB2Transaction transaction = null;
 223                         if(refTransaction != null)
 224                                 transaction = (DB2Transaction)refTransaction.Target;
 225                         if((transaction != null) && refTransaction.IsAlive)
 226                         {
 227                                 transaction.Dispose();
 228                         }
 229                         if(refCommands != null)
 230                         {
 231                                 for(int i = 0; i < refCommands.Count; i++)
 232                                 {
 233                                         DB2Command command = null;
 234                                         if(refCommands[i] != null)
 235                                         {
 236                                                 command = (DB2Command)((WeakReference)refCommands[i]).Target;
 237                                         }
 238                                         if((command != null) && ((WeakReference)refCommands[i]).IsAlive)
 239                                         {
 240                                                 try
 241                                                 {
 242                                                         command.ConnectionClosed();
 243                                                 }
 244                                                 catch{}
 245                                         }
 246                                         //?? refCommands[i] = null;
 247                                 }
 248                         }
 249
 250                         if(openConnection != null)
 251                         {
 252                                 openConnection.Close();
 253                                 openConnection = null;
 254                         }
 255                 }
 256
 257                 #endregion
 258
 259                 #region CreateCommand
 260                 IDbCommand IDbConnection.CreateCommand()
 261                 {
 262                         return CreateCommand();
 263                 }
 264
 265                 public DB2Command CreateCommand()
 266                 {
 267                         //CheckState();
 268                         return new DB2Command(null, this);
 269                 }
 270                 #endregion
 271
 272                 #region Open
 273
 274                 unsafe public void Open()
 275                 {
 276                         if(disposed)
 277                         {
 278                                 throw new ObjectDisposedException("DB2Connection");
 279                         }
 280
 281                         if (this.State == ConnectionState.Open || this.State == ConnectionState.Connecting || this.State == ConnectionState.Executing || this.State == ConnectionState.Fetching)
 282                         {
 283                                 throw new InvalidOperationException("Connection already open");
 284                         }
 285
 286                         try
 287                         {
 288                                 openConnection = connectionSettings.GetRealOpenConnection(this);
 289                         }
 290                         catch (DB2Exception)
 291                         {
 292                                 Close();
 293                                 throw;
 294                         }
 295                 }
 296                 #endregion
 297
 298                 #region Dispose
 299                 public new void Dispose()
 300                 {
 301                         Dispose(true);
 302                         GC.SuppressFinalize(this);
 303                 }
 304
 305                 protected override void Dispose(bool disposing)
 306                 {
 307                         if(!disposed)
 308                         {
 309                                 if(disposing)
 310                                 {
 311                                         // dispose managed resources
 312                                         Close();
 313                                 }
 314                         }
 315                         base.Dispose(disposing);
 316                         disposed = true;
 317                 }
 318
 319
 320                 ~DB2Connection()
 321                 {
 322                         Dispose(false);
 323                 }
 324                 #endregion
 325
 326                 private void CheckState()
 327                 {
 328                         if (ConnectionState.Closed == State)
 329                                 throw new InvalidOperationException("Connection is currently closed.");
 330                 }
 331
 332                 void SetConnectionString (string connectionString)
 333                 {
 334                         if (State != ConnectionState.Closed)
 335                                 throw new InvalidOperationException("Connection is not closed.");
 336
 337                         this.connectionSettings = DB2ConnectionSettings.GetConnectionSettings(connectionString);
 338                 }
 339
 340                 internal WeakReference WeakRefTransaction
 341                 {
 342                         get
 343                         {
 344                                 return refTransaction;
 345                         }
 346                         set
 347                         {
 348                                 refTransaction = value;
 349                         }
 350
 351                 }
 352
 353                 internal void AddCommand(DB2Command command)
 354                 {
 355                         if(refCommands == null)
 356                         {
 357                                 refCommands = new ArrayList();
 358                         }
 359                         for(int i = 0; i < refCommands.Count; i++)
 360                         {
 361                                 WeakReference reference = (WeakReference)refCommands[i];
 362                                 if((reference == null) || !reference.IsAlive)
 363                                 {
 364                                         refCommands[i] = new WeakReference(command);
 365                                         return;
 366                                 }
 367                         }
 368                         refCommands.Add(new WeakReference(command));
 369
 370                 }
 371
 372                 internal void RemoveCommand(DB2Command command)
 373                 {
 374                         for(int i = 0; i < refCommands.Count; i++)
 375                         {
 376                                 WeakReference reference = (WeakReference)refCommands[i];
 377                                 if(object.ReferenceEquals(reference, command))
 378                                 {
 379                                         refCommands[i] = null;
 380                                         return;
 381                                 }
 382                         }
 383                 }
 384
 385                 #region ICloneable Members
 386
 387                 object ICloneable.Clone()
 388                 {
 389                         DB2Connection clone = new DB2Connection();
 390
 391                         clone.connectionSettings = connectionSettings;
 392                         clone.connectionTimeout = connectionTimeout;
 393
 394                         return clone;
 395                 }
 396
 397                 #endregion
 398
 399         }
 400 }
 401