mcs/class/System.Data/System.Data.OleDb/OleDbDataAdapter.cs

   1 //
   2 // System.Data.OleDb.OleDbDataAdapter
   3 //
   4 // Authors:
   5 //   Rodrigo Moya (rodrigo@ximian.com)
   6 //   Tim Coleman (tim@timcoleman.com)
   7 //
   8 // Copyright (C) Rodrigo Moya, 2002
   9 // Copyright (C) Tim Coleman, 2002
  10 //
  11
  12 using System;
  13 using System.ComponentModel;
  14 using System.Data;
  15 using System.Data.Common;
  16
  17 namespace System.Data.OleDb
  18 {
  19         public sealed class OleDbDataAdapter : DbDataAdapter, IDbDataAdapter
  20         {
  21                 #region Fields
  22
  23                 OleDbCommand deleteCommand;
  24                 OleDbCommand insertCommand;
  25                 OleDbCommand selectCommand;
  26                 OleDbCommand updateCommand;
  27                 MissingMappingAction missingMappingAction;
  28                 MissingSchemaAction missingSchemaAction;
  29
  30                 static readonly object EventRowUpdated = new object ();
  31                 static readonly object EventRowUpdating = new object ();
  32
  33                 #endregion
  34
  35                 #region Constructors
  36
  37                 public OleDbDataAdapter ()
  38                         : this (new OleDbCommand ())
  39                 {
  40                 }
  41
  42                 public OleDbDataAdapter (OleDbCommand selectCommand)
  43                 {
  44                         DeleteCommand = new OleDbCommand ();
  45                         InsertCommand = new OleDbCommand ();
  46                         SelectCommand = selectCommand;
  47                         UpdateCommand = new OleDbCommand ();
  48                 }
  49
  50                 public OleDbDataAdapter (string selectCommandText, OleDbConnection selectConnection)
  51                         : this (new OleDbCommand (selectCommandText, selectConnection))
  52                 {
  53                 }
  54
  55                 public OleDbDataAdapter (string selectCommandText, string selectConnectionString)
  56                         : this (selectCommandText, new OleDbConnection (selectConnectionString))
  57                 {
  58                 }
  59
  60                 #endregion // Fields
  61
  62                 #region Properties
  63
  64                 public OleDbCommand DeleteCommand {
  65                         get {
  66                                 return deleteCommand;
  67                         }
  68                         set {
  69                                 deleteCommand = value;
  70                         }
  71                 }
  72
  73                 public OleDbCommand InsertCommand {
  74                         get {
  75                                 return insertCommand;
  76                         }
  77                         set {
  78                                 insertCommand = value;
  79                         }
  80                 }
  81
  82                 public OleDbCommand SelectCommand {
  83                         get {
  84                                 return selectCommand;
  85                         }
  86                         set {
  87                                 selectCommand = value;
  88                         }
  89                 }
  90
  91                 public OleDbCommand UpdateCommand {
  92                         get {
  93                                 return updateCommand;
  94                         }
  95                         set {
  96                                 updateCommand = value;
  97                         }
  98                 }
  99
 100                 IDbCommand IDbDataAdapter.DeleteCommand {
 101                         get {
 102                                 return DeleteCommand;
 103                         }
 104                         set {
 105                                 if (!(value is OleDbCommand))
 106                                         throw new ArgumentException ();
 107                                 DeleteCommand = (OleDbCommand)value;
 108                         }
 109                 }
 110
 111                 IDbCommand IDbDataAdapter.InsertCommand {
 112                         get {
 113                                 return InsertCommand;
 114                         }
 115                         set {
 116                                 if (!(value is OleDbCommand))
 117                                         throw new ArgumentException ();
 118                                 InsertCommand = (OleDbCommand)value;
 119                         }
 120                 }
 121
 122                 IDbCommand IDbDataAdapter.SelectCommand {
 123                         get {
 124                                 return SelectCommand;
 125                         }
 126                         set {
 127                                 if (!(value is OleDbCommand))
 128                                         throw new ArgumentException ();
 129                                 SelectCommand = (OleDbCommand)value;
 130                         }
 131                 }
 132
 133                 MissingMappingAction IDataAdapter.MissingMappingAction {
 134                         get {
 135                                 return missingMappingAction;
 136                         }
 137                         set {
 138                                 missingMappingAction = value;
 139                         }
 140                 }
 141
 142                 MissingSchemaAction IDataAdapter.MissingSchemaAction {
 143                         get {
 144                                 return missingSchemaAction;
 145                         }
 146                         set {
 147                                 missingSchemaAction = value;
 148                         }
 149                 }
 150
 151                 IDbCommand IDbDataAdapter.UpdateCommand {
 152                         get {
 153                                 return UpdateCommand;
 154                         }
 155                         set {
 156                                 if (!(value is OleDbCommand))
 157                                         throw new ArgumentException ();
 158                                 UpdateCommand = (OleDbCommand)value;
 159                         }
 160                 }
 161
 162                 ITableMappingCollection IDataAdapter.TableMappings {
 163                         get {
 164                                 return TableMappings;
 165                         }
 166                 }
 167
 168                 #endregion // Properties
 169
 170                 #region Methods
 171
 172                 protected override RowUpdatedEventArgs CreateRowUpdatedEvent (DataRow dataRow,
 173                                                                               IDbCommand command,
 174                                                                               StatementType statementType,
 175                                                                               DataTableMapping tableMapping)
 176                 {
 177                         return new OleDbRowUpdatedEventArgs (dataRow, command, statementType, tableMapping);
 178                 }
 179
 180
 181                 protected override RowUpdatingEventArgs CreateRowUpdatingEvent (DataRow dataRow,
 182                                                                                 IDbCommand command,
 183                                                                                 StatementType statementType,
 184                                                                                 DataTableMapping tableMapping)
 185                 {
 186                         return new OleDbRowUpdatingEventArgs (dataRow, command, statementType, tableMapping);
 187                 }
 188
 189                 protected override void OnRowUpdated (RowUpdatedEventArgs value)
 190                 {
 191                         OleDbRowUpdatedEventHandler handler = (OleDbRowUpdatedEventHandler) Events[EventRowUpdated];
 192                         if ((handler != null) && (value is OleDbRowUpdatedEventArgs))
 193                                 handler (this, (OleDbRowUpdatedEventArgs) value);
 194                 }
 195
 196                 protected override void OnRowUpdating (RowUpdatingEventArgs value)
 197                 {
 198                         OleDbRowUpdatingEventHandler handler = (OleDbRowUpdatingEventHandler) Events[EventRowUpdating];
 199                         if ((handler != null) && (value is OleDbRowUpdatingEventArgs))
 200                                 handler (this, (OleDbRowUpdatingEventArgs) value);
 201                 }
 202
 203                 #endregion // Methods
 204
 205                 #region Events and Delegates
 206
 207                 public event OleDbRowUpdatedEventHandler RowUpdated {
 208                         add { Events.AddHandler (EventRowUpdated, value); }
 209                         remove { Events.RemoveHandler (EventRowUpdated, value); }
 210                 }
 211
 212                 public event OleDbRowUpdatedEventHandler RowUpdating {
 213                         add { Events.AddHandler (EventRowUpdating, value); }
 214                         remove { Events.RemoveHandler (EventRowUpdating, value); }
 215                 }
 216
 217                 #endregion // Events and Delegates
 218
 219         }
 220 }