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

   1 //
   2 // System.Web.UI.WebControls.SqlDataSource
   3 //
   4 // Authors:
   5 //      Ben Maurer (bmaurer@users.sourceforge.net)
   6 //      Sanjay Gupta (gsanjay@novell.com)
   7 //      Chris Toshok (toshok@ximian.com)
   8 //
   9 // (C) 2003 Ben Maurer
  10 // (C) 2004-2006 Novell, Inc. (http://www.novell.com)
  11 //
  12
  13 //
  14 // Permission is hereby granted, free of charge, to any person obtaining
  15 // a copy of this software and associated documentation files (the
  16 // "Software"), to deal in the Software without restriction, including
  17 // without limitation the rights to use, copy, modify, merge, publish,
  18 // distribute, sublicense, and/or sell copies of the Software, and to
  19 // permit persons to whom the Software is furnished to do so, subject to
  20 // the following conditions:
  21 //
  22 // The above copyright notice and this permission notice shall be
  23 // included in all copies or substantial portions of the Software.
  24 //
  25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  29 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  30 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  31 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  32 //
  33
  34 #if NET_2_0
  35 using System.Collections;
  36 using System.Collections.Specialized;
  37 using System.Configuration;
  38 using System.Drawing;
  39 using System.Web.Configuration;
  40 using System.Data.Common;
  41 using System.Data.SqlClient;
  42 using System.Text;
  43 using System.ComponentModel;
  44
  45 namespace System.Web.UI.WebControls {
  46
  47         [ParseChildrenAttribute (true)]
  48         [PersistChildrenAttribute (false)]
  49         [DefaultPropertyAttribute ("SelectQuery")]
  50         [DesignerAttribute ("System.Web.UI.Design.WebControls.SqlDataSourceDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
  51         [DefaultEventAttribute ("Selecting")]
  52         public class SqlDataSource : DataSourceControl {
  53
  54                 static readonly string [] emptyNames = new string [] { "DefaultView" };
  55
  56                 public SqlDataSource ()
  57                 {
  58                 }
  59
  60                 public SqlDataSource (string connectionString, string selectCommand)
  61                 {
  62                         ConnectionString = connectionString;
  63                         SelectCommand = selectCommand;
  64                 }
  65
  66                 public SqlDataSource (string providerName, string connectionString, string selectCommand)
  67                 {
  68                         ProviderName = providerName;
  69                         ConnectionString = connectionString;
  70                         SelectCommand = selectCommand;
  71                 }
  72
  73                 protected override DataSourceView GetView (string viewName)
  74                 {
  75                         if (String.IsNullOrEmpty (viewName) || (String.Compare (viewName, emptyNames [0], StringComparison.InvariantCultureIgnoreCase) == 0))
  76                                 return View;
  77                         else
  78                                 throw new ArgumentException ("viewName");
  79                 }
  80
  81                 protected virtual SqlDataSourceView CreateDataSourceView (string viewName)
  82                 {
  83                         SqlDataSourceView view = new SqlDataSourceView (this, viewName, this.Context);
  84                         if (IsTrackingViewState)
  85                                 ((IStateManager) view).TrackViewState ();
  86                         return view;
  87                 }
  88
  89                 protected virtual DbProviderFactory GetDbProviderFactory ()
  90                 {
  91                         DbProviderFactory f = null;
  92
  93                         if (!String.IsNullOrEmpty (ProviderName)) {
  94                                 f = DbProviderFactories.GetFactory(ProviderName);
  95                                 return f;
  96                         }
  97
  98                         return SqlClientFactory.Instance;
  99                 }
 100
 101                 internal DbProviderFactory GetDbProviderFactoryInternal ()
 102                 {
 103                         return GetDbProviderFactory ();
 104                 }
 105
 106                 protected override ICollection GetViewNames ()
 107                 {
 108                         return emptyNames;
 109                 }
 110
 111                 public int Insert ()
 112                 {
 113                         return View.Insert (null);
 114                 }
 115
 116                 public int Delete ()
 117                 {
 118                         return View.Delete (null, null);
 119                 }
 120
 121                 public IEnumerable Select (DataSourceSelectArguments args)
 122                 {
 123                         return View.Select (args);
 124                 }
 125
 126                 public int Update ()
 127                 {
 128                         return View.Update (null, null, null);
 129                 }
 130
 131                 protected internal override void OnInit (EventArgs e)
 132                 {
 133                         Page.LoadComplete += OnPageLoadComplete;
 134                 }
 135
 136                 void OnPageLoadComplete (object sender, EventArgs e)
 137                 {
 138                         FilterParameters.UpdateValues (Context, this);
 139                         SelectParameters.UpdateValues (Context, this);
 140                 }
 141
 142                 protected override void LoadViewState (object savedState)
 143                 {
 144                         Pair p = savedState as Pair;
 145                         if (p != null) {
 146                                 base.LoadViewState (p.First);
 147                                 ((IStateManager) View).LoadViewState (p.Second);
 148                         }
 149                 }
 150
 151                 protected override object SaveViewState ()
 152                 {
 153                         object me = base.SaveViewState (), view = ((IStateManager) View).SaveViewState ();
 154                         if (me != null || view != null)
 155                                 return new Pair (me, view);
 156                         else
 157                                 return null;
 158                 }
 159
 160                 protected override void TrackViewState ()
 161                 {
 162                         base.TrackViewState ();
 163                         if (view != null)
 164                                 ((IStateManager) view).TrackViewState ();
 165                 }
 166
 167                 [DefaultValue (true)]
 168                 public virtual bool CancelSelectOnNullParameter {
 169                         get { return View.CancelSelectOnNullParameter; }
 170                         set { View.CancelSelectOnNullParameter = value; }
 171                 }
 172
 173                 [DefaultValue (ConflictOptions.OverwriteChanges)]
 174                 public ConflictOptions ConflictDetection {
 175                         get { return View.ConflictDetection; }
 176                         set { View.ConflictDetection = value; }
 177                 }
 178
 179                 [DefaultValue (SqlDataSourceCommandType.Text)]
 180                 public SqlDataSourceCommandType DeleteCommandType {
 181                         get { return View.DeleteCommandType; }
 182                         set { View.DeleteCommandType = value; }
 183                 }
 184
 185                 [DefaultValue (SqlDataSourceCommandType.Text)]
 186                 public SqlDataSourceCommandType InsertCommandType {
 187                         get { return View.InsertCommandType; }
 188                         set { View.InsertCommandType = value; }
 189                 }
 190
 191                 [DefaultValue (SqlDataSourceCommandType.Text)]
 192                 public SqlDataSourceCommandType SelectCommandType {
 193                         get { return View.SelectCommandType; }
 194                         set { View.SelectCommandType = value; }
 195                 }
 196
 197                 [DefaultValue (SqlDataSourceCommandType.Text)]
 198                 public SqlDataSourceCommandType UpdateCommandType {
 199                         get { return View.UpdateCommandType; }
 200                         set { View.UpdateCommandType = value; }
 201                 }
 202
 203                 [DefaultValue ("{0}")]
 204                 public string OldValuesParameterFormatString {
 205                         get { return View.OldValuesParameterFormatString; }
 206                         set { View.OldValuesParameterFormatString = value; }
 207                 }
 208
 209                 [DefaultValue ("")]
 210                 public string SortParameterName
 211                 {
 212                         get { return View.SortParameterName; }
 213                         set { View.SortParameterName = value; }
 214                 }
 215
 216                 [DefaultValueAttribute ("")]
 217                 public string FilterExpression
 218                 {
 219                         get { return View.FilterExpression; }
 220                         set { View.FilterExpression = value; }
 221                 }
 222
 223                 private string providerName = "";
 224                 [DefaultValueAttribute ("")]
 225                 [TypeConverterAttribute ("System.Web.UI.Design.WebControls.DataProviderNameConverter, " + Consts.AssemblySystem_Design)]
 226                 public virtual string ProviderName {
 227                         get { return providerName; }
 228                         set
 229                         {
 230                                 providerName = value;
 231                                 RaiseDataSourceChangedEvent (EventArgs.Empty);
 232                         }
 233                 }
 234
 235                 private string connectionString = "";
 236                 [EditorAttribute ("System.Web.UI.Design.WebControls.SqlDataSourceConnectionStringEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 237                 [DefaultValueAttribute ("")]
 238                 public virtual string ConnectionString {
 239                         get { return connectionString; }
 240                         set
 241                         {
 242
 243                                 connectionString = value;
 244                                 RaiseDataSourceChangedEvent (EventArgs.Empty);
 245                         }
 246                 }
 247
 248                 // LAME SPEC: MSDN says value should be saved in ViewState but tests show otherwise.
 249                 private SqlDataSourceMode dataSourceMode = SqlDataSourceMode.DataSet;
 250                 [DefaultValueAttribute (SqlDataSourceMode.DataSet)]
 251                 public SqlDataSourceMode DataSourceMode {
 252                         get { return dataSourceMode; }
 253                         set
 254                         {
 255                                 dataSourceMode = value;
 256                                 RaiseDataSourceChangedEvent (EventArgs.Empty);
 257                         }
 258                 }
 259
 260                 [DefaultValueAttribute ("")]
 261                 public string DeleteCommand {
 262                         get { return View.DeleteCommand; }
 263                         set { View.DeleteCommand = value; }
 264                 }
 265
 266                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 267                 [MergablePropertyAttribute (false)]
 268                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 269                 [DefaultValueAttribute (null)]
 270                 public ParameterCollection DeleteParameters {
 271                         get { return View.DeleteParameters; }
 272                 }
 273
 274                 [DefaultValueAttribute (null)]
 275                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 276                 [MergablePropertyAttribute (false)]
 277                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 278                 public ParameterCollection FilterParameters {
 279                         get { return View.FilterParameters; }
 280                 }
 281
 282                 [DefaultValueAttribute ("")]
 283                 public string InsertCommand {
 284                         get { return View.InsertCommand; }
 285                         set { View.InsertCommand = value; }
 286                 }
 287
 288                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 289                 [DefaultValueAttribute (null)]
 290                 [MergablePropertyAttribute (false)]
 291                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 292                 public ParameterCollection InsertParameters {
 293                         get { return View.InsertParameters; }
 294                 }
 295
 296                 [DefaultValueAttribute ("")]
 297                 public string SelectCommand {
 298                         get { return View.SelectCommand; }
 299                         set { View.SelectCommand = value; }
 300                 }
 301
 302                 [DefaultValueAttribute (null)]
 303                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 304                 [MergablePropertyAttribute (false)]
 305                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 306                 public ParameterCollection SelectParameters {
 307                         get { return View.SelectParameters; }
 308                 }
 309
 310                 [DefaultValueAttribute ("")]
 311                 public string UpdateCommand {
 312                         get { return View.UpdateCommand; }
 313                         set { View.UpdateCommand = value; }
 314                 }
 315
 316                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 317                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 318                 [MergablePropertyAttribute (false)]
 319                 [DefaultValueAttribute (null)]
 320                 public ParameterCollection UpdateParameters {
 321                         get { return View.UpdateParameters; }
 322                 }
 323
 324 #region TODO
 325
 326                 int cacheDuration = 0;
 327                 bool enableCaching = false;
 328                 string cacheKeyDependency = null;
 329                 string sqlCacheDependency = null;
 330                 DataSourceCacheManager cache = null;
 331                 DataSourceCacheExpiry cacheExpirationPolicy = DataSourceCacheExpiry.Absolute;
 332
 333                 internal DataSourceCacheManager Cache
 334                 {
 335                         get
 336                         {
 337                                 if (cache == null)
 338                                         cache = new DataSourceCacheManager (CacheDuration, CacheKeyDependency, CacheExpirationPolicy, this, Context);
 339                                 return cache;
 340                         }
 341                 }
 342
 343                 [DefaultValue ("")]
 344                 public virtual string CacheKeyDependency
 345                 {
 346                         get { return cacheKeyDependency != null ? cacheKeyDependency : string.Empty; }
 347                         set { cacheKeyDependency = value; }
 348                 }
 349
 350                 [MonoTODO ("SQLServer specific")]
 351                 [DefaultValue ("")]
 352                 public virtual string SqlCacheDependency {
 353                         get { return sqlCacheDependency != null ? sqlCacheDependency : string.Empty; }
 354                         set { sqlCacheDependency = value; }
 355                 }
 356
 357                 [DefaultValue (0)]
 358                 public virtual int CacheDuration {
 359                         get { return cacheDuration; }
 360                         set
 361                         {
 362                                 if (value < 0)
 363                                         throw new ArgumentOutOfRangeException ("value", "The duration must be non-negative");
 364
 365                                 cacheDuration = value;
 366                         }
 367                 }
 368
 369                 [DefaultValue (DataSourceCacheExpiry.Absolute)]
 370                 public virtual DataSourceCacheExpiry CacheExpirationPolicy {
 371                         get { return cacheExpirationPolicy; ; }
 372                         set { cacheExpirationPolicy = value; }
 373                 }
 374
 375                 [DefaultValue (false)]
 376                 public virtual bool EnableCaching {
 377                         get { return enableCaching; }
 378                         set
 379                         {
 380                                 if (DataSourceMode == SqlDataSourceMode.DataReader && value == true)
 381                                         throw new NotSupportedException ();
 382                                 enableCaching = value;
 383                         }
 384                 }
 385
 386 #endregion
 387
 388                 public event SqlDataSourceStatusEventHandler Deleted {
 389                         add { View.Deleted += value; }
 390                         remove { View.Deleted -= value; }
 391                 }
 392
 393                 public event SqlDataSourceCommandEventHandler Deleting {
 394                         add { View.Deleting += value; }
 395                         remove { View.Deleting -= value; }
 396                 }
 397
 398                 public event SqlDataSourceStatusEventHandler Inserted {
 399                         add { View.Inserted += value; }
 400                         remove { View.Inserted -= value; }
 401                 }
 402
 403                 public event SqlDataSourceFilteringEventHandler Filtering {
 404                         add { View.Filtering += value; }
 405                         remove { View.Filtering -= value; }
 406                 }
 407
 408                 public event SqlDataSourceCommandEventHandler Inserting {
 409                         add { View.Inserting += value; }
 410                         remove { View.Inserting -= value; }
 411                 }
 412
 413                 public event SqlDataSourceStatusEventHandler Selected {
 414                         add { View.Selected += value; }
 415                         remove { View.Selected -= value; }
 416                 }
 417
 418                 public event SqlDataSourceSelectingEventHandler Selecting {
 419                         add { View.Selecting += value; }
 420                         remove { View.Selecting -= value; }
 421                 }
 422
 423                 public event SqlDataSourceStatusEventHandler Updated {
 424                         add { View.Updated += value; }
 425                         remove { View.Updated -= value; }
 426                 }
 427
 428                 public event SqlDataSourceCommandEventHandler Updating {
 429                         add { View.Updating += value; }
 430                         remove { View.Updating -= value; }
 431                 }
 432
 433                 SqlDataSourceView view;
 434                 SqlDataSourceView View {
 435                         get {
 436                                 if (view == null) {
 437                                         view = CreateDataSourceView ("DefaultView");
 438                                         if (IsTrackingViewState)
 439                                                 ((IStateManager) view).TrackViewState ();
 440                                 }
 441                                 return view;
 442                         }
 443                 }
 444         }
 445 }
 446 #endif
 447
 448
 449