mcs/class/System.Web/System.Web.UI.WebControls/SqlDataSourceView.cs

   1 //
   2 // System.Web.UI.WebControls.SqlDataSourceView
   3 //
   4 // Authors:
   5 //      Ben Maurer (bmaurer@users.sourceforge.net)
   6 //      Sanjay Gupta (gsanjay@novell.com)
   7 //
   8 // (C) 2003 Ben Maurer
   9 // (C) Novell, Inc. (http://www.novell.com)
  10 //
  11
  12 //
  13 // Permission is hereby granted, free of charge, to any person obtaining
  14 // a copy of this software and associated documentation files (the
  15 // "Software"), to deal in the Software without restriction, including
  16 // without limitation the rights to use, copy, modify, merge, publish,
  17 // distribute, sublicense, and/or sell copies of the Software, and to
  18 // permit persons to whom the Software is furnished to do so, subject to
  19 // the following conditions:
  20 //
  21 // The above copyright notice and this permission notice shall be
  22 // included in all copies or substantial portions of the Software.
  23 //
  24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  28 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  29 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  30 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  31 //
  32
  33 #if NET_2_0
  34 using System.Collections;
  35 using System.Collections.Specialized;
  36 using System.Text;
  37 using System.Data;
  38 using System.ComponentModel;
  39 using System.Data.SqlClient;
  40
  41 namespace System.Web.UI.WebControls {
  42         public class SqlDataSourceView : DataSourceView, IStateManager {
  43
  44                 SqlCommand command;
  45                 SqlConnection connection;
  46
  47                 public SqlDataSourceView (SqlDataSource owner, string name)
  48                 {
  49                         this.owner = owner;
  50                         this.name = name;
  51                         connection = new SqlConnection (owner.ConnectionString);
  52                 }
  53
  54                 public int Delete (IDictionary keys, IDictionary oldValues)
  55                 {
  56                         return ExecuteDelete (keys, oldValues);
  57                 }
  58
  59                 [MonoTODO ("Handle keys and oldValues and parameters")]
  60                 protected override int ExecuteDelete(IDictionary keys, IDictionary oldValues)
  61                 {
  62                         command = new SqlCommand (this.DeleteCommand, connection);
  63                         connection.Open ();
  64                         int result = command.ExecuteNonQuery ();
  65                         connection.Close ();
  66                         return result;
  67                 }
  68
  69                 public int Insert (IDictionary values)
  70                 {
  71                         return Insert (values);
  72                 }
  73
  74                 [MonoTODO ("Handle values and parameters")]
  75                 protected override int ExecuteInsert (IDictionary values)
  76                 {
  77                         command = new SqlCommand (this.InsertCommand, connection);
  78                         connection.Open ();
  79                         int result = command.ExecuteNonQuery ();
  80                         connection.Close ();
  81                         return result;
  82                 }
  83
  84                 public IEnumerable Select (DataSourceSelectArguments arguments)
  85                 {
  86                         return ExecuteSelect (arguments);
  87                 }
  88
  89                 [MonoTODO("Extra method to keep things compiling, need to remove later")]
  90                 public IEnumerable Select()
  91                 {
  92                         throw new NotImplementedException ("Not required");
  93                 }
  94
  95                 [MonoTODO ("Handle arguments")]
  96                 protected internal override IEnumerable ExecuteSelect (
  97                                                 DataSourceSelectArguments arguments)
  98                 {
  99                         command = new SqlCommand (this.SelectCommand, connection);
 100                         connection.Open ();
 101                         SqlDataReader reader = command.ExecuteReader ();
 102                         //return reader.GetEnumerator ();
 103                         throw new NotImplementedException ("SqlDataReader doesnt implements GetEnumerator method yet");
 104                 }
 105
 106                 public int Update(IDictionary keys, IDictionary values,
 107                         IDictionary oldValues)
 108                 {
 109                         return ExecuteUpdate (keys, values, oldValues);
 110                 }
 111
 112                 [MonoTODO ("Handle keys, values and oldValues")]
 113                 protected override int ExecuteUpdate (IDictionary keys,
 114                                         IDictionary values, IDictionary oldValues)
 115                 {
 116                         command = new SqlCommand (this.UpdateCommand, connection);
 117                         connection.Open ();
 118                         int result = command.ExecuteNonQuery();
 119                         connection.Close();
 120                         return result;
 121                 }
 122
 123
 124                 void IStateManager.LoadViewState (object savedState)
 125                 {
 126                         LoadViewState (savedState);
 127                 }
 128
 129                 object IStateManager.SaveViewState ()
 130                 {
 131                         return SaveViewState ();
 132                 }
 133
 134                 void IStateManager.TrackViewState ()
 135                 {
 136                         TrackViewState ();
 137                 }
 138
 139                 protected virtual void LoadViewState (object savedState)
 140                 {
 141                         object [] vs = savedState as object [];
 142                         if (vs == null)
 143                                 return;
 144
 145                         if (vs [0] != null) ((IStateManager) deleteParameters).LoadViewState (vs [0]);
 146                         if (vs [1] != null) ((IStateManager) filterParameters).LoadViewState (vs [1]);
 147                         if (vs [2] != null) ((IStateManager) insertParameters).LoadViewState (vs [2]);
 148                         if (vs [3] != null) ((IStateManager) selectParameters).LoadViewState (vs [3]);
 149                         if (vs [4] != null) ((IStateManager) updateParameters).LoadViewState (vs [4]);
 150                         if (vs [5] != null) ((IStateManager) viewState).LoadViewState (vs [5]);
 151                 }
 152
 153                 protected virtual object SaveViewState ()
 154                 {
 155                         object [] vs = new object [6];
 156
 157                         if (deleteParameters != null) vs [0] = ((IStateManager) deleteParameters).SaveViewState ();
 158                         if (filterParameters != null) vs [1] = ((IStateManager) filterParameters).SaveViewState ();
 159                         if (insertParameters != null) vs [2] = ((IStateManager) insertParameters).SaveViewState ();
 160                         if (selectParameters != null) vs [3] = ((IStateManager) selectParameters).SaveViewState ();
 161                         if (updateParameters != null) vs [4] = ((IStateManager) updateParameters).SaveViewState ();
 162                         if (viewState != null) vs [5] = ((IStateManager) viewState).SaveViewState ();
 163
 164                         foreach (object o in vs)
 165                                 if (o != null) return vs;
 166                         return null;
 167                 }
 168
 169                 protected virtual void TrackViewState ()
 170                 {
 171                         tracking = true;
 172
 173                         if (deleteParameters != null) ((IStateManager) deleteParameters).TrackViewState ();
 174                         if (filterParameters != null) ((IStateManager) filterParameters).TrackViewState ();
 175                         if (insertParameters != null) ((IStateManager) insertParameters).TrackViewState ();
 176                         if (selectParameters != null) ((IStateManager) selectParameters).TrackViewState ();
 177                         if (updateParameters != null) ((IStateManager) updateParameters).TrackViewState ();
 178                         if (viewState != null) ((IStateManager) viewState).TrackViewState ();
 179                 }
 180
 181                 protected bool IsTrackingViewState {
 182                         get { return tracking; }
 183                 }
 184
 185                 bool IStateManager.IsTrackingViewState {
 186                         get { return IsTrackingViewState; }
 187                 }
 188
 189                 public string DeleteCommand {
 190                         get {
 191                                 string val = ViewState ["DeleteCommand"] as string;
 192                                 return val == null ? "" : val;
 193                         }
 194                         set { ViewState ["DeleteCommand"] = value; }
 195                 }
 196
 197                 public string FilterExpression {
 198                         get {
 199                                 string val = ViewState ["FilterExpression"] as string;
 200                                 return val == null ? "" : val;
 201                         }
 202                         set { ViewState ["FilterExpression"] = value; }
 203                 }
 204
 205                 public string InsertCommand {
 206                         get {
 207                                 string val = ViewState ["InsertCommand"] as string;
 208                                 return val == null ? "" : val;
 209                         }
 210                         set { ViewState ["InsertCommand"] = value; }
 211                 }
 212
 213                 public string SelectCommand {
 214                         get {
 215                                 string val = ViewState ["SelectCommand"] as string;
 216                                 return val == null ? "" : val;
 217                         }
 218                         set { ViewState ["SelectCommand"] = value; }
 219                 }
 220
 221                 public string UpdateCommand {
 222                         get {
 223                                 string val = ViewState ["UpdateCommand"] as string;
 224                                 return val == null ? "" : val;
 225                         }
 226                         set { ViewState ["UpdateCommand"] = value; }
 227                 }
 228
 229                 public string SortExpression {
 230                         get {
 231                                 string val = ViewState ["SortExpression"] as string;
 232                                 return val == null ? "" : val;
 233                         }
 234                         set { ViewState ["SortExpression"] = value; }
 235                 }
 236
 237                 public override bool CanDelete {
 238                         get { return DeleteCommand != ""; }
 239                 }
 240
 241                 public override bool CanInsert {
 242                         get { return UpdateCommand != ""; }
 243                 }
 244
 245                 public override bool CanSort {
 246                         get { return owner.DataSourceMode == SqlDataSourceMode.DataSet; }
 247                 }
 248
 249                 public override bool CanUpdate {
 250                         get { return UpdateCommand != ""; }
 251                 }
 252
 253                 EventHandlerList events;
 254                 protected EventHandlerList Events {
 255                         get {
 256                                 if (events == null)
 257                                         events = new EventHandlerList ();
 258
 259                                 return events;
 260                         }
 261                 }
 262
 263                 void ParametersChanged (object source, EventArgs args)
 264                 {
 265                         OnDataSourceViewChanged (EventArgs.Empty);
 266                 }
 267
 268                 ParameterCollection GetParameterCollection (ref ParameterCollection output)
 269                 {
 270                         if (output != null)
 271                                 return output;
 272
 273                         output = new ParameterCollection ();
 274                         output.ParametersChanged += new EventHandler (ParametersChanged);
 275
 276                         if (IsTrackingViewState)
 277                                 ((IStateManager) output).TrackViewState ();
 278
 279                         return output;
 280                 }
 281
 282                 public ParameterCollection DeleteParameters {
 283                         get { return GetParameterCollection (ref deleteParameters); }
 284                 }
 285
 286                 public ParameterCollection FilterParameters {
 287                         get { return GetParameterCollection (ref filterParameters); }
 288                 }
 289
 290                 public ParameterCollection InsertParameters {
 291                         get { return GetParameterCollection (ref insertParameters); }
 292                 }
 293
 294                 public ParameterCollection SelectParameters {
 295                         get { return GetParameterCollection (ref selectParameters); }
 296                 }
 297
 298                 public ParameterCollection UpdateParameters {
 299                         get { return GetParameterCollection (ref updateParameters); }
 300                 }
 301
 302
 303                 public override string Name {
 304                         get { return name; }
 305                 }
 306
 307                 protected virtual string ParameterPrefix {
 308                         get { return "@"; }
 309                 }
 310
 311                 StateBag viewState;
 312                 protected StateBag ViewState {
 313                         get {
 314                                 if (viewState != null)
 315                                         return viewState;
 316
 317                                 viewState = new StateBag ();
 318                                 if (IsTrackingViewState)
 319                                         viewState.TrackViewState ();
 320
 321                                 return viewState;
 322                         }
 323                 }
 324
 325                 ParameterCollection deleteParameters;
 326                 ParameterCollection filterParameters;
 327                 ParameterCollection insertParameters;
 328                 ParameterCollection selectParameters;
 329                 ParameterCollection updateParameters;
 330
 331                 bool tracking;
 332
 333                 string name;
 334                 SqlDataSource owner;
 335
 336                 static readonly object EventDataSourceViewChanged = new object ();
 337
 338                 protected virtual void OnDataSourceViewChanged (EventArgs e)
 339                 {
 340                         if (events == null) return;
 341                         EventHandler h = events [EventDataSourceViewChanged] as EventHandler;
 342                         if (h != null)
 343                                 h (this, e);
 344                 }
 345
 346                 public event EventHandler DataSourceViewChanged {
 347                         add { Events.AddHandler (EventDataSourceViewChanged, value); }
 348                         remove { Events.RemoveHandler (EventDataSourceViewChanged, value); }
 349                 }
 350
 351                 #region OnDelete
 352                 static readonly object EventDeleted = new object ();
 353                 protected virtual void OnDeleted (SqlDataSourceStatusEventArgs e)
 354                 {
 355                         if (events == null) return;
 356                         SqlDataSourceStatusEventHandler h = events [EventDeleted] as SqlDataSourceStatusEventHandler;
 357                         if (h != null)
 358                                 h (this, e);
 359                 }
 360
 361                 public event SqlDataSourceStatusEventHandler Deleted {
 362                         add { Events.AddHandler (EventDeleted, value); }
 363                         remove { Events.RemoveHandler (EventDeleted, value); }
 364                 }
 365
 366                 static readonly object EventDeleting = new object ();
 367                 protected virtual void OnDeleting (SqlDataSourceCommandEventArgs e)
 368                 {
 369                         if (events == null) return;
 370                         SqlDataSourceCommandEventHandler h = events [EventDeleting] as SqlDataSourceCommandEventHandler;
 371                         if (h != null)
 372                                 h (this, e);
 373                 }
 374                 public event SqlDataSourceCommandEventHandler Deleting {
 375                         add { Events.AddHandler (EventDeleting, value); }
 376                         remove { Events.RemoveHandler (EventDeleting, value); }
 377                 }
 378                 #endregion
 379
 380                 #region OnInsert
 381                 static readonly object EventInserted = new object ();
 382                 protected virtual void OnInserted (SqlDataSourceStatusEventArgs e)
 383                 {
 384                         if (events == null) return;
 385                         SqlDataSourceStatusEventHandler h = events [EventInserted] as SqlDataSourceStatusEventHandler;
 386                         if (h != null)
 387                                 h (this, e);
 388                 }
 389
 390                 public event SqlDataSourceStatusEventHandler Inserted {
 391                         add { Events.AddHandler (EventInserted, value); }
 392                         remove { Events.RemoveHandler (EventInserted, value); }
 393                 }
 394
 395                 static readonly object EventInserting = new object ();
 396                 protected virtual void OnInserting (SqlDataSourceCommandEventArgs e)
 397                 {
 398                         if (events == null) return;
 399                         SqlDataSourceCommandEventHandler h = events [EventInserting] as SqlDataSourceCommandEventHandler;
 400                         if (h != null)
 401                                 h (this, e);
 402                 }
 403                 public event SqlDataSourceCommandEventHandler Inserting {
 404                         add { Events.AddHandler (EventInserting, value); }
 405                         remove { Events.RemoveHandler (EventInserting, value); }
 406                 }
 407                 #endregion
 408
 409                 #region OnSelect
 410                 static readonly object EventSelected = new object ();
 411                 protected virtual void OnSelected (SqlDataSourceStatusEventArgs e)
 412                 {
 413                         if (events == null) return;
 414                         SqlDataSourceStatusEventHandler h = events [EventSelected] as SqlDataSourceStatusEventHandler;
 415                         if (h != null)
 416                                 h (this, e);
 417                 }
 418
 419                 public event SqlDataSourceStatusEventHandler Selected {
 420                         add { Events.AddHandler (EventSelected, value); }
 421                         remove { Events.RemoveHandler (EventSelected, value); }
 422                 }
 423
 424                 static readonly object EventSelecting = new object ();
 425                 protected virtual void OnSelecting (SqlDataSourceCommandEventArgs e)
 426                 {
 427                         if (events == null) return;
 428                         SqlDataSourceCommandEventHandler h = events [EventSelecting] as SqlDataSourceCommandEventHandler;
 429                         if (h != null)
 430                                 h (this, e);
 431                 }
 432                 public event SqlDataSourceCommandEventHandler Selecting {
 433                         add { Events.AddHandler (EventSelecting, value); }
 434                         remove { Events.RemoveHandler (EventSelecting, value); }
 435                 }
 436                 #endregion
 437
 438                 #region OnUpdate
 439                 static readonly object EventUpdated = new object ();
 440                 protected virtual void OnUpdated (SqlDataSourceStatusEventArgs e)
 441                 {
 442                         if (events == null) return;
 443                         SqlDataSourceStatusEventHandler h = events [EventUpdated] as SqlDataSourceStatusEventHandler;
 444                         if (h != null)
 445                                 h (this, e);
 446                 }
 447
 448                 public event SqlDataSourceStatusEventHandler Updated {
 449                         add { Events.AddHandler (EventUpdated, value); }
 450                         remove { Events.RemoveHandler (EventUpdated, value); }
 451                 }
 452
 453                 static readonly object EventUpdating = new object ();
 454                 protected virtual void OnUpdating (SqlDataSourceCommandEventArgs e)
 455                 {
 456                         if (events == null) return;
 457                         SqlDataSourceCommandEventHandler h = events [EventUpdating] as SqlDataSourceCommandEventHandler;
 458                         if (h != null)
 459                                 h (this, e);
 460                 }
 461                 public event SqlDataSourceCommandEventHandler Updating {
 462                         add { Events.AddHandler (EventUpdating, value); }
 463                         remove { Events.RemoveHandler (EventUpdating, value); }
 464                 }
 465                 #endregion
 466
 467         }
 468
 469 }
 470 #endif
 471