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                 public SqlDataSource ()
  55                 {
  56                 }
  57
  58                 public SqlDataSource (string connectionString, string selectCommand)
  59                 {
  60                         ConnectionString = connectionString;
  61                         SelectCommand = selectCommand;
  62                 }
  63
  64                 public SqlDataSource (string providerName, string connectionString, string selectCommand)
  65                 {
  66                         ProviderName = providerName;
  67                         ConnectionString = connectionString;
  68                         SelectCommand = selectCommand;
  69                 }
  70
  71                 protected override DataSourceView GetView (string viewName)
  72                 {
  73                         if (viewName == "" || viewName == null)
  74                                 return View;
  75                         else
  76                                 throw new ArgumentException ("viewName");
  77                 }
  78
  79                 protected virtual SqlDataSourceView CreateDataSourceView (string viewName)
  80                 {
  81                         SqlDataSourceView view = new SqlDataSourceView (this, viewName, this.Context);
  82                         view.DataSourceViewChanged += new EventHandler (ViewChanged);
  83                         if (IsTrackingViewState)
  84                                 ((IStateManager) view).TrackViewState ();
  85                         return view;
  86                 }
  87
  88                 protected virtual DbProviderFactory GetDbProviderFactory ()
  89                 {
  90                         DbProviderFactory f = null;
  91
  92                         if (ProviderName != null && ProviderName != "") {
  93                                 try {
  94                                         f = DbProviderFactories.GetFactory(ProviderName);
  95                                 }
  96                                 catch { /* nada */ }
  97                                 if (f != null)
  98                                         return f;
  99                         }
 100
 101                         return SqlClientFactory.Instance;
 102                 }
 103
 104                 internal DbProviderFactory GetDbProviderFactoryInternal ()
 105                 {
 106                         return GetDbProviderFactory ();
 107                 }
 108
 109                 protected override ICollection GetViewNames ()
 110                 {
 111                         return new string [] { "DefaultView" };
 112                 }
 113
 114                 public int Insert ()
 115                 {
 116                         return View.Insert (null);
 117                 }
 118
 119                 public int Delete ()
 120                 {
 121                         return View.Delete (null, null);
 122                 }
 123
 124                 public IEnumerable Select (DataSourceSelectArguments args)
 125                 {
 126                         return View.Select (args);
 127                 }
 128
 129                 public int Update ()
 130                 {
 131                         return View.Update (null, null, null);
 132                 }
 133
 134                 protected override void LoadViewState (object savedState)
 135                 {
 136                         Pair p = savedState as Pair;
 137                         if (p != null) {
 138                                 base.LoadViewState (p.First);
 139                                 ((IStateManager) View).LoadViewState (p.Second);
 140                         }
 141                 }
 142
 143                 protected override object SaveViewState ()
 144                 {
 145                         object me = base.SaveViewState (), view = ((IStateManager) View).SaveViewState ();
 146                         if (me != null || view != null)
 147                                 return new Pair (me, view);
 148                         else
 149                                 return null;
 150                 }
 151
 152                 protected override void TrackViewState ()
 153                 {
 154                         base.TrackViewState ();
 155                         if (view != null)
 156                                 ((IStateManager) view).TrackViewState ();
 157                 }
 158
 159 #region TODO
 160                 [MonoTODO]
 161                 [DefaultValue ("")]
 162                 public virtual string CacheKeyDependency {
 163                         get { return ViewState.GetString ("CacheKeyDependency", ""); }
 164                         set { ViewState ["CacheKeyDependency"] = value; }
 165                 }
 166
 167                 [MonoTODO]
 168                 [DefaultValue (true)]
 169                 public virtual bool CancelSelectOnNullParameter {
 170                         get { return ViewState.GetBool ("CancelSelectOnNullParameter", true); }
 171                         set { ViewState["CancelSelectOnNullParameter"] = value; }
 172                 }
 173
 174                 [MonoTODO]
 175                 [DefaultValue (ConflictOptions.OverwriteChanges)]
 176                 public ConflictOptions ConflictDetection {
 177                         get { return (ConflictOptions) ViewState.GetInt ("ConflictDetection", (int)ConflictOptions.OverwriteChanges); }
 178                         set { ViewState ["ConflictDetection"] = value; }
 179                 }
 180
 181                 [MonoTODO]
 182                 [DefaultValue (SqlDataSourceCommandType.Text)]
 183                 public SqlDataSourceCommandType DeleteCommandType {
 184                         get { return (SqlDataSourceCommandType) ViewState.GetInt ("DeleteCommandType", (int)SqlDataSourceCommandType.StoredProcedure); }
 185                         set { ViewState ["DeleteCommandType"] = value; }
 186                 }
 187
 188                 [MonoTODO]
 189                 [DefaultValue (SqlDataSourceCommandType.Text)]
 190                 public SqlDataSourceCommandType InsertCommandType {
 191                         get { return (SqlDataSourceCommandType) ViewState.GetInt ("InsertCommandType", (int)SqlDataSourceCommandType.StoredProcedure); }
 192                         set { ViewState ["InsertCommandType"] = value; }
 193                 }
 194
 195                 [MonoTODO]
 196                 [DefaultValue (SqlDataSourceCommandType.Text)]
 197                 public SqlDataSourceCommandType SelectCommandType {
 198                         get { return (SqlDataSourceCommandType) ViewState.GetInt ("SelectCommandType", (int)SqlDataSourceCommandType.StoredProcedure); }
 199                         set { ViewState ["SelectCommandType"] = value; }
 200                 }
 201
 202                 [MonoTODO]
 203                 [DefaultValue (SqlDataSourceCommandType.Text)]
 204                 public SqlDataSourceCommandType UpdateCommandType {
 205                         get { return (SqlDataSourceCommandType) ViewState.GetInt ("UpdateCommandType", (int)SqlDataSourceCommandType.StoredProcedure); }
 206                         set { ViewState ["UpdateCommandType"] = value; }
 207                 }
 208
 209                 [MonoTODO]
 210                 [DefaultValue ("{0}")]
 211                 public string OldValuesParameterFormatString {
 212                         get { return ViewState.GetString ("OldValuesParameterFormatString", "{0}"); }
 213                         set { ViewState ["OldValuesParameterFormatString"] = value; }
 214                 }
 215
 216                 [DefaultValue ("")]
 217                 [MonoTODO]
 218                 public virtual string SqlCacheDependency {
 219                         get { return ViewState.GetString ("SqlCacheDependency", ""); }
 220                         set { ViewState ["SqlCacheDependency"] = value; }
 221                 }
 222
 223                 [MonoTODO]
 224                 [DefaultValue ("")]
 225                 public string SortParameterName {
 226                         get { return ViewState.GetString ("SortParameterName", ""); }
 227                         set { ViewState ["SortParameterName"] = value; }
 228                 }
 229
 230                 [DefaultValue (0)]
 231                 //              [TypeConverter (typeof (DataSourceCacheDurationConverter))]
 232                 public virtual int CacheDuration {
 233                         get { return ViewState.GetInt ("CacheDuration", 0); }
 234                         set { ViewState ["CacheDuration"] = value; }
 235                 }
 236
 237                 [DefaultValue (DataSourceCacheExpiry.Absolute)]
 238                 public virtual DataSourceCacheExpiry CacheExpirationPolicy {
 239                         get { return (DataSourceCacheExpiry) ViewState.GetInt ("CacheExpirationPolicy", (int)DataSourceCacheExpiry.Absolute); }
 240                         set { ViewState ["CacheExpirationPolicy"] = value; }
 241                 }
 242
 243                 [DefaultValue (false)]
 244                 public virtual bool EnableCaching {
 245                         get { return ViewState.GetBool ("EnableCaching", false); }
 246                         set { ViewState ["EnableCaching"] = value; }
 247                 }
 248 #endregion
 249
 250                 [DefaultValueAttribute ("")]
 251                 [TypeConverterAttribute ("System.Web.UI.Design.WebControls.DataProviderNameConverter, " + Consts.AssemblySystem_Design)]
 252                 public virtual string ProviderName {
 253                         get { return ViewState.GetString ("ProviderName", ""); }
 254                         set { ViewState ["ProviderName"] = value; }
 255                 }
 256
 257
 258                 [EditorAttribute ("System.Web.UI.Design.WebControls.SqlDataSourceConnectionStringEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 259                 [DefaultValueAttribute ("")]
 260                 public virtual string ConnectionString {
 261                         get { return ViewState.GetString ("ConnectionString", ""); }
 262                         set { ViewState ["ConnectionString"] = value; }
 263                 }
 264
 265                 [DefaultValueAttribute (SqlDataSourceMode.DataSet)]
 266                 public SqlDataSourceMode DataSourceMode {
 267                         get { return (SqlDataSourceMode) ViewState.GetInt ("DataSourceMode", (int)SqlDataSourceMode.DataSet); }
 268                         set { ViewState ["DataSourceMode"] = value; }
 269                 }
 270
 271                 [DefaultValueAttribute ("")]
 272                 public string DeleteCommand {
 273                         get { return View.DeleteCommand; }
 274                         set { View.DeleteCommand = value; }
 275                 }
 276
 277                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 278                 [MergablePropertyAttribute (false)]
 279                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 280                 [DefaultValueAttribute (null)]
 281                 public ParameterCollection DeleteParameters {
 282                         get { return View.DeleteParameters; }
 283                 }
 284
 285                 [DefaultValueAttribute (null)]
 286                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 287                 [MergablePropertyAttribute (false)]
 288                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 289                 public ParameterCollection FilterParameters {
 290                         get { return View.FilterParameters; }
 291                 }
 292
 293                 [DefaultValueAttribute ("")]
 294                 public string InsertCommand {
 295                         get { return View.InsertCommand; }
 296                         set { View.InsertCommand = value; }
 297                 }
 298
 299                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 300                 [DefaultValueAttribute (null)]
 301                 [MergablePropertyAttribute (false)]
 302                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 303                 public ParameterCollection InsertParameters {
 304                         get { return View.InsertParameters; }
 305                 }
 306
 307                 [DefaultValueAttribute ("")]
 308                 public string SelectCommand {
 309                         get { return View.SelectCommand; }
 310                         set { View.SelectCommand = value; }
 311                 }
 312
 313                 [DefaultValueAttribute (null)]
 314                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 315                 [MergablePropertyAttribute (false)]
 316                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 317                 public ParameterCollection SelectParameters {
 318                         get { return View.SelectParameters; }
 319                 }
 320
 321                 [DefaultValueAttribute ("")]
 322                 public string UpdateCommand {
 323                         get { return View.UpdateCommand; }
 324                         set { View.UpdateCommand = value; }
 325                 }
 326
 327                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 328                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 329                 [MergablePropertyAttribute (false)]
 330                 [DefaultValueAttribute (null)]
 331                 public ParameterCollection UpdateParameters {
 332                         get { return View.UpdateParameters; }
 333                 }
 334
 335                 [DefaultValueAttribute ("")]
 336                 public string FilterExpression {
 337                         get { return View.FilterExpression; }
 338                         set { View.FilterExpression = value; }
 339                 }
 340
 341                 public event SqlDataSourceStatusEventHandler Deleted {
 342                         add { View.Deleted += value; }
 343                         remove { View.Deleted -= value; }
 344                 }
 345
 346                 public event SqlDataSourceCommandEventHandler Deleting {
 347                         add { View.Deleting += value; }
 348                         remove { View.Deleting -= value; }
 349                 }
 350
 351                 public event SqlDataSourceStatusEventHandler Inserted {
 352                         add { View.Inserted += value; }
 353                         remove { View.Inserted -= value; }
 354                 }
 355
 356                 public event SqlDataSourceFilteringEventHandler Filtering {
 357                         add { View.Filtering += value; }
 358                         remove { View.Filtering -= value; }
 359                 }
 360
 361                 public event SqlDataSourceCommandEventHandler Inserting {
 362                         add { View.Inserting += value; }
 363                         remove { View.Inserting -= value; }
 364                 }
 365
 366                 public event SqlDataSourceStatusEventHandler Selected {
 367                         add { View.Selected += value; }
 368                         remove { View.Selected -= value; }
 369                 }
 370
 371                 public event SqlDataSourceSelectingEventHandler Selecting {
 372                         add { View.Selecting += value; }
 373                         remove { View.Selecting -= value; }
 374                 }
 375
 376                 public event SqlDataSourceStatusEventHandler Updated {
 377                         add { View.Updated += value; }
 378                         remove { View.Updated -= value; }
 379                 }
 380
 381                 public event SqlDataSourceCommandEventHandler Updating {
 382                         add { View.Updating += value; }
 383                         remove { View.Updating -= value; }
 384                 }
 385
 386                 SqlDataSourceView view;
 387                 SqlDataSourceView View {
 388                         get {
 389                                 if (view == null) {
 390                                         view = CreateDataSourceView ("DefaultView");
 391                                         view.DataSourceViewChanged += new EventHandler (ViewChanged);
 392                                         if (IsTrackingViewState)
 393                                                 ((IStateManager) view).TrackViewState ();
 394                                 }
 395                                 return view;
 396                         }
 397                 }
 398
 399                 void ViewChanged (object source, EventArgs e)
 400                 {
 401                         RaiseDataSourceChangedEvent (e);
 402                 }
 403         }
 404 }
 405 #endif
 406