public void Equals ()
		{
			DataSourceSelectArguments arg1 = new DataSourceSelectArguments ();
			DataSourceSelectArguments arg2 = DataSourceSelectArguments.Empty;

			Assert.IsTrue (arg1.Equals (arg2), "Equals#1");
			Assert.IsTrue (arg1.GetHashCode () == arg2.GetHashCode (), "GetHashCode#1");

			arg1.SortExpression = "sort";
			arg1.MaximumRows = 10;
			arg1.StartRowIndex = 5;
			arg1.RetrieveTotalRowCount = true;
			arg1.TotalRowCount = 30;

			Assert.IsFalse (arg1.Equals (arg2), "Equals#2");
			Assert.IsFalse (arg1.GetHashCode () == arg2.GetHashCode (), "GetHashCode#2");

			arg2.SortExpression = "sort";
			arg2.MaximumRows = 10;
			arg2.StartRowIndex = 5;

			Assert.IsFalse (arg1.Equals (arg2), "Equals#3");
			Assert.IsFalse (arg1.GetHashCode () == arg2.GetHashCode (), "GetHashCode#3");

			arg2.RetrieveTotalRowCount = true;
			arg2.TotalRowCount = 30;

			Assert.IsTrue (arg1.Equals (arg2), "Equals#4");
			Assert.IsTrue (arg1.GetHashCode () == arg2.GetHashCode (), "GetHashCode#4");
		}

        protected override IEnumerable ExecuteSelect(DataSourceSelectArguments selectArgs)
        {
            // only continue if a membership provider has been configured
            if (!Utils.IsProviderConfigured())
                return null;

            // get roles and build data table
            DataTable dataTable = new DataTable();
            String[] roles = Utils.BaseRoleProvider().GetAllRoles();
            dataTable.Columns.Add("Role");
            dataTable.Columns.Add("UsersInRole");

            // add users in role counts
            for (int i = 0; i < roles.Length; i++)
            {
                DataRow row = dataTable.NewRow();
                row["Role"] = roles[i];
                row["UsersInRole"] = Utils.BaseRoleProvider().GetUsersInRole(roles[i].ToString()).Length;
                dataTable.Rows.Add(row);
            }
            dataTable.AcceptChanges();
            DataView dataView = new DataView(dataTable);

            // sort if a sort expression available
            if (selectArgs.SortExpression != String.Empty)
            {
                dataView.Sort = selectArgs.SortExpression;
            }

            // return as a DataList
            return (IEnumerable) dataView;
        }

		protected override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments)
		{
			if (this.dataSourceControl.Enabled == true)
			{
				IOrderedDictionary parameters = this.dataSourceControl.DataParameters.GetValues(HttpContext.Current, this.dataSourceControl);
				DataEventArgs args = new DataEventArgs(this.dataSourceControl.PageSize, arguments.StartRowIndex, arguments.SortExpression, parameters);

				this.dataSourceControl.GetData(args);

				arguments.TotalRowCount = args.TotalRowCount;
				arguments.MaximumRows = this.dataSourceControl.PageSize;
				arguments.AddSupportedCapabilities(DataSourceCapabilities.Page | DataSourceCapabilities.Sort | DataSourceCapabilities.RetrieveTotalRowCount);
				arguments.RetrieveTotalRowCount = true;

				if (!(args.Data is ICollection))
				{
					return (args.Data.OfType<Object>().ToList());
				}
				else
				{
					return (args.Data);
				}
			}
			else
			{
				arguments.TotalRowCount = 0;
				return (new ArrayList());
			}
		}

		public IList GetTableData (string tableName, DataSourceSelectArguments args, string where, ParameterCollection whereParams)
		{
			if (String.Compare (tableName, "BazValidationAttributesTable", StringComparison.OrdinalIgnoreCase) == 0)
				return BazValidationAttributes;

			return null;
		}

		/// <summary>
		/// Iterates through the <see cref="Navigation.Crumb"/> contents of <see cref="Navigation.StateController.Crumbs"/>
		/// </summary>
		/// <param name="arguments">This parameter is ignored</param>
		/// <returns>An <see cref="System.Collections.IEnumerable"/> list of <see cref="Navigation.Crumb"/> items</returns>
		protected override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments)
		{
			foreach (Crumb crumb in StateController.Crumbs)
			{
				yield return crumb;
			}
		}

        private void BindData()
        {
            SqlDataSource1.DataBind();
            //string sqlquery = "SELECT * FROM [ISBEPI_DEV].[dbo].[HomeVisitorSiteVisitSurvey] WHERE Schd_ID = 16";
            DataTable dt = new DataTable();
            DataSourceSelectArguments args = new DataSourceSelectArguments();
            DataView view = (DataView)SqlDataSource1.Select(args);
            dt = view.ToTable();
            DataSet ds = new DataSet();
            ds.Tables.Add(dt);
            DataSet new_ds = FlipDataSet(ds); // Flip the DataSet
            DataView my_DataView = new_ds.Tables[0].DefaultView;
            this.DataGrid1.DataSource = my_DataView;
            this.DataGrid1.DataBind();

            DataTable dt2 = new DataTable();
            DataSourceSelectArguments args2 = new DataSourceSelectArguments();
            DataView view2 = (DataView)SqlDataSource2.Select(args2);
            dt2 = view2.ToTable();
            DataSet ds2 = new DataSet();
            ds2.Tables.Add(dt2);
            DataSet new_ds2 = FlipDataSet(ds2); // Flip the DataSet
            DataView my_DataView2 = new_ds2.Tables[0].DefaultView;
            this.DataGrid2.DataSource = my_DataView2;
            this.DataGrid2.DataBind();
        }

 protected internal override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments)
 {
     if (string.IsNullOrEmpty(this._owner.DataFile))
     {
         throw new InvalidOperationException(System.Web.SR.GetString("AccessDataSourceView_SelectRequiresDataFile", new object[] { this._owner.ID }));
     }
     return base.ExecuteSelect(arguments);
 }

        /// <summary>
        /// Gets a list of data asynchronously from the underlying data storage.
        /// </summary>
        /// <param name="arguments">A <see cref="T:System.Web.UI.DataSourceSelectArguments"></see> that is used to request operations on the data beyond basic data retrieval.</param>
        /// <param name="callback">A <see cref="T:System.Web.UI.DataSourceViewSelectCallback"></see> delegate that is used to notify a data-bound control when the asynchronous operation is complete.</param>
        /// <exception cref="T:System.ArgumentNullException">The <see cref="T:System.Web.UI.DataSourceViewSelectCallback"></see> supplied is null.</exception>
        public override void Select(DataSourceSelectArguments arguments, DataSourceViewSelectCallback callback)
        {
            if (callback == null)
            {
                throw new ArgumentNullException("callback");
            }

            callback(ExecuteSelect(arguments));
        }

        protected override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments)
        {
            GenericSelectArgs args = new GenericSelectArgs(arguments)
            {
            };

            var theResult = this.Owner.Select(args);

            return theResult;
        }

 public QueryContext(IDictionary<string, object> whereParameters,
     IDictionary<string, object> orderGroupsByParameters,
     IOrderedDictionary orderByParameters,
     IDictionary<string, object> groupByParameters,
     IDictionary<string, object> selectParameters, 
     DataSourceSelectArguments arguments) {
     WhereParameters = whereParameters;
     OrderByParameters = orderByParameters;
     OrderGroupsByParameters = orderGroupsByParameters;
     SelectParameters = selectParameters;
     GroupByParameters = groupByParameters;
     Arguments = arguments;
 }

		public IList GetTableData (string tableName, DataSourceSelectArguments args, string where, ParameterCollection whereParams)
		{
			if (String.Compare (tableName, "AssociatedFooTable", StringComparison.OrdinalIgnoreCase) == 0)
				return AssociatedFoo;

			if (String.Compare (tableName, "AssociatedBarTable", StringComparison.OrdinalIgnoreCase) == 0)
				return AssociatedBar;

			if (String.Compare (tableName, "BazWithDataTypeAttributeTable", StringComparison.OrdinalIgnoreCase) == 0)
				return BazWithDataTypeAttribute;

			return null;
		}

		public IList GetTableData (string tableName, DataSourceSelectArguments args, string where, ParameterCollection whereParams)
		{
			if (String.Compare (tableName, "EmployeeTable", StringComparison.OrdinalIgnoreCase) == 0)
				return Employees;

			if (String.Compare (tableName, "SeasonalEmployeeTable", StringComparison.OrdinalIgnoreCase) == 0)
				return SeasonalEmployees;

			if (String.Compare (tableName, "BazDataTypeDefaultTypesTable", StringComparison.OrdinalIgnoreCase) == 0)
				return DefaultDataTypes;

			return null;
		}

 private void BindData()
 {
     SqlDataSource1.DataBind();          
     DataTable dt = new DataTable();
     DataSourceSelectArguments args = new DataSourceSelectArguments();
     DataView view = (DataView)SqlDataSource2.Select(args);
     dt = view.ToTable();
     DataSet ds = new DataSet();
     ds.Tables.Add(dt);
     DataSet new_ds = FlipDataSet(ds); // Flip the DataSet
     DataView my_DataView = new_ds.Tables[0].DefaultView;
     this.DataGrid1.DataSource = my_DataView;
     this.DataGrid1.DataBind();
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="arguments"></param>
        /// <param name="parameters"></param>
        /// <param name="sourceType"></param>
        public SelectingEventArgs(DataSourceSelectArguments arguments, IDictionary parameters, Type sourceType)
            : base(sourceType)
        {
            if (arguments == null)
                throw new ControlParameterException("The arguments for the SelectingEventArgs instance cannot be null.", "arguments");

            this.startRowIndex = arguments.StartRowIndex;
            this.maximumRows = arguments.MaximumRows;

            if (parameters != null && parameters.Count > 0)
            {
                this.parameters.AddRange(parameters.Keys.Cast<string>().Select<string, ISourceParameter>(n => new SourceParameter(n, parameters[n])));
            }
        }

 protected internal override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments)
 {
     arguments.RaiseUnsupportedCapabilitiesError(this);
     XmlNode xmlDocument = this._owner.GetXmlDocument();
     XmlNodeList nodes = null;
     if (this._owner.XPath.Length != 0)
     {
         nodes = xmlDocument.SelectNodes(this._owner.XPath);
     }
     else
     {
         nodes = xmlDocument.SelectNodes("/node()/node()");
     }
     return new XmlDataSourceNodeDescriptorEnumeration(nodes);
 }

        protected override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments)
        {
            arguments.RaiseUnsupportedCapabilitiesError(this);

            DataTable dt = _owner.GetDataTable();
            if(dt == null) return new DataTable().DefaultView;

            _dataView = new DataView(dt);

            PerformFiltering();

            PerformSorting(arguments.SortExpression);

            return _dataView;
        }

		public LinqDataSourceSelectEventArgs (
			DataSourceSelectArguments arguments,
			IDictionary<string, object> whereParameters,
			IOrderedDictionary orderByParameters,
			IDictionary<string, object> groupByParameters,
			IDictionary<string, object> orderGroupsByParameters,
			IDictionary<string, object> selectParameters)
		{
			// all nullable.
			Arguments = arguments;
			WhereParameters = whereParameters;
			OrderByParameters = orderByParameters;
			GroupByParameters = groupByParameters;
			OrderGroupsByParameters = orderGroupsByParameters;
			SelectParameters = selectParameters;
		}

        protected override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments)
        {
            var loadedEntities =  base.ExecuteSelect(arguments);

            if (!this._dataSource.GenerateEmptyRowOnTop)
            {
                return loadedEntities;
            }

            if (arguments.MaximumRows > 0)
            {
                throw new InvalidOperationException("GenerateEmptyRowOnTop is not supported together with paging!");
            }

            return Yield(Activator.CreateInstance(this.EntityType), loadedEntities);
        }

		private object[] GetParametersForSelect(DataSourceSelectArguments arguments)
		{
			var parameters = new List<object>();
			foreach (DictionaryEntry entry in SelectParameters.GetValues(HttpContext.Current, owner))
			{
				parameters.Add(entry.Value);
			}
			if (CanPage)
			{
				parameters.Add(arguments.MaximumRows);
				parameters.Add(arguments.StartRowIndex);
			}
			if ((!string.IsNullOrEmpty(arguments.SortExpression)) && (!InternalSort))
			{
				parameters.Add(arguments.SortExpression);
			}
			return parameters.ToArray();
		}

        /// <devdoc>
        /// Returns all the rows of the datasource.
        /// </devdoc>
        protected internal override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments) {
            arguments.RaiseUnsupportedCapabilitiesError(this);


            XmlNode root = _owner.GetXmlDocument();

            XmlNodeList nodes = null;
            if (_owner.XPath.Length != 0) {
                // If an XPath is specified on the control, use it
                nodes = root.SelectNodes(_owner.XPath);
            }
            else {
                // Otherwise, get all the children of the root
                nodes = root.SelectNodes("/node()/node()");
            }

            return new XmlDataSourceNodeDescriptorEnumeration(nodes);
        }