Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / UI / WebControls / SqlDataSourceView.cs / 1305376 / SqlDataSourceView.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Web.UI.WebControls {
using System;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using System.Data.SqlClient;
using System.Drawing.Design;
using System.Globalization;
using System.IO;
using System.Text;
using System.Web;
using System.Web.Caching;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.Util;
using ConflictOptions = System.Web.UI.ConflictOptions;
///
/// Represents a single view of a SqlDataSource.
///
public class SqlDataSourceView : DataSourceView, IStateManager {
private const int MustDeclareVariableSqlExceptionNumber = 137;
private const int ProcedureExpectsParameterSqlExceptionNumber = 201;
private static readonly object EventDeleted = new object();
private static readonly object EventDeleting = new object();
private static readonly object EventFiltering = new object();
private static readonly object EventInserted = new object();
private static readonly object EventInserting = new object();
private static readonly object EventSelected = new object();
private static readonly object EventSelecting = new object();
private static readonly object EventUpdated = new object();
private static readonly object EventUpdating = new object();
private HttpContext _context;
private SqlDataSource _owner;
private bool _tracking;
private bool _cancelSelectOnNullParameter = true;
private ConflictOptions _conflictDetection = ConflictOptions.OverwriteChanges;
private string _deleteCommand;
private SqlDataSourceCommandType _deleteCommandType = SqlDataSourceCommandType.Text;
private ParameterCollection _deleteParameters;
private string _filterExpression;
private ParameterCollection _filterParameters;
private string _insertCommand;
private SqlDataSourceCommandType _insertCommandType = SqlDataSourceCommandType.Text;
private ParameterCollection _insertParameters;
private string _oldValuesParameterFormatString;
private string _selectCommand;
private SqlDataSourceCommandType _selectCommandType = SqlDataSourceCommandType.Text;
private ParameterCollection _selectParameters;
private string _sortParameterName;
private string _updateCommand;
private SqlDataSourceCommandType _updateCommandType = SqlDataSourceCommandType.Text;
private ParameterCollection _updateParameters;
///
/// Creates a new instance of SqlDataSourceView.
///
public SqlDataSourceView(SqlDataSource owner, string name, HttpContext context) : base(owner, name) {
_owner = owner;
_context = context;
}
public bool CancelSelectOnNullParameter {
get {
return _cancelSelectOnNullParameter;
}
set {
if (CancelSelectOnNullParameter != value) {
_cancelSelectOnNullParameter = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
///
/// Indicates that the view can delete rows.
///
public override bool CanDelete {
get {
return (DeleteCommand.Length != 0);
}
}
///
/// Indicates that the view can add new rows.
///
public override bool CanInsert {
get {
return (InsertCommand.Length != 0);
}
}
///
/// Indicates that the view can page the datasource on the server.
///
public override bool CanPage {
get {
return false;
}
}
///
/// Indicates that the view can return the total number of rows returned by the query.
///
public override bool CanRetrieveTotalRowCount {
get {
return false;
}
}
///
/// Indicates that the view can sort rows.
///
public override bool CanSort {
get {
return (_owner.DataSourceMode == SqlDataSourceMode.DataSet) || (SortParameterName.Length > 0);
}
}
///
/// Indicates that the view can update rows.
///
public override bool CanUpdate {
get {
return (UpdateCommand.Length != 0);
}
}
///
/// Whether commands pass old values in the parameter collection.
///
public ConflictOptions ConflictDetection {
get {
return _conflictDetection;
}
set {
if ((value < ConflictOptions.OverwriteChanges) || (value > ConflictOptions.CompareAllValues)) {
throw new ArgumentOutOfRangeException("value");
}
_conflictDetection = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
///
/// The command to execute when Delete() is called on the SqlDataSourceView.
///
public string DeleteCommand {
get {
if (_deleteCommand == null) {
return String.Empty;
}
return _deleteCommand;
}
set {
_deleteCommand = value;
}
}
public SqlDataSourceCommandType DeleteCommandType {
get {
return _deleteCommandType;
}
set {
if ((value < SqlDataSourceCommandType.Text) || (value > SqlDataSourceCommandType.StoredProcedure)) {
throw new ArgumentOutOfRangeException("value");
}
_deleteCommandType = value;
}
}
///
/// Collection of parameters used in Delete().
///
[
DefaultValue(null),
Editor("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
PersistenceMode(PersistenceMode.InnerProperty),
WebSysDescription(SR.SqlDataSource_DeleteParameters),
]
public ParameterCollection DeleteParameters {
get {
if (_deleteParameters == null) {
_deleteParameters = new ParameterCollection();
}
return _deleteParameters;
}
}
///
/// The filter to apply when Select() is called on the SqlDataSourceView.
///
public string FilterExpression {
get {
if (_filterExpression == null) {
return String.Empty;
}
return _filterExpression;
}
set {
if (FilterExpression != value) {
_filterExpression = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
///
/// Collection of parameters used in the FilterExpression property.
///
[
DefaultValue(null),
Editor("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
PersistenceMode(PersistenceMode.InnerProperty),
WebSysDescription(SR.SqlDataSource_FilterParameters),
]
public ParameterCollection FilterParameters {
get {
if (_filterParameters == null) {
_filterParameters = new ParameterCollection();
_filterParameters.ParametersChanged += new EventHandler(SelectParametersChangedEventHandler);
if (_tracking) {
((IStateManager)_filterParameters).TrackViewState();
}
}
return _filterParameters;
}
}
///
/// The command to execute when Insert() is called on the SqlDataSourceView.
///
public string InsertCommand {
get {
if (_insertCommand == null) {
return String.Empty;
}
return _insertCommand;
}
set {
_insertCommand = value;
}
}
public SqlDataSourceCommandType InsertCommandType {
get {
return _insertCommandType;
}
set {
if ((value < SqlDataSourceCommandType.Text) || (value > SqlDataSourceCommandType.StoredProcedure)) {
throw new ArgumentOutOfRangeException("value");
}
_insertCommandType = value;
}
}
///
/// Collection of values used in Insert().
///
[
DefaultValue(null),
Editor("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
PersistenceMode(PersistenceMode.InnerProperty),
WebSysDescription(SR.SqlDataSource_InsertParameters),
]
public ParameterCollection InsertParameters {
get {
if (_insertParameters == null) {
_insertParameters = new ParameterCollection();
}
return _insertParameters;
}
}
///
/// Returns whether this object is tracking view state.
///
protected bool IsTrackingViewState {
get {
return _tracking;
}
}
///
/// The format string applied to the names of the old values parameters
///
[
DefaultValue("{0}"),
WebCategory("Data"),
WebSysDescription(SR.DataSource_OldValuesParameterFormatString),
]
public string OldValuesParameterFormatString {
get {
if (_oldValuesParameterFormatString == null) {
return "{0}";
}
return _oldValuesParameterFormatString;
}
set {
_oldValuesParameterFormatString = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
///
/// Indicates the prefix for parameters.
///
protected virtual string ParameterPrefix {
get {
if (String.IsNullOrEmpty(_owner.ProviderName) ||
String.Equals(_owner.ProviderName, "System.Data.SqlClient", StringComparison.OrdinalIgnoreCase)) {
return "@";
}
else {
return String.Empty;
}
}
}
///
/// The command to execute when Select() is called on the SqlDataSourceView.
///
public string SelectCommand {
get {
if (_selectCommand == null) {
return String.Empty;
}
return _selectCommand;
}
set {
if (SelectCommand != value) {
_selectCommand = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public SqlDataSourceCommandType SelectCommandType {
get {
return _selectCommandType;
}
set {
if ((value < SqlDataSourceCommandType.Text) || (value > SqlDataSourceCommandType.StoredProcedure)) {
throw new ArgumentOutOfRangeException("value");
}
_selectCommandType = value;
}
}
///
/// The command to execute when Select is called on the SqlDataSourceView and the total rows is requested.
///
/*public string SelectCountCommand {
get {
if (_selectCountCommand == null) {
return String.Empty;
}
return _selectCountCommand;
}
set {
if (SelectCountCommand != value) {
_selectCountCommand = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}*/
///
/// Collection of parameters used in Select().
///
public ParameterCollection SelectParameters {
get {
if (_selectParameters == null) {
_selectParameters = new ParameterCollection();
_selectParameters.ParametersChanged += new EventHandler(SelectParametersChangedEventHandler);
if (_tracking) {
((IStateManager)_selectParameters).TrackViewState();
}
}
return _selectParameters;
}
}
///
/// The name of the parameter in the SelectCommand that specifies the
/// sort expression. This parameter's value will be automatically set
/// at runtime with the appropriate sort expression. This is only
/// supported for stored procedure commands.
///
public string SortParameterName {
get {
if (_sortParameterName == null) {
return String.Empty;
}
return _sortParameterName;
}
set {
if (SortParameterName != value) {
_sortParameterName = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
///
/// The command to execute when Update() is called on the SqlDataSourceView.
///
public string UpdateCommand {
get {
if (_updateCommand == null) {
return String.Empty;
}
return _updateCommand;
}
set {
_updateCommand = value;
}
}
public SqlDataSourceCommandType UpdateCommandType {
get {
return _updateCommandType;
}
set {
if ((value < SqlDataSourceCommandType.Text) || (value > SqlDataSourceCommandType.StoredProcedure)) {
throw new ArgumentOutOfRangeException("value");
}
_updateCommandType = value;
}
}
///
/// Collection of parameters used in Update().
///
[
DefaultValue(null),
Editor("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
PersistenceMode(PersistenceMode.InnerProperty),
WebSysDescription(SR.SqlDataSource_UpdateParameters),
]
public ParameterCollection UpdateParameters {
get {
if (_updateParameters == null) {
_updateParameters = new ParameterCollection();
}
return _updateParameters;
}
}
///
/// This event is raised after the Delete operation has completed.
/// Handle this event if you need to examine the values of output parameters.
///
public event SqlDataSourceStatusEventHandler Deleted {
add {
Events.AddHandler(EventDeleted, value);
}
remove {
Events.RemoveHandler(EventDeleted, value);
}
}
///
/// This event is raised before the Delete operation has been executed.
/// Handle this event if you want to perform additional initialization operations
/// that are specific to your application. You can also handle this event if you
/// need to validate the values of parameters or change their values.
/// When this event is raised, the database connection is not open yet, and you
/// can cancel the event by setting the Cancel property of the DataCommandEventArgs
/// to true.
///
public event SqlDataSourceCommandEventHandler Deleting {
add {
Events.AddHandler(EventDeleting, value);
}
remove {
Events.RemoveHandler(EventDeleting, value);
}
}
public event SqlDataSourceFilteringEventHandler Filtering {
add {
Events.AddHandler(EventFiltering, value);
}
remove {
Events.RemoveHandler(EventFiltering, value);
}
}
///
/// This event is raised after the Insert operation has completed.
/// Handle this event if you need to examine the values of output parameters.
///
public event SqlDataSourceStatusEventHandler Inserted {
add {
Events.AddHandler(EventInserted, value);
}
remove {
Events.RemoveHandler(EventInserted, value);
}
}
///
/// This event is raised before the Insert operation has been executed.
/// Handle this event if you want to perform additional initialization operations
/// that are specific to your application. You can also handle this event if you
/// need to validate the values of parameters or change their values.
/// When this event is raised, the database connection is not open yet, and you
/// can cancel the event by setting the Cancel property of the DataCommandEventArgs
/// to true.
///
public event SqlDataSourceCommandEventHandler Inserting {
add {
Events.AddHandler(EventInserting, value);
}
remove {
Events.RemoveHandler(EventInserting, value);
}
}
///
/// This event is raised after the Select operation has completed.
/// Handle this event if you need to examine the values of output parameters.
///
public event SqlDataSourceStatusEventHandler Selected {
add {
Events.AddHandler(EventSelected, value);
}
remove {
Events.RemoveHandler(EventSelected, value);
}
}
///
/// This event is raised before the Select operation has been executed.
/// Handle this event if you want to perform additional initialization operations
/// that are specific to your application. You can also handle this event if you
/// need to validate the values of parameters or change their values.
/// When this event is raised, the database connection is not open yet, and you
/// can cancel the event by setting the Cancel property of the DataCommandEventArgs
/// to true.
///
public event SqlDataSourceSelectingEventHandler Selecting {
add {
Events.AddHandler(EventSelecting, value);
}
remove {
Events.RemoveHandler(EventSelecting, value);
}
}
///
/// This event is raised after the Update operation has completed.
/// Handle this event if you need to examine the values of output parameters.
///
public event SqlDataSourceStatusEventHandler Updated {
add {
Events.AddHandler(EventUpdated, value);
}
remove {
Events.RemoveHandler(EventUpdated, value);
}
}
///
/// This event is raised before the Update operation has been executed.
/// Handle this event if you want to perform additional initialization operations
/// that are specific to your application. You can also handle this event if you
/// need to validate the values of parameters or change their values.
/// When this event is raised, the database connection is not open yet, and you
/// can cancel the event by setting the Cancel property of the DataCommandEventArgs
/// to true.
///
public event SqlDataSourceCommandEventHandler Updating {
add {
Events.AddHandler(EventUpdating, value);
}
remove {
Events.RemoveHandler(EventUpdating, value);
}
}
///
/// Adds parameters to an DbCommand from an IOrderedDictionary.
/// The exclusion list contains parameter names that should not be added
/// to the command's parameter collection.
///
private void AddParameters(DbCommand command, ParameterCollection reference, IDictionary parameters, IDictionary exclusionList, string oldValuesParameterFormatString) {
Debug.Assert(command != null);
IDictionary caseInsensitiveExclusionList = null;
if (exclusionList != null) {
caseInsensitiveExclusionList = new ListDictionary(StringComparer.OrdinalIgnoreCase);
foreach (DictionaryEntry de in exclusionList) {
caseInsensitiveExclusionList.Add(de.Key, de.Value);
}
}
if (parameters != null) {
string parameterPrefix = ParameterPrefix;
foreach (DictionaryEntry de in parameters) {
string rawParamName = (string)de.Key;
if ((caseInsensitiveExclusionList != null) && (caseInsensitiveExclusionList.Contains(rawParamName))) {
// If we have an exclusion list and it contains this parameter, skip it
continue;
}
string formattedParamName;
if (oldValuesParameterFormatString == null) {
formattedParamName = rawParamName;
}
else {
formattedParamName = String.Format(CultureInfo.InvariantCulture, oldValuesParameterFormatString, rawParamName);
}
object value = de.Value;
// If the reference collection contains this parameter, we will use
// the Parameter's settings to format the value
Parameter parameter = reference[formattedParamName];
if (parameter != null) {
value = parameter.GetValue(de.Value, false);
}
formattedParamName = parameterPrefix + formattedParamName;
if (command.Parameters.Contains(formattedParamName)) {
// We never overwrite an existing value with a null value
if (value != null) {
command.Parameters[formattedParamName].Value = value;
}
}
else {
// Parameter does not exist, add a new one
DbParameter dbParameter = _owner.CreateParameter(formattedParamName, value);
command.Parameters.Add(dbParameter);
}
}
}
}
///
/// Builds a custom exception for specific database errors.
/// Currently the only custom exception text supported is for SQL Server
/// when a parameter is present in the command but not in the parameters
/// collection.
/// The isCustomException parameter indicates whether a custom exception
/// was created or not. This way the caller can determine whether it wants
/// to rethrow the original exception or throw the new custom exception.
///
private Exception BuildCustomException(Exception ex, DataSourceOperation operation, DbCommand command, out bool isCustomException) {
System.Data.SqlClient.SqlException sqlException = ex as System.Data.SqlClient.SqlException;
if (sqlException != null) {
if ((sqlException.Number == MustDeclareVariableSqlExceptionNumber) ||
(sqlException.Number == ProcedureExpectsParameterSqlExceptionNumber)) {
string parameterNames;
if (command.Parameters.Count > 0) {
StringBuilder sb = new StringBuilder();
bool firstParameter = true;
foreach (DbParameter p in command.Parameters) {
if (!firstParameter) {
sb.Append(", ");
}
sb.Append(p.ParameterName);
firstParameter = false;
}
parameterNames = sb.ToString();
}
else {
parameterNames = SR.GetString(SR.SqlDataSourceView_NoParameters);
}
isCustomException = true;
return new InvalidOperationException(SR.GetString(SR.SqlDataSourceView_MissingParameters, operation, _owner.ID, parameterNames));
}
}
isCustomException = false;
return ex;
}
public int Delete(IDictionary keys, IDictionary oldValues) {
return ExecuteDelete(keys, oldValues);
}
///
/// Executes a DbCommand and returns the number of rows affected.
///
private int ExecuteDbCommand(DbCommand command, DataSourceOperation operation) {
int rowsAffected = 0;
bool eventRaised = false;
try {
if (command.Connection.State != ConnectionState.Open) {
command.Connection.Open();
}
rowsAffected = command.ExecuteNonQuery();
if (rowsAffected > 0) {
OnDataSourceViewChanged(EventArgs.Empty);
DataSourceCache cache = _owner.Cache;
if ((cache != null) && (cache.Enabled)) {
_owner.InvalidateCacheEntry();
}
}
// Raise appropriate event
eventRaised = true;
SqlDataSourceStatusEventArgs eventArgs = new SqlDataSourceStatusEventArgs(command, rowsAffected, null);
switch (operation) {
case DataSourceOperation.Delete:
OnDeleted(eventArgs);
break;
case DataSourceOperation.Insert:
OnInserted(eventArgs);
break;
case DataSourceOperation.Update:
OnUpdated(eventArgs);
break;
}
}
catch (Exception ex) {
if (!eventRaised) {
// Raise appropriate event
SqlDataSourceStatusEventArgs eventArgs = new SqlDataSourceStatusEventArgs(command, rowsAffected, ex);
switch (operation) {
case DataSourceOperation.Delete:
OnDeleted(eventArgs);
break;
case DataSourceOperation.Insert:
OnInserted(eventArgs);
break;
case DataSourceOperation.Update:
OnUpdated(eventArgs);
break;
}
if (!eventArgs.ExceptionHandled) {
throw;
}
}
else {
bool isCustomException;
ex = BuildCustomException(ex, operation, command, out isCustomException);
if (isCustomException) {
throw ex;
}
else {
throw;
}
}
}
finally {
if (command.Connection.State == ConnectionState.Open) {
command.Connection.Close();
}
}
return rowsAffected;
}
///
/// Deletes rows from the data source with given parameters.
///
protected override int ExecuteDelete(IDictionary keys, IDictionary oldValues) {
if (!CanDelete) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_DeleteNotSupported, _owner.ID));
}
DbConnection connection = _owner.CreateConnection(_owner.ConnectionString);
if (connection == null) {
throw new InvalidOperationException(SR.GetString(SR.SqlDataSourceView_CouldNotCreateConnection, _owner.ID));
}
// Create command and add parameters
string oldValuesParameterFormatString = OldValuesParameterFormatString;
DbCommand command = _owner.CreateCommand(DeleteCommand, connection);
InitializeParameters(command, DeleteParameters, oldValues);
AddParameters(command, DeleteParameters, keys, null, oldValuesParameterFormatString);
if (ConflictDetection == ConflictOptions.CompareAllValues) {
if (oldValues == null || oldValues.Count == 0) {
throw new InvalidOperationException(SR.GetString(SR.SqlDataSourceView_Pessimistic, SR.GetString(SR.DataSourceView_delete), _owner.ID, "values"));
}
AddParameters(command, DeleteParameters, oldValues, null, oldValuesParameterFormatString);
}
command.CommandType = GetCommandType(DeleteCommandType);
// Raise event to allow customization and cancellation
SqlDataSourceCommandEventArgs eventArgs = new SqlDataSourceCommandEventArgs(command);
OnDeleting(eventArgs);
// If the operation was cancelled, exit immediately
if (eventArgs.Cancel) {
return 0;
}
// Replace null values in parameters with DBNull.Value
ReplaceNullValues(command);
return ExecuteDbCommand(command, DataSourceOperation.Delete);
}
///
/// Inserts a new row with data from a name/value collection.
///
protected override int ExecuteInsert(IDictionary values) {
if (!CanInsert) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_InsertNotSupported, _owner.ID));
}
DbConnection connection = _owner.CreateConnection(_owner.ConnectionString);
if (connection == null) {
throw new InvalidOperationException(SR.GetString(SR.SqlDataSourceView_CouldNotCreateConnection, _owner.ID));
}
// Create command and add parameters
DbCommand command = _owner.CreateCommand(InsertCommand, connection);
InitializeParameters(command, InsertParameters, null);
AddParameters(command, InsertParameters, values, null, null);
command.CommandType = GetCommandType(InsertCommandType);
// Raise event to allow customization and cancellation
SqlDataSourceCommandEventArgs eventArgs = new SqlDataSourceCommandEventArgs(command);
OnInserting(eventArgs);
// If the operation was cancelled, exit immediately
if (eventArgs.Cancel) {
return 0;
}
// Replace null values in parameters with DBNull.Value
ReplaceNullValues(command);
return ExecuteDbCommand(command, DataSourceOperation.Insert);
}
///
/// Returns all the rows of the datasource.
/// Parameters are taken from the SqlDataSource.Parameters property collection.
/// If DataSourceMode is set to DataSet then a DataView is returned.
/// If DataSourceMode is set to DataReader then a DataReader is returned, and it must be closed when done.
///
protected internal override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments) {
if (SelectCommand.Length == 0) {
return null;
}
DbConnection connection = _owner.CreateConnection(_owner.ConnectionString);
if (connection == null) {
throw new InvalidOperationException(SR.GetString(SR.SqlDataSourceView_CouldNotCreateConnection, _owner.ID));
}
DataSourceCache cache = _owner.Cache;
bool cacheEnabled = (cache != null) && (cache.Enabled);
//int startRowIndex = arguments.StartRowIndex;
//int maximumRows = arguments.MaximumRows;
string sortExpression = arguments.SortExpression;
if (CanPage) {
arguments.AddSupportedCapabilities(DataSourceCapabilities.Page);
}
if (CanSort) {
arguments.AddSupportedCapabilities(DataSourceCapabilities.Sort);
}
if (CanRetrieveTotalRowCount) {
arguments.AddSupportedCapabilities(DataSourceCapabilities.RetrieveTotalRowCount);
}
// If caching is enabled, load DataSet from cache
if (cacheEnabled) {
if (_owner.DataSourceMode != SqlDataSourceMode.DataSet) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_CacheNotSupported, _owner.ID));
}
arguments.RaiseUnsupportedCapabilitiesError(this);
DataSet dataSet = _owner.LoadDataFromCache(0, -1) as DataSet;
if (dataSet != null) {
/*if (arguments.RetrieveTotalRowCount) {
int cachedTotalRowCount = _owner.LoadTotalRowCountFromCache();
if (cachedTotalRowCount >= 0) {
arguments.TotalRowCount = cachedTotalRowCount;
}
else {
// query for row count and then save it in cache
cachedTotalRowCount = QueryTotalRowCount(connection, arguments);
arguments.TotalRowCount = cachedTotalRowCount;
_owner.SaveTotalRowCountToCache(cachedTotalRowCount);
}
}*/
IOrderedDictionary parameterValues = FilterParameters.GetValues(_context, _owner);
if (FilterExpression.Length > 0) {
SqlDataSourceFilteringEventArgs filterArgs = new SqlDataSourceFilteringEventArgs(parameterValues);
OnFiltering(filterArgs);
if (filterArgs.Cancel) {
return null;
}
}
return FilteredDataSetHelper.CreateFilteredDataView(dataSet.Tables[0], sortExpression, FilterExpression, parameterValues);
}
}
// Create command and add parameters
DbCommand command = _owner.CreateCommand(SelectCommand, connection);
InitializeParameters(command, SelectParameters, null);
command.CommandType = GetCommandType(SelectCommandType);
// Raise event to allow customization and cancellation
SqlDataSourceSelectingEventArgs selectingEventArgs = new SqlDataSourceSelectingEventArgs(command, arguments);
OnSelecting(selectingEventArgs);
// If the operation was cancelled, exit immediately
if (selectingEventArgs.Cancel) {
return null;
}
// Add the sort parameter to allow for custom stored procedure sorting, if necessary
string sortParameterName = SortParameterName;
if (sortParameterName.Length > 0) {
if (command.CommandType != CommandType.StoredProcedure) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_SortParameterRequiresStoredProcedure, _owner.ID));
}
command.Parameters.Add(_owner.CreateParameter(ParameterPrefix + sortParameterName, sortExpression));
// We reset the sort expression here so that we pretend as
// though we're not really sorting (since the developer is
// worrying about it instead of us).
arguments.SortExpression = String.Empty;
}
arguments.RaiseUnsupportedCapabilitiesError(this);
// reset these values, since they might have changed in the OnSelecting event
sortExpression = arguments.SortExpression;
//startRowIndex = arguments.StartRowIndex;
//maximumRows = arguments.MaximumRows;
// Perform null check if user wants to cancel on any null parameter value
if (CancelSelectOnNullParameter) {
int paramCount = command.Parameters.Count;
for (int i = 0; i < paramCount; i++) {
DbParameter parameter = command.Parameters[i];
if ((parameter != null) &&
(parameter.Value == null) &&
((parameter.Direction == ParameterDirection.Input) || (parameter.Direction == ParameterDirection.InputOutput))) {
return null;
}
}
}
// Replace null values in parameters with DBNull.Value
ReplaceNullValues(command);
/*if (arguments.RetrieveTotalRowCount && SelectCountCommand.Length > 0) {
int cachedTotalRowCount = -1;
if (cacheEnabled) {
cachedTotalRowCount = _owner.LoadTotalRowCountFromCache();
if (cachedTotalRowCount >= 0) {
arguments.TotalRowCount = cachedTotalRowCount;
}
}
if (cachedTotalRowCount < 0) {
cachedTotalRowCount = QueryTotalRowCount(connection, arguments);
arguments.TotalRowCount = cachedTotalRowCount;
if (cacheEnabled) {
_owner.SaveTotalRowCountToCache(cachedTotalRowCount);
}
}
}*/
IEnumerable selectResult = null;
switch (_owner.DataSourceMode) {
case SqlDataSourceMode.DataSet:
{
SqlCacheDependency cacheDependency = null;
if (cacheEnabled && cache is SqlDataSourceCache) {
SqlDataSourceCache sqlCache = (SqlDataSourceCache)cache;
if (String.Equals(sqlCache.SqlCacheDependency, SqlDataSourceCache.Sql9CacheDependencyDirective, StringComparison.OrdinalIgnoreCase)) {
if (!(command is System.Data.SqlClient.SqlCommand)) {
throw new InvalidOperationException(SR.GetString(SR.SqlDataSourceView_CommandNotificationNotSupported, _owner.ID));
}
cacheDependency = new SqlCacheDependency((System.Data.SqlClient.SqlCommand)command);
}
}
DbDataAdapter adapter = _owner.CreateDataAdapter(command);
DataSet dataSet = new DataSet();
int rowsAffected = 0;
bool eventRaised = false;
try {
rowsAffected = adapter.Fill(dataSet, Name);
// Raise the Selected event
eventRaised = true;
SqlDataSourceStatusEventArgs selectedEventArgs = new SqlDataSourceStatusEventArgs(command, rowsAffected, null);
OnSelected(selectedEventArgs);
}
catch (Exception ex) {
if (!eventRaised) {
// Raise the Selected event
SqlDataSourceStatusEventArgs selectedEventArgs = new SqlDataSourceStatusEventArgs(command, rowsAffected, ex);
OnSelected(selectedEventArgs);
if (!selectedEventArgs.ExceptionHandled) {
throw;
}
}
else {
bool isCustomException;
ex = BuildCustomException(ex, DataSourceOperation.Select, command, out isCustomException);
if (isCustomException) {
throw ex;
}
else {
throw;
}
}
}
finally {
if (connection.State == ConnectionState.Open) {
connection.Close();
}
}
// If caching is enabled, save DataSet to cache
DataTable dataTable = (dataSet.Tables.Count > 0 ? dataSet.Tables[0] : null);
if (cacheEnabled && dataTable != null) {
_owner.SaveDataToCache(0, -1, dataSet, cacheDependency);
}
if (dataTable != null) {
IOrderedDictionary parameterValues = FilterParameters.GetValues(_context, _owner);
if (FilterExpression.Length > 0) {
SqlDataSourceFilteringEventArgs filterArgs = new SqlDataSourceFilteringEventArgs(parameterValues);
OnFiltering(filterArgs);
if (filterArgs.Cancel) {
return null;
}
}
selectResult = FilteredDataSetHelper.CreateFilteredDataView(dataTable, sortExpression, FilterExpression, parameterValues);
}
break;
}
case SqlDataSourceMode.DataReader:
{
if (FilterExpression.Length > 0) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_FilterNotSupported, _owner.ID));
}
if (sortExpression.Length > 0) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_SortNotSupported, _owner.ID));
}
bool eventRaised = false;
try {
if (connection.State != ConnectionState.Open) {
connection.Open();
}
selectResult = command.ExecuteReader(CommandBehavior.CloseConnection);
// Raise the Selected event
eventRaised = true;
SqlDataSourceStatusEventArgs selectedEventArgs = new SqlDataSourceStatusEventArgs(command, 0, null);
OnSelected(selectedEventArgs);
}
catch (Exception ex) {
if (!eventRaised) {
// Raise the Selected event
SqlDataSourceStatusEventArgs selectedEventArgs = new SqlDataSourceStatusEventArgs(command, 0, ex);
OnSelected(selectedEventArgs);
if (!selectedEventArgs.ExceptionHandled) {
throw;
}
}
else {
bool isCustomException;
ex = BuildCustomException(ex, DataSourceOperation.Select, command, out isCustomException);
if (isCustomException) {
throw ex;
}
else {
throw;
}
}
}
break;
}
}
return selectResult;
}
///
/// Updates rows matching the parameter collection and setting new values from the name/value values collection.
///
protected override int ExecuteUpdate(IDictionary keys, IDictionary values, IDictionary oldValues) {
if (!CanUpdate) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_UpdateNotSupported, _owner.ID));
}
DbConnection connection = _owner.CreateConnection(_owner.ConnectionString);
if (connection == null) {
throw new InvalidOperationException(SR.GetString(SR.SqlDataSourceView_CouldNotCreateConnection, _owner.ID));
}
// Create command and add parameters
string oldValuesParameterFormatString = OldValuesParameterFormatString;
DbCommand command = _owner.CreateCommand(UpdateCommand, connection);
InitializeParameters(command, UpdateParameters, keys);
AddParameters(command, UpdateParameters, values, null, null);
AddParameters(command, UpdateParameters, keys, null, oldValuesParameterFormatString);
if (ConflictDetection == ConflictOptions.CompareAllValues) {
if (oldValues == null || oldValues.Count == 0) {
throw new InvalidOperationException(SR.GetString(SR.SqlDataSourceView_Pessimistic, SR.GetString(SR.DataSourceView_update), _owner.ID, "oldValues"));
}
AddParameters(command, UpdateParameters, oldValues, null, oldValuesParameterFormatString);
}
command.CommandType = GetCommandType(UpdateCommandType);
// Raise event to allow customization and cancellation
SqlDataSourceCommandEventArgs eventArgs = new SqlDataSourceCommandEventArgs(command);
OnUpdating(eventArgs);
// If the operation was cancelled, exit immediately
if (eventArgs.Cancel) {
return 0;
}
// Replace null values in parameters with DBNull.Value
ReplaceNullValues(command);
return ExecuteDbCommand(command, DataSourceOperation.Update);
}
///
/// Converts a SqlDataSourceCommandType to a System.Data.CommandType.
///
private static CommandType GetCommandType(SqlDataSourceCommandType commandType) {
if (commandType == SqlDataSourceCommandType.Text) {
return CommandType.Text;
}
return CommandType.StoredProcedure;
}
///
/// Initializes a DbCommand with parameters from a ParameterCollection.
/// The exclusion list contains parameter names that should not be added
/// to the command's parameter collection.
///
private void InitializeParameters(DbCommand command, ParameterCollection parameters, IDictionary exclusionList) {
Debug.Assert(command != null);
Debug.Assert(parameters != null);
string parameterPrefix = ParameterPrefix;
IDictionary caseInsensitiveExclusionList = null;
if (exclusionList != null) {
caseInsensitiveExclusionList = new ListDictionary(StringComparer.OrdinalIgnoreCase);
foreach (DictionaryEntry de in exclusionList) {
caseInsensitiveExclusionList.Add(de.Key, de.Value);
}
}
IOrderedDictionary values = parameters.GetValues(_context, _owner);
for (int i = 0; i < parameters.Count; i++) {
Parameter parameter = parameters[i];
if ((caseInsensitiveExclusionList == null) || (!caseInsensitiveExclusionList.Contains(parameter.Name))) {
DbParameter dbParameter = _owner.CreateParameter(parameterPrefix + parameter.Name, values[i]);
dbParameter.Direction = parameter.Direction;
dbParameter.Size = parameter.Size;
if (parameter.DbType != DbType.Object || (parameter.Type != TypeCode.Empty && parameter.Type != TypeCode.DBNull)) {
SqlParameter sqlParameter = dbParameter as SqlParameter;
if (sqlParameter == null) {
dbParameter.DbType = parameter.GetDatabaseType();
}
else {
// In Whidbey, the DbType Date and Time members mapped to SqlDbType.DateTime since there
// were no SqlDbType equivalents. SqlDbType has since been modified to include the new
// Katmai types, including Date and Time. For backwards compatability SqlParameter's DbType
// setter doesn't support Date and Time, so the SqlDbType property should be used instead.
// Other new SqlServer 2008 types (DateTime2, DateTimeOffset) can be set using DbType.
DbType dbType = parameter.GetDatabaseType();
switch (dbType) {
case DbType.Time:
sqlParameter.SqlDbType = SqlDbType.Time;
break;
case DbType.Date:
sqlParameter.SqlDbType = SqlDbType.Date;
break;
default:
dbParameter.DbType = parameter.GetDatabaseType();
break;
}
}
}
command.Parameters.Add(dbParameter);
}
}
}
public int Insert(IDictionary values) {
return ExecuteInsert(values);
}
///
/// Loads view state.
///
protected virtual void LoadViewState(object savedState) {
if (savedState == null)
return;
Pair myState = (Pair)savedState;
if (myState.First != null)
((IStateManager)SelectParameters).LoadViewState(myState.First);
if (myState.Second != null)
((IStateManager)FilterParameters).LoadViewState(myState.Second);
}
///
/// Raises the Deleted event.
///
protected virtual void OnDeleted(SqlDataSourceStatusEventArgs e) {
SqlDataSourceStatusEventHandler handler = Events[EventDeleted] as SqlDataSourceStatusEventHandler;
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the Deleting event.
///
protected virtual void OnDeleting(SqlDataSourceCommandEventArgs e) {
SqlDataSourceCommandEventHandler handler = Events[EventDeleting] as SqlDataSourceCommandEventHandler;
if (handler != null) {
handler(this, e);
}
}
protected virtual void OnFiltering(SqlDataSourceFilteringEventArgs e) {
SqlDataSourceFilteringEventHandler handler = Events[EventFiltering] as SqlDataSourceFilteringEventHandler;
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the Inserted event.
///
protected virtual void OnInserted(SqlDataSourceStatusEventArgs e) {
SqlDataSourceStatusEventHandler handler = Events[EventInserted] as SqlDataSourceStatusEventHandler;
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the Inserting event.
///
protected virtual void OnInserting(SqlDataSourceCommandEventArgs e) {
SqlDataSourceCommandEventHandler handler = Events[EventInserting] as SqlDataSourceCommandEventHandler;
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the Selected event.
///
protected virtual void OnSelected(SqlDataSourceStatusEventArgs e) {
SqlDataSourceStatusEventHandler handler = Events[EventSelected] as SqlDataSourceStatusEventHandler;
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the Selecting event.
///
protected virtual void OnSelecting(SqlDataSourceSelectingEventArgs e) {
SqlDataSourceSelectingEventHandler handler = Events[EventSelecting] as SqlDataSourceSelectingEventHandler;
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the Updated event.
///
protected virtual void OnUpdated(SqlDataSourceStatusEventArgs e) {
SqlDataSourceStatusEventHandler handler = Events[EventUpdated] as SqlDataSourceStatusEventHandler;
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the Updating event.
///
protected virtual void OnUpdating(SqlDataSourceCommandEventArgs e) {
SqlDataSourceCommandEventHandler handler = Events[EventUpdating] as SqlDataSourceCommandEventHandler;
if (handler != null) {
handler(this, e);
}
}
///
/// Executes the SelectCountCommand to retrieve the total row count.
///
/*protected virtual int QueryTotalRowCount(DbConnection connection, DataSourceSelectArguments arguments) {
int totalRowCount = 0;
bool eventRaised = false;
if (SelectCountCommand.Length > 0) {
// Create command and add parameters
DbCommand command = _owner.CreateCommand(SelectCountCommand, connection);
InitializeParameters(command, SelectParameters);
command.CommandType = GetCommandType(SelectCountCommand, SelectCompareString);
// Raise event to allow customization and cancellation
SqlDataSourceSelectingEventArgs selectCountingEventArgs = new SqlDataSourceSelectingEventArgs(command, arguments, true);
OnSelecting(selectCountingEventArgs);
// If the operation was cancelled, exit immediately
if (selectCountingEventArgs.Cancel) {
return totalRowCount;
}
// the arguments may have been changed
arguments.RaiseUnsupportedCapabilitiesError(this);
//
*/
protected internal override void RaiseUnsupportedCapabilityError(DataSourceCapabilities capability) {
if (!CanPage && ((capability & DataSourceCapabilities.Page) != 0)) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_NoPaging, _owner.ID));
}
if (!CanSort && ((capability & DataSourceCapabilities.Sort) != 0)) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_NoSorting, _owner.ID));
}
if (!CanRetrieveTotalRowCount && ((capability & DataSourceCapabilities.RetrieveTotalRowCount) != 0)) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_NoRowCount, _owner.ID));
}
base.RaiseUnsupportedCapabilityError(capability);
}
///
/// Replace null values in parameters with DBNull.Value.
///
private void ReplaceNullValues(DbCommand command) {
int paramCount = command.Parameters.Count;
foreach (DbParameter parameter in command.Parameters) {
if (parameter.Value == null) {
parameter.Value = DBNull.Value;
}
}
}
///
/// Saves view state.
///
protected virtual object SaveViewState() {
Pair myState = new Pair();
myState.First = (_selectParameters != null) ? ((IStateManager)_selectParameters).SaveViewState() : null;
myState.Second = (_filterParameters != null) ? ((IStateManager)_filterParameters).SaveViewState() : null;
if ((myState.First == null) &&
(myState.Second == null)) {
return null;
}
return myState;
}
public IEnumerable Select(DataSourceSelectArguments arguments) {
return ExecuteSelect(arguments);
}
///
/// Event handler for SelectParametersChanged event.
///
private void SelectParametersChangedEventHandler(object o, EventArgs e) {
OnDataSourceViewChanged(EventArgs.Empty);
}
///
/// Starts tracking view state.
///
protected virtual void TrackViewState() {
_tracking = true;
if (_selectParameters != null) {
((IStateManager)_selectParameters).TrackViewState();
}
if (_filterParameters != null) {
((IStateManager)_filterParameters).TrackViewState();
}
}
public int Update(IDictionary keys, IDictionary values, IDictionary oldValues) {
return ExecuteUpdate(keys, values, oldValues);
}
#region IStateManager implementation
bool IStateManager.IsTrackingViewState {
get {
return IsTrackingViewState;
}
}
void IStateManager.LoadViewState(object savedState) {
LoadViewState(savedState);
}
object IStateManager.SaveViewState() {
return SaveViewState();
}
void IStateManager.TrackViewState() {
TrackViewState();
}
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Web.UI.WebControls {
using System;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using System.Data.SqlClient;
using System.Drawing.Design;
using System.Globalization;
using System.IO;
using System.Text;
using System.Web;
using System.Web.Caching;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.Util;
using ConflictOptions = System.Web.UI.ConflictOptions;
///
/// Represents a single view of a SqlDataSource.
///
public class SqlDataSourceView : DataSourceView, IStateManager {
private const int MustDeclareVariableSqlExceptionNumber = 137;
private const int ProcedureExpectsParameterSqlExceptionNumber = 201;
private static readonly object EventDeleted = new object();
private static readonly object EventDeleting = new object();
private static readonly object EventFiltering = new object();
private static readonly object EventInserted = new object();
private static readonly object EventInserting = new object();
private static readonly object EventSelected = new object();
private static readonly object EventSelecting = new object();
private static readonly object EventUpdated = new object();
private static readonly object EventUpdating = new object();
private HttpContext _context;
private SqlDataSource _owner;
private bool _tracking;
private bool _cancelSelectOnNullParameter = true;
private ConflictOptions _conflictDetection = ConflictOptions.OverwriteChanges;
private string _deleteCommand;
private SqlDataSourceCommandType _deleteCommandType = SqlDataSourceCommandType.Text;
private ParameterCollection _deleteParameters;
private string _filterExpression;
private ParameterCollection _filterParameters;
private string _insertCommand;
private SqlDataSourceCommandType _insertCommandType = SqlDataSourceCommandType.Text;
private ParameterCollection _insertParameters;
private string _oldValuesParameterFormatString;
private string _selectCommand;
private SqlDataSourceCommandType _selectCommandType = SqlDataSourceCommandType.Text;
private ParameterCollection _selectParameters;
private string _sortParameterName;
private string _updateCommand;
private SqlDataSourceCommandType _updateCommandType = SqlDataSourceCommandType.Text;
private ParameterCollection _updateParameters;
///
/// Creates a new instance of SqlDataSourceView.
///
public SqlDataSourceView(SqlDataSource owner, string name, HttpContext context) : base(owner, name) {
_owner = owner;
_context = context;
}
public bool CancelSelectOnNullParameter {
get {
return _cancelSelectOnNullParameter;
}
set {
if (CancelSelectOnNullParameter != value) {
_cancelSelectOnNullParameter = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
///
/// Indicates that the view can delete rows.
///
public override bool CanDelete {
get {
return (DeleteCommand.Length != 0);
}
}
///
/// Indicates that the view can add new rows.
///
public override bool CanInsert {
get {
return (InsertCommand.Length != 0);
}
}
///
/// Indicates that the view can page the datasource on the server.
///
public override bool CanPage {
get {
return false;
}
}
///
/// Indicates that the view can return the total number of rows returned by the query.
///
public override bool CanRetrieveTotalRowCount {
get {
return false;
}
}
///
/// Indicates that the view can sort rows.
///
public override bool CanSort {
get {
return (_owner.DataSourceMode == SqlDataSourceMode.DataSet) || (SortParameterName.Length > 0);
}
}
///
/// Indicates that the view can update rows.
///
public override bool CanUpdate {
get {
return (UpdateCommand.Length != 0);
}
}
///
/// Whether commands pass old values in the parameter collection.
///
public ConflictOptions ConflictDetection {
get {
return _conflictDetection;
}
set {
if ((value < ConflictOptions.OverwriteChanges) || (value > ConflictOptions.CompareAllValues)) {
throw new ArgumentOutOfRangeException("value");
}
_conflictDetection = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
///
/// The command to execute when Delete() is called on the SqlDataSourceView.
///
public string DeleteCommand {
get {
if (_deleteCommand == null) {
return String.Empty;
}
return _deleteCommand;
}
set {
_deleteCommand = value;
}
}
public SqlDataSourceCommandType DeleteCommandType {
get {
return _deleteCommandType;
}
set {
if ((value < SqlDataSourceCommandType.Text) || (value > SqlDataSourceCommandType.StoredProcedure)) {
throw new ArgumentOutOfRangeException("value");
}
_deleteCommandType = value;
}
}
///
/// Collection of parameters used in Delete().
///
[
DefaultValue(null),
Editor("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
PersistenceMode(PersistenceMode.InnerProperty),
WebSysDescription(SR.SqlDataSource_DeleteParameters),
]
public ParameterCollection DeleteParameters {
get {
if (_deleteParameters == null) {
_deleteParameters = new ParameterCollection();
}
return _deleteParameters;
}
}
///
/// The filter to apply when Select() is called on the SqlDataSourceView.
///
public string FilterExpression {
get {
if (_filterExpression == null) {
return String.Empty;
}
return _filterExpression;
}
set {
if (FilterExpression != value) {
_filterExpression = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
///
/// Collection of parameters used in the FilterExpression property.
///
[
DefaultValue(null),
Editor("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
PersistenceMode(PersistenceMode.InnerProperty),
WebSysDescription(SR.SqlDataSource_FilterParameters),
]
public ParameterCollection FilterParameters {
get {
if (_filterParameters == null) {
_filterParameters = new ParameterCollection();
_filterParameters.ParametersChanged += new EventHandler(SelectParametersChangedEventHandler);
if (_tracking) {
((IStateManager)_filterParameters).TrackViewState();
}
}
return _filterParameters;
}
}
///
/// The command to execute when Insert() is called on the SqlDataSourceView.
///
public string InsertCommand {
get {
if (_insertCommand == null) {
return String.Empty;
}
return _insertCommand;
}
set {
_insertCommand = value;
}
}
public SqlDataSourceCommandType InsertCommandType {
get {
return _insertCommandType;
}
set {
if ((value < SqlDataSourceCommandType.Text) || (value > SqlDataSourceCommandType.StoredProcedure)) {
throw new ArgumentOutOfRangeException("value");
}
_insertCommandType = value;
}
}
///
/// Collection of values used in Insert().
///
[
DefaultValue(null),
Editor("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
PersistenceMode(PersistenceMode.InnerProperty),
WebSysDescription(SR.SqlDataSource_InsertParameters),
]
public ParameterCollection InsertParameters {
get {
if (_insertParameters == null) {
_insertParameters = new ParameterCollection();
}
return _insertParameters;
}
}
///
/// Returns whether this object is tracking view state.
///
protected bool IsTrackingViewState {
get {
return _tracking;
}
}
///
/// The format string applied to the names of the old values parameters
///
[
DefaultValue("{0}"),
WebCategory("Data"),
WebSysDescription(SR.DataSource_OldValuesParameterFormatString),
]
public string OldValuesParameterFormatString {
get {
if (_oldValuesParameterFormatString == null) {
return "{0}";
}
return _oldValuesParameterFormatString;
}
set {
_oldValuesParameterFormatString = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
///
/// Indicates the prefix for parameters.
///
protected virtual string ParameterPrefix {
get {
if (String.IsNullOrEmpty(_owner.ProviderName) ||
String.Equals(_owner.ProviderName, "System.Data.SqlClient", StringComparison.OrdinalIgnoreCase)) {
return "@";
}
else {
return String.Empty;
}
}
}
///
/// The command to execute when Select() is called on the SqlDataSourceView.
///
public string SelectCommand {
get {
if (_selectCommand == null) {
return String.Empty;
}
return _selectCommand;
}
set {
if (SelectCommand != value) {
_selectCommand = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public SqlDataSourceCommandType SelectCommandType {
get {
return _selectCommandType;
}
set {
if ((value < SqlDataSourceCommandType.Text) || (value > SqlDataSourceCommandType.StoredProcedure)) {
throw new ArgumentOutOfRangeException("value");
}
_selectCommandType = value;
}
}
///
/// The command to execute when Select is called on the SqlDataSourceView and the total rows is requested.
///
/*public string SelectCountCommand {
get {
if (_selectCountCommand == null) {
return String.Empty;
}
return _selectCountCommand;
}
set {
if (SelectCountCommand != value) {
_selectCountCommand = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}*/
///
/// Collection of parameters used in Select().
///
public ParameterCollection SelectParameters {
get {
if (_selectParameters == null) {
_selectParameters = new ParameterCollection();
_selectParameters.ParametersChanged += new EventHandler(SelectParametersChangedEventHandler);
if (_tracking) {
((IStateManager)_selectParameters).TrackViewState();
}
}
return _selectParameters;
}
}
///
/// The name of the parameter in the SelectCommand that specifies the
/// sort expression. This parameter's value will be automatically set
/// at runtime with the appropriate sort expression. This is only
/// supported for stored procedure commands.
///
public string SortParameterName {
get {
if (_sortParameterName == null) {
return String.Empty;
}
return _sortParameterName;
}
set {
if (SortParameterName != value) {
_sortParameterName = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
///
/// The command to execute when Update() is called on the SqlDataSourceView.
///
public string UpdateCommand {
get {
if (_updateCommand == null) {
return String.Empty;
}
return _updateCommand;
}
set {
_updateCommand = value;
}
}
public SqlDataSourceCommandType UpdateCommandType {
get {
return _updateCommandType;
}
set {
if ((value < SqlDataSourceCommandType.Text) || (value > SqlDataSourceCommandType.StoredProcedure)) {
throw new ArgumentOutOfRangeException("value");
}
_updateCommandType = value;
}
}
///
/// Collection of parameters used in Update().
///
[
DefaultValue(null),
Editor("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
PersistenceMode(PersistenceMode.InnerProperty),
WebSysDescription(SR.SqlDataSource_UpdateParameters),
]
public ParameterCollection UpdateParameters {
get {
if (_updateParameters == null) {
_updateParameters = new ParameterCollection();
}
return _updateParameters;
}
}
///
/// This event is raised after the Delete operation has completed.
/// Handle this event if you need to examine the values of output parameters.
///
public event SqlDataSourceStatusEventHandler Deleted {
add {
Events.AddHandler(EventDeleted, value);
}
remove {
Events.RemoveHandler(EventDeleted, value);
}
}
///
/// This event is raised before the Delete operation has been executed.
/// Handle this event if you want to perform additional initialization operations
/// that are specific to your application. You can also handle this event if you
/// need to validate the values of parameters or change their values.
/// When this event is raised, the database connection is not open yet, and you
/// can cancel the event by setting the Cancel property of the DataCommandEventArgs
/// to true.
///
public event SqlDataSourceCommandEventHandler Deleting {
add {
Events.AddHandler(EventDeleting, value);
}
remove {
Events.RemoveHandler(EventDeleting, value);
}
}
public event SqlDataSourceFilteringEventHandler Filtering {
add {
Events.AddHandler(EventFiltering, value);
}
remove {
Events.RemoveHandler(EventFiltering, value);
}
}
///
/// This event is raised after the Insert operation has completed.
/// Handle this event if you need to examine the values of output parameters.
///
public event SqlDataSourceStatusEventHandler Inserted {
add {
Events.AddHandler(EventInserted, value);
}
remove {
Events.RemoveHandler(EventInserted, value);
}
}
///
/// This event is raised before the Insert operation has been executed.
/// Handle this event if you want to perform additional initialization operations
/// that are specific to your application. You can also handle this event if you
/// need to validate the values of parameters or change their values.
/// When this event is raised, the database connection is not open yet, and you
/// can cancel the event by setting the Cancel property of the DataCommandEventArgs
/// to true.
///
public event SqlDataSourceCommandEventHandler Inserting {
add {
Events.AddHandler(EventInserting, value);
}
remove {
Events.RemoveHandler(EventInserting, value);
}
}
///
/// This event is raised after the Select operation has completed.
/// Handle this event if you need to examine the values of output parameters.
///
public event SqlDataSourceStatusEventHandler Selected {
add {
Events.AddHandler(EventSelected, value);
}
remove {
Events.RemoveHandler(EventSelected, value);
}
}
///
/// This event is raised before the Select operation has been executed.
/// Handle this event if you want to perform additional initialization operations
/// that are specific to your application. You can also handle this event if you
/// need to validate the values of parameters or change their values.
/// When this event is raised, the database connection is not open yet, and you
/// can cancel the event by setting the Cancel property of the DataCommandEventArgs
/// to true.
///
public event SqlDataSourceSelectingEventHandler Selecting {
add {
Events.AddHandler(EventSelecting, value);
}
remove {
Events.RemoveHandler(EventSelecting, value);
}
}
///
/// This event is raised after the Update operation has completed.
/// Handle this event if you need to examine the values of output parameters.
///
public event SqlDataSourceStatusEventHandler Updated {
add {
Events.AddHandler(EventUpdated, value);
}
remove {
Events.RemoveHandler(EventUpdated, value);
}
}
///
/// This event is raised before the Update operation has been executed.
/// Handle this event if you want to perform additional initialization operations
/// that are specific to your application. You can also handle this event if you
/// need to validate the values of parameters or change their values.
/// When this event is raised, the database connection is not open yet, and you
/// can cancel the event by setting the Cancel property of the DataCommandEventArgs
/// to true.
///
public event SqlDataSourceCommandEventHandler Updating {
add {
Events.AddHandler(EventUpdating, value);
}
remove {
Events.RemoveHandler(EventUpdating, value);
}
}
///
/// Adds parameters to an DbCommand from an IOrderedDictionary.
/// The exclusion list contains parameter names that should not be added
/// to the command's parameter collection.
///
private void AddParameters(DbCommand command, ParameterCollection reference, IDictionary parameters, IDictionary exclusionList, string oldValuesParameterFormatString) {
Debug.Assert(command != null);
IDictionary caseInsensitiveExclusionList = null;
if (exclusionList != null) {
caseInsensitiveExclusionList = new ListDictionary(StringComparer.OrdinalIgnoreCase);
foreach (DictionaryEntry de in exclusionList) {
caseInsensitiveExclusionList.Add(de.Key, de.Value);
}
}
if (parameters != null) {
string parameterPrefix = ParameterPrefix;
foreach (DictionaryEntry de in parameters) {
string rawParamName = (string)de.Key;
if ((caseInsensitiveExclusionList != null) && (caseInsensitiveExclusionList.Contains(rawParamName))) {
// If we have an exclusion list and it contains this parameter, skip it
continue;
}
string formattedParamName;
if (oldValuesParameterFormatString == null) {
formattedParamName = rawParamName;
}
else {
formattedParamName = String.Format(CultureInfo.InvariantCulture, oldValuesParameterFormatString, rawParamName);
}
object value = de.Value;
// If the reference collection contains this parameter, we will use
// the Parameter's settings to format the value
Parameter parameter = reference[formattedParamName];
if (parameter != null) {
value = parameter.GetValue(de.Value, false);
}
formattedParamName = parameterPrefix + formattedParamName;
if (command.Parameters.Contains(formattedParamName)) {
// We never overwrite an existing value with a null value
if (value != null) {
command.Parameters[formattedParamName].Value = value;
}
}
else {
// Parameter does not exist, add a new one
DbParameter dbParameter = _owner.CreateParameter(formattedParamName, value);
command.Parameters.Add(dbParameter);
}
}
}
}
///
/// Builds a custom exception for specific database errors.
/// Currently the only custom exception text supported is for SQL Server
/// when a parameter is present in the command but not in the parameters
/// collection.
/// The isCustomException parameter indicates whether a custom exception
/// was created or not. This way the caller can determine whether it wants
/// to rethrow the original exception or throw the new custom exception.
///
private Exception BuildCustomException(Exception ex, DataSourceOperation operation, DbCommand command, out bool isCustomException) {
System.Data.SqlClient.SqlException sqlException = ex as System.Data.SqlClient.SqlException;
if (sqlException != null) {
if ((sqlException.Number == MustDeclareVariableSqlExceptionNumber) ||
(sqlException.Number == ProcedureExpectsParameterSqlExceptionNumber)) {
string parameterNames;
if (command.Parameters.Count > 0) {
StringBuilder sb = new StringBuilder();
bool firstParameter = true;
foreach (DbParameter p in command.Parameters) {
if (!firstParameter) {
sb.Append(", ");
}
sb.Append(p.ParameterName);
firstParameter = false;
}
parameterNames = sb.ToString();
}
else {
parameterNames = SR.GetString(SR.SqlDataSourceView_NoParameters);
}
isCustomException = true;
return new InvalidOperationException(SR.GetString(SR.SqlDataSourceView_MissingParameters, operation, _owner.ID, parameterNames));
}
}
isCustomException = false;
return ex;
}
public int Delete(IDictionary keys, IDictionary oldValues) {
return ExecuteDelete(keys, oldValues);
}
///
/// Executes a DbCommand and returns the number of rows affected.
///
private int ExecuteDbCommand(DbCommand command, DataSourceOperation operation) {
int rowsAffected = 0;
bool eventRaised = false;
try {
if (command.Connection.State != ConnectionState.Open) {
command.Connection.Open();
}
rowsAffected = command.ExecuteNonQuery();
if (rowsAffected > 0) {
OnDataSourceViewChanged(EventArgs.Empty);
DataSourceCache cache = _owner.Cache;
if ((cache != null) && (cache.Enabled)) {
_owner.InvalidateCacheEntry();
}
}
// Raise appropriate event
eventRaised = true;
SqlDataSourceStatusEventArgs eventArgs = new SqlDataSourceStatusEventArgs(command, rowsAffected, null);
switch (operation) {
case DataSourceOperation.Delete:
OnDeleted(eventArgs);
break;
case DataSourceOperation.Insert:
OnInserted(eventArgs);
break;
case DataSourceOperation.Update:
OnUpdated(eventArgs);
break;
}
}
catch (Exception ex) {
if (!eventRaised) {
// Raise appropriate event
SqlDataSourceStatusEventArgs eventArgs = new SqlDataSourceStatusEventArgs(command, rowsAffected, ex);
switch (operation) {
case DataSourceOperation.Delete:
OnDeleted(eventArgs);
break;
case DataSourceOperation.Insert:
OnInserted(eventArgs);
break;
case DataSourceOperation.Update:
OnUpdated(eventArgs);
break;
}
if (!eventArgs.ExceptionHandled) {
throw;
}
}
else {
bool isCustomException;
ex = BuildCustomException(ex, operation, command, out isCustomException);
if (isCustomException) {
throw ex;
}
else {
throw;
}
}
}
finally {
if (command.Connection.State == ConnectionState.Open) {
command.Connection.Close();
}
}
return rowsAffected;
}
///
/// Deletes rows from the data source with given parameters.
///
protected override int ExecuteDelete(IDictionary keys, IDictionary oldValues) {
if (!CanDelete) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_DeleteNotSupported, _owner.ID));
}
DbConnection connection = _owner.CreateConnection(_owner.ConnectionString);
if (connection == null) {
throw new InvalidOperationException(SR.GetString(SR.SqlDataSourceView_CouldNotCreateConnection, _owner.ID));
}
// Create command and add parameters
string oldValuesParameterFormatString = OldValuesParameterFormatString;
DbCommand command = _owner.CreateCommand(DeleteCommand, connection);
InitializeParameters(command, DeleteParameters, oldValues);
AddParameters(command, DeleteParameters, keys, null, oldValuesParameterFormatString);
if (ConflictDetection == ConflictOptions.CompareAllValues) {
if (oldValues == null || oldValues.Count == 0) {
throw new InvalidOperationException(SR.GetString(SR.SqlDataSourceView_Pessimistic, SR.GetString(SR.DataSourceView_delete), _owner.ID, "values"));
}
AddParameters(command, DeleteParameters, oldValues, null, oldValuesParameterFormatString);
}
command.CommandType = GetCommandType(DeleteCommandType);
// Raise event to allow customization and cancellation
SqlDataSourceCommandEventArgs eventArgs = new SqlDataSourceCommandEventArgs(command);
OnDeleting(eventArgs);
// If the operation was cancelled, exit immediately
if (eventArgs.Cancel) {
return 0;
}
// Replace null values in parameters with DBNull.Value
ReplaceNullValues(command);
return ExecuteDbCommand(command, DataSourceOperation.Delete);
}
///
/// Inserts a new row with data from a name/value collection.
///
protected override int ExecuteInsert(IDictionary values) {
if (!CanInsert) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_InsertNotSupported, _owner.ID));
}
DbConnection connection = _owner.CreateConnection(_owner.ConnectionString);
if (connection == null) {
throw new InvalidOperationException(SR.GetString(SR.SqlDataSourceView_CouldNotCreateConnection, _owner.ID));
}
// Create command and add parameters
DbCommand command = _owner.CreateCommand(InsertCommand, connection);
InitializeParameters(command, InsertParameters, null);
AddParameters(command, InsertParameters, values, null, null);
command.CommandType = GetCommandType(InsertCommandType);
// Raise event to allow customization and cancellation
SqlDataSourceCommandEventArgs eventArgs = new SqlDataSourceCommandEventArgs(command);
OnInserting(eventArgs);
// If the operation was cancelled, exit immediately
if (eventArgs.Cancel) {
return 0;
}
// Replace null values in parameters with DBNull.Value
ReplaceNullValues(command);
return ExecuteDbCommand(command, DataSourceOperation.Insert);
}
///
/// Returns all the rows of the datasource.
/// Parameters are taken from the SqlDataSource.Parameters property collection.
/// If DataSourceMode is set to DataSet then a DataView is returned.
/// If DataSourceMode is set to DataReader then a DataReader is returned, and it must be closed when done.
///
protected internal override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments) {
if (SelectCommand.Length == 0) {
return null;
}
DbConnection connection = _owner.CreateConnection(_owner.ConnectionString);
if (connection == null) {
throw new InvalidOperationException(SR.GetString(SR.SqlDataSourceView_CouldNotCreateConnection, _owner.ID));
}
DataSourceCache cache = _owner.Cache;
bool cacheEnabled = (cache != null) && (cache.Enabled);
//int startRowIndex = arguments.StartRowIndex;
//int maximumRows = arguments.MaximumRows;
string sortExpression = arguments.SortExpression;
if (CanPage) {
arguments.AddSupportedCapabilities(DataSourceCapabilities.Page);
}
if (CanSort) {
arguments.AddSupportedCapabilities(DataSourceCapabilities.Sort);
}
if (CanRetrieveTotalRowCount) {
arguments.AddSupportedCapabilities(DataSourceCapabilities.RetrieveTotalRowCount);
}
// If caching is enabled, load DataSet from cache
if (cacheEnabled) {
if (_owner.DataSourceMode != SqlDataSourceMode.DataSet) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_CacheNotSupported, _owner.ID));
}
arguments.RaiseUnsupportedCapabilitiesError(this);
DataSet dataSet = _owner.LoadDataFromCache(0, -1) as DataSet;
if (dataSet != null) {
/*if (arguments.RetrieveTotalRowCount) {
int cachedTotalRowCount = _owner.LoadTotalRowCountFromCache();
if (cachedTotalRowCount >= 0) {
arguments.TotalRowCount = cachedTotalRowCount;
}
else {
// query for row count and then save it in cache
cachedTotalRowCount = QueryTotalRowCount(connection, arguments);
arguments.TotalRowCount = cachedTotalRowCount;
_owner.SaveTotalRowCountToCache(cachedTotalRowCount);
}
}*/
IOrderedDictionary parameterValues = FilterParameters.GetValues(_context, _owner);
if (FilterExpression.Length > 0) {
SqlDataSourceFilteringEventArgs filterArgs = new SqlDataSourceFilteringEventArgs(parameterValues);
OnFiltering(filterArgs);
if (filterArgs.Cancel) {
return null;
}
}
return FilteredDataSetHelper.CreateFilteredDataView(dataSet.Tables[0], sortExpression, FilterExpression, parameterValues);
}
}
// Create command and add parameters
DbCommand command = _owner.CreateCommand(SelectCommand, connection);
InitializeParameters(command, SelectParameters, null);
command.CommandType = GetCommandType(SelectCommandType);
// Raise event to allow customization and cancellation
SqlDataSourceSelectingEventArgs selectingEventArgs = new SqlDataSourceSelectingEventArgs(command, arguments);
OnSelecting(selectingEventArgs);
// If the operation was cancelled, exit immediately
if (selectingEventArgs.Cancel) {
return null;
}
// Add the sort parameter to allow for custom stored procedure sorting, if necessary
string sortParameterName = SortParameterName;
if (sortParameterName.Length > 0) {
if (command.CommandType != CommandType.StoredProcedure) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_SortParameterRequiresStoredProcedure, _owner.ID));
}
command.Parameters.Add(_owner.CreateParameter(ParameterPrefix + sortParameterName, sortExpression));
// We reset the sort expression here so that we pretend as
// though we're not really sorting (since the developer is
// worrying about it instead of us).
arguments.SortExpression = String.Empty;
}
arguments.RaiseUnsupportedCapabilitiesError(this);
// reset these values, since they might have changed in the OnSelecting event
sortExpression = arguments.SortExpression;
//startRowIndex = arguments.StartRowIndex;
//maximumRows = arguments.MaximumRows;
// Perform null check if user wants to cancel on any null parameter value
if (CancelSelectOnNullParameter) {
int paramCount = command.Parameters.Count;
for (int i = 0; i < paramCount; i++) {
DbParameter parameter = command.Parameters[i];
if ((parameter != null) &&
(parameter.Value == null) &&
((parameter.Direction == ParameterDirection.Input) || (parameter.Direction == ParameterDirection.InputOutput))) {
return null;
}
}
}
// Replace null values in parameters with DBNull.Value
ReplaceNullValues(command);
/*if (arguments.RetrieveTotalRowCount && SelectCountCommand.Length > 0) {
int cachedTotalRowCount = -1;
if (cacheEnabled) {
cachedTotalRowCount = _owner.LoadTotalRowCountFromCache();
if (cachedTotalRowCount >= 0) {
arguments.TotalRowCount = cachedTotalRowCount;
}
}
if (cachedTotalRowCount < 0) {
cachedTotalRowCount = QueryTotalRowCount(connection, arguments);
arguments.TotalRowCount = cachedTotalRowCount;
if (cacheEnabled) {
_owner.SaveTotalRowCountToCache(cachedTotalRowCount);
}
}
}*/
IEnumerable selectResult = null;
switch (_owner.DataSourceMode) {
case SqlDataSourceMode.DataSet:
{
SqlCacheDependency cacheDependency = null;
if (cacheEnabled && cache is SqlDataSourceCache) {
SqlDataSourceCache sqlCache = (SqlDataSourceCache)cache;
if (String.Equals(sqlCache.SqlCacheDependency, SqlDataSourceCache.Sql9CacheDependencyDirective, StringComparison.OrdinalIgnoreCase)) {
if (!(command is System.Data.SqlClient.SqlCommand)) {
throw new InvalidOperationException(SR.GetString(SR.SqlDataSourceView_CommandNotificationNotSupported, _owner.ID));
}
cacheDependency = new SqlCacheDependency((System.Data.SqlClient.SqlCommand)command);
}
}
DbDataAdapter adapter = _owner.CreateDataAdapter(command);
DataSet dataSet = new DataSet();
int rowsAffected = 0;
bool eventRaised = false;
try {
rowsAffected = adapter.Fill(dataSet, Name);
// Raise the Selected event
eventRaised = true;
SqlDataSourceStatusEventArgs selectedEventArgs = new SqlDataSourceStatusEventArgs(command, rowsAffected, null);
OnSelected(selectedEventArgs);
}
catch (Exception ex) {
if (!eventRaised) {
// Raise the Selected event
SqlDataSourceStatusEventArgs selectedEventArgs = new SqlDataSourceStatusEventArgs(command, rowsAffected, ex);
OnSelected(selectedEventArgs);
if (!selectedEventArgs.ExceptionHandled) {
throw;
}
}
else {
bool isCustomException;
ex = BuildCustomException(ex, DataSourceOperation.Select, command, out isCustomException);
if (isCustomException) {
throw ex;
}
else {
throw;
}
}
}
finally {
if (connection.State == ConnectionState.Open) {
connection.Close();
}
}
// If caching is enabled, save DataSet to cache
DataTable dataTable = (dataSet.Tables.Count > 0 ? dataSet.Tables[0] : null);
if (cacheEnabled && dataTable != null) {
_owner.SaveDataToCache(0, -1, dataSet, cacheDependency);
}
if (dataTable != null) {
IOrderedDictionary parameterValues = FilterParameters.GetValues(_context, _owner);
if (FilterExpression.Length > 0) {
SqlDataSourceFilteringEventArgs filterArgs = new SqlDataSourceFilteringEventArgs(parameterValues);
OnFiltering(filterArgs);
if (filterArgs.Cancel) {
return null;
}
}
selectResult = FilteredDataSetHelper.CreateFilteredDataView(dataTable, sortExpression, FilterExpression, parameterValues);
}
break;
}
case SqlDataSourceMode.DataReader:
{
if (FilterExpression.Length > 0) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_FilterNotSupported, _owner.ID));
}
if (sortExpression.Length > 0) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_SortNotSupported, _owner.ID));
}
bool eventRaised = false;
try {
if (connection.State != ConnectionState.Open) {
connection.Open();
}
selectResult = command.ExecuteReader(CommandBehavior.CloseConnection);
// Raise the Selected event
eventRaised = true;
SqlDataSourceStatusEventArgs selectedEventArgs = new SqlDataSourceStatusEventArgs(command, 0, null);
OnSelected(selectedEventArgs);
}
catch (Exception ex) {
if (!eventRaised) {
// Raise the Selected event
SqlDataSourceStatusEventArgs selectedEventArgs = new SqlDataSourceStatusEventArgs(command, 0, ex);
OnSelected(selectedEventArgs);
if (!selectedEventArgs.ExceptionHandled) {
throw;
}
}
else {
bool isCustomException;
ex = BuildCustomException(ex, DataSourceOperation.Select, command, out isCustomException);
if (isCustomException) {
throw ex;
}
else {
throw;
}
}
}
break;
}
}
return selectResult;
}
///
/// Updates rows matching the parameter collection and setting new values from the name/value values collection.
///
protected override int ExecuteUpdate(IDictionary keys, IDictionary values, IDictionary oldValues) {
if (!CanUpdate) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_UpdateNotSupported, _owner.ID));
}
DbConnection connection = _owner.CreateConnection(_owner.ConnectionString);
if (connection == null) {
throw new InvalidOperationException(SR.GetString(SR.SqlDataSourceView_CouldNotCreateConnection, _owner.ID));
}
// Create command and add parameters
string oldValuesParameterFormatString = OldValuesParameterFormatString;
DbCommand command = _owner.CreateCommand(UpdateCommand, connection);
InitializeParameters(command, UpdateParameters, keys);
AddParameters(command, UpdateParameters, values, null, null);
AddParameters(command, UpdateParameters, keys, null, oldValuesParameterFormatString);
if (ConflictDetection == ConflictOptions.CompareAllValues) {
if (oldValues == null || oldValues.Count == 0) {
throw new InvalidOperationException(SR.GetString(SR.SqlDataSourceView_Pessimistic, SR.GetString(SR.DataSourceView_update), _owner.ID, "oldValues"));
}
AddParameters(command, UpdateParameters, oldValues, null, oldValuesParameterFormatString);
}
command.CommandType = GetCommandType(UpdateCommandType);
// Raise event to allow customization and cancellation
SqlDataSourceCommandEventArgs eventArgs = new SqlDataSourceCommandEventArgs(command);
OnUpdating(eventArgs);
// If the operation was cancelled, exit immediately
if (eventArgs.Cancel) {
return 0;
}
// Replace null values in parameters with DBNull.Value
ReplaceNullValues(command);
return ExecuteDbCommand(command, DataSourceOperation.Update);
}
///
/// Converts a SqlDataSourceCommandType to a System.Data.CommandType.
///
private static CommandType GetCommandType(SqlDataSourceCommandType commandType) {
if (commandType == SqlDataSourceCommandType.Text) {
return CommandType.Text;
}
return CommandType.StoredProcedure;
}
///
/// Initializes a DbCommand with parameters from a ParameterCollection.
/// The exclusion list contains parameter names that should not be added
/// to the command's parameter collection.
///
private void InitializeParameters(DbCommand command, ParameterCollection parameters, IDictionary exclusionList) {
Debug.Assert(command != null);
Debug.Assert(parameters != null);
string parameterPrefix = ParameterPrefix;
IDictionary caseInsensitiveExclusionList = null;
if (exclusionList != null) {
caseInsensitiveExclusionList = new ListDictionary(StringComparer.OrdinalIgnoreCase);
foreach (DictionaryEntry de in exclusionList) {
caseInsensitiveExclusionList.Add(de.Key, de.Value);
}
}
IOrderedDictionary values = parameters.GetValues(_context, _owner);
for (int i = 0; i < parameters.Count; i++) {
Parameter parameter = parameters[i];
if ((caseInsensitiveExclusionList == null) || (!caseInsensitiveExclusionList.Contains(parameter.Name))) {
DbParameter dbParameter = _owner.CreateParameter(parameterPrefix + parameter.Name, values[i]);
dbParameter.Direction = parameter.Direction;
dbParameter.Size = parameter.Size;
if (parameter.DbType != DbType.Object || (parameter.Type != TypeCode.Empty && parameter.Type != TypeCode.DBNull)) {
SqlParameter sqlParameter = dbParameter as SqlParameter;
if (sqlParameter == null) {
dbParameter.DbType = parameter.GetDatabaseType();
}
else {
// In Whidbey, the DbType Date and Time members mapped to SqlDbType.DateTime since there
// were no SqlDbType equivalents. SqlDbType has since been modified to include the new
// Katmai types, including Date and Time. For backwards compatability SqlParameter's DbType
// setter doesn't support Date and Time, so the SqlDbType property should be used instead.
// Other new SqlServer 2008 types (DateTime2, DateTimeOffset) can be set using DbType.
DbType dbType = parameter.GetDatabaseType();
switch (dbType) {
case DbType.Time:
sqlParameter.SqlDbType = SqlDbType.Time;
break;
case DbType.Date:
sqlParameter.SqlDbType = SqlDbType.Date;
break;
default:
dbParameter.DbType = parameter.GetDatabaseType();
break;
}
}
}
command.Parameters.Add(dbParameter);
}
}
}
public int Insert(IDictionary values) {
return ExecuteInsert(values);
}
///
/// Loads view state.
///
protected virtual void LoadViewState(object savedState) {
if (savedState == null)
return;
Pair myState = (Pair)savedState;
if (myState.First != null)
((IStateManager)SelectParameters).LoadViewState(myState.First);
if (myState.Second != null)
((IStateManager)FilterParameters).LoadViewState(myState.Second);
}
///
/// Raises the Deleted event.
///
protected virtual void OnDeleted(SqlDataSourceStatusEventArgs e) {
SqlDataSourceStatusEventHandler handler = Events[EventDeleted] as SqlDataSourceStatusEventHandler;
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the Deleting event.
///
protected virtual void OnDeleting(SqlDataSourceCommandEventArgs e) {
SqlDataSourceCommandEventHandler handler = Events[EventDeleting] as SqlDataSourceCommandEventHandler;
if (handler != null) {
handler(this, e);
}
}
protected virtual void OnFiltering(SqlDataSourceFilteringEventArgs e) {
SqlDataSourceFilteringEventHandler handler = Events[EventFiltering] as SqlDataSourceFilteringEventHandler;
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the Inserted event.
///
protected virtual void OnInserted(SqlDataSourceStatusEventArgs e) {
SqlDataSourceStatusEventHandler handler = Events[EventInserted] as SqlDataSourceStatusEventHandler;
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the Inserting event.
///
protected virtual void OnInserting(SqlDataSourceCommandEventArgs e) {
SqlDataSourceCommandEventHandler handler = Events[EventInserting] as SqlDataSourceCommandEventHandler;
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the Selected event.
///
protected virtual void OnSelected(SqlDataSourceStatusEventArgs e) {
SqlDataSourceStatusEventHandler handler = Events[EventSelected] as SqlDataSourceStatusEventHandler;
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the Selecting event.
///
protected virtual void OnSelecting(SqlDataSourceSelectingEventArgs e) {
SqlDataSourceSelectingEventHandler handler = Events[EventSelecting] as SqlDataSourceSelectingEventHandler;
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the Updated event.
///
protected virtual void OnUpdated(SqlDataSourceStatusEventArgs e) {
SqlDataSourceStatusEventHandler handler = Events[EventUpdated] as SqlDataSourceStatusEventHandler;
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the Updating event.
///
protected virtual void OnUpdating(SqlDataSourceCommandEventArgs e) {
SqlDataSourceCommandEventHandler handler = Events[EventUpdating] as SqlDataSourceCommandEventHandler;
if (handler != null) {
handler(this, e);
}
}
///
/// Executes the SelectCountCommand to retrieve the total row count.
///
/*protected virtual int QueryTotalRowCount(DbConnection connection, DataSourceSelectArguments arguments) {
int totalRowCount = 0;
bool eventRaised = false;
if (SelectCountCommand.Length > 0) {
// Create command and add parameters
DbCommand command = _owner.CreateCommand(SelectCountCommand, connection);
InitializeParameters(command, SelectParameters);
command.CommandType = GetCommandType(SelectCountCommand, SelectCompareString);
// Raise event to allow customization and cancellation
SqlDataSourceSelectingEventArgs selectCountingEventArgs = new SqlDataSourceSelectingEventArgs(command, arguments, true);
OnSelecting(selectCountingEventArgs);
// If the operation was cancelled, exit immediately
if (selectCountingEventArgs.Cancel) {
return totalRowCount;
}
// the arguments may have been changed
arguments.RaiseUnsupportedCapabilitiesError(this);
//
*/
protected internal override void RaiseUnsupportedCapabilityError(DataSourceCapabilities capability) {
if (!CanPage && ((capability & DataSourceCapabilities.Page) != 0)) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_NoPaging, _owner.ID));
}
if (!CanSort && ((capability & DataSourceCapabilities.Sort) != 0)) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_NoSorting, _owner.ID));
}
if (!CanRetrieveTotalRowCount && ((capability & DataSourceCapabilities.RetrieveTotalRowCount) != 0)) {
throw new NotSupportedException(SR.GetString(SR.SqlDataSourceView_NoRowCount, _owner.ID));
}
base.RaiseUnsupportedCapabilityError(capability);
}
///
/// Replace null values in parameters with DBNull.Value.
///
private void ReplaceNullValues(DbCommand command) {
int paramCount = command.Parameters.Count;
foreach (DbParameter parameter in command.Parameters) {
if (parameter.Value == null) {
parameter.Value = DBNull.Value;
}
}
}
///
/// Saves view state.
///
protected virtual object SaveViewState() {
Pair myState = new Pair();
myState.First = (_selectParameters != null) ? ((IStateManager)_selectParameters).SaveViewState() : null;
myState.Second = (_filterParameters != null) ? ((IStateManager)_filterParameters).SaveViewState() : null;
if ((myState.First == null) &&
(myState.Second == null)) {
return null;
}
return myState;
}
public IEnumerable Select(DataSourceSelectArguments arguments) {
return ExecuteSelect(arguments);
}
///
/// Event handler for SelectParametersChanged event.
///
private void SelectParametersChangedEventHandler(object o, EventArgs e) {
OnDataSourceViewChanged(EventArgs.Empty);
}
///
/// Starts tracking view state.
///
protected virtual void TrackViewState() {
_tracking = true;
if (_selectParameters != null) {
((IStateManager)_selectParameters).TrackViewState();
}
if (_filterParameters != null) {
((IStateManager)_filterParameters).TrackViewState();
}
}
public int Update(IDictionary keys, IDictionary values, IDictionary oldValues) {
return ExecuteUpdate(keys, values, oldValues);
}
#region IStateManager implementation
bool IStateManager.IsTrackingViewState {
get {
return IsTrackingViewState;
}
}
void IStateManager.LoadViewState(object savedState) {
LoadViewState(savedState);
}
object IStateManager.SaveViewState() {
return SaveViewState();
}
void IStateManager.TrackViewState() {
TrackViewState();
}
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- XmlWriterTraceListener.cs
- WinFormsUtils.cs
- DesignerCommandSet.cs
- SettingsSavedEventArgs.cs
- SqlDataSourceAdvancedOptionsForm.cs
- TaskHelper.cs
- PeerToPeerException.cs
- DbConvert.cs
- SecurityPolicySection.cs
- UnsafeNetInfoNativeMethods.cs
- KnownColorTable.cs
- HandlerBase.cs
- HostAdapter.cs
- PipelineDeploymentState.cs
- Rotation3DAnimationBase.cs
- StringSorter.cs
- DragAssistanceManager.cs
- CommandEventArgs.cs
- TreeNode.cs
- SqlTriggerContext.cs
- BindingManagerDataErrorEventArgs.cs
- ViewValidator.cs
- Mappings.cs
- FormView.cs
- WorkflowOperationContext.cs
- DataServiceRequestOfT.cs
- CellLabel.cs
- WindowsPrincipal.cs
- xmlformatgeneratorstatics.cs
- GroupBoxRenderer.cs
- EpmSyndicationContentSerializer.cs
- Highlights.cs
- safemediahandle.cs
- OnOperation.cs
- NamespaceQuery.cs
- TimeStampChecker.cs
- ValidatorCompatibilityHelper.cs
- WindowsFormsEditorServiceHelper.cs
- RegexRunnerFactory.cs
- ValidatedControlConverter.cs
- WebResponse.cs
- Rule.cs
- DesignerRegion.cs
- XamlWriter.cs
- KnownTypeAttribute.cs
- TextBoxBase.cs
- StylusLogic.cs
- HelloMessage11.cs
- ReachBasicContext.cs
- VectorAnimationBase.cs
- DetailsViewCommandEventArgs.cs
- MouseGesture.cs
- PageThemeParser.cs
- CursorConverter.cs
- SafeBitVector32.cs
- CodeSnippetExpression.cs
- HttpModuleCollection.cs
- UndoManager.cs
- PhoneCall.cs
- NamespaceQuery.cs
- ClientSection.cs
- CacheModeConverter.cs
- FormatException.cs
- CngAlgorithmGroup.cs
- ExternalException.cs
- EntityContainerRelationshipSetEnd.cs
- WindowsRichEdit.cs
- WebColorConverter.cs
- InheritanceContextHelper.cs
- GlyphRunDrawing.cs
- ObjectContext.cs
- HttpStreamFormatter.cs
- InputScopeConverter.cs
- AttributeUsageAttribute.cs
- CaseInsensitiveOrdinalStringComparer.cs
- LicenseException.cs
- AsyncWaitHandle.cs
- ObjectParameter.cs
- ReadWriteObjectLock.cs
- TextRenderer.cs
- CryptographicAttribute.cs
- iisPickupDirectory.cs
- OdbcError.cs
- StructuredTypeEmitter.cs
- SchemaNames.cs
- ForeignConstraint.cs
- WmpBitmapEncoder.cs
- HealthMonitoringSectionHelper.cs
- GuidTagList.cs
- BitmapSourceSafeMILHandle.cs
- SqlDataSourceView.cs
- FastEncoderWindow.cs
- RtfToken.cs
- ArraySubsetEnumerator.cs
- XmlTextEncoder.cs
- TextEncodedRawTextWriter.cs
- InstanceLockException.cs
- ISessionStateStore.cs
- SimpleWorkerRequest.cs
- Positioning.cs