//Activate This Construntor to log All To Standard output
	//public TestClass():base(true){}

	//Activate this constructor to log Failures to a log file
	//public TestClass(System.IO.TextWriter tw):base(tw, false){}


	//Activate this constructor to log All to a log file
	//public TestClass(System.IO.TextWriter tw):base(tw, true){}

	//BY DEFAULT LOGGING IS DONE TO THE STANDARD OUTPUT ONLY FOR FAILURES

	public void run()
	{
		Exception exp = null;
		DataSet ds = new DataSet();
		DataTable dtChild = GHTUtils.DataProvider.CreateChildDataTable();
		DataTable dtParent = GHTUtils.DataProvider.CreateParentDataTable();
		ds.Tables.Add(dtParent);
		ds.Tables.Add(dtChild);

		DataRelation dRel;
		dRel = new DataRelation(null,dtParent.Columns[0],dtChild.Columns[0]);
		ds.Relations.Add(dRel);
				
		try
		{
			BeginCase("Nested default ");
			Compare(dRel.Nested  , false);
		}
		catch(Exception ex)	{exp = ex;}
		finally	{EndCase(exp); exp = null;}


		dRel.Nested = true;

		try
		{
			BeginCase("Nested get/set");
			Compare(dRel.Nested ,true);
		}
		catch(Exception ex)	{exp = ex;}
		finally	{EndCase(exp); exp = null;}
	
	}

 private string ChildPropertyName(DataRelation relation, out bool usesAnnotations)
 {
     usesAnnotations = true;
     string str = (string) relation.ExtendedProperties["typedChildren"];
     if (!StringUtil.Empty(str))
     {
         return str;
     }
     string str2 = (string) relation.ChildTable.ExtendedProperties["typedPlural"];
     if (StringUtil.Empty(str2))
     {
         str2 = (string) relation.ChildTable.ExtendedProperties["typedName"];
         if (StringUtil.Empty(str2))
         {
             usesAnnotations = false;
             str = "Get" + relation.ChildTable.TableName + "Rows";
             if (1 < TablesConnectedness(relation.ParentTable, relation.ChildTable))
             {
                 str = str + "By" + relation.RelationName;
             }
             return NameHandler.FixIdName(str);
         }
         str2 = str2 + "Rows";
     }
     return ("Get" + str2);
 }

        private void Form1_Load(object sender, EventArgs e)
        {
            DbADOTest = new DataSet("DbADOTest");

            tblPeople = MakePeopleTable();
            tblSale = MakeSaleTable();
            DbADOTest.Tables.Add(tblPeople);
            DbADOTest.Tables.Add(tblSale);

            //* 관계 객체 생성
            RelBuy = new DataRelation("Buy",
                DbADOTest.Tables["tblPeople"].Columns["Name"],
                DbADOTest.Tables["tblSale"].Columns["Customer"]);
            DbADOTest.Relations.Add(RelBuy);
            //*/

            /* FK 직접 생성
            ForeignKeyConstraint fk = new ForeignKeyConstraint("Buy",
                DbADOTest.Tables["tblPeople"].Columns["Name"],
                DbADOTest.Tables["tblSale"].Columns["Customer"]);
            tblSale.Constraints.Add(fk);
            //*/

            /* 삭제 규칙 변경
            ForeignKeyConstraint fk= (ForeignKeyConstraint)tblSale.Constraints["Buy"];
            fk.DeleteRule = Rule.None;
            //*/

            dataGridView1.DataSource = DbADOTest.Tables["tblPeople"];
            dataGridView2.DataSource = DbADOTest.Tables["tblSale"];
        }

	//Activate This Construntor to log All To Standard output
	//public TestClass():base(true){}

	//Activate this constructor to log Failures to a log file
	//public TestClass(System.IO.TextWriter tw):base(tw, false){}


	//Activate this constructor to log All to a log file
	//public TestClass(System.IO.TextWriter tw):base(tw, true){}

	//BY DEFAULT LOGGING IS DONE TO THE STANDARD OUTPUT ONLY FOR FAILURES

	public void run()
	{

		Exception exp = null;
		DataSet ds = new DataSet();
		DataTable dtChild = GHTUtils.DataProvider.CreateChildDataTable();
		DataTable dtParent = GHTUtils.DataProvider.CreateParentDataTable();
		ds.Tables.Add(dtParent);
		ds.Tables.Add(dtChild);

		DataRelation dRel;
		dRel = new DataRelation("MyRelation",dtParent.Columns[0],dtChild.Columns[0]);
		ds.Relations.Add(dRel);

		PropertyCollection pc;
		pc = dRel.ExtendedProperties ;
        
		try
		{
			base.BeginCase("Checking ExtendedProperties default ");
			base.Compare(pc != null,true);
		}
		catch(Exception ex)	{exp = ex;}
		finally	{EndCase(exp); exp = null;}
		

		try
		{
			base.BeginCase("Checking ExtendedProperties count ");
			base.Compare(pc.Count ,0);
		}
		catch(Exception ex)	{exp = ex;}
		finally	{EndCase(exp); exp = null;}
	}

 public void Add(DataRelation relation)
 {
     IntPtr ptr;
     Bid.ScopeEnter(out ptr, "<ds.DataRelationCollection.Add|API> %d#, relation=%d\n", this.ObjectID, (relation != null) ? relation.ObjectID : 0);
     try
     {
         if (this.inTransition != relation)
         {
             this.inTransition = relation;
             try
             {
                 this.OnCollectionChanging(new CollectionChangeEventArgs(CollectionChangeAction.Add, relation));
                 this.AddCore(relation);
                 this.OnCollectionChanged(new CollectionChangeEventArgs(CollectionChangeAction.Add, relation));
             }
             finally
             {
                 this.inTransition = null;
             }
         }
     }
     finally
     {
         Bid.ScopeLeave(ref ptr);
     }
 }

        private void relacionCursoAsignatura()
        {
            bindingSourceCurso = new BindingSource();
            bindingSourceAsignatura = new BindingSource();
            bindingSourceRelacionCursoAsignatura = new BindingSource();
            bindingSourceRelacionAsignaturaNota = new BindingSource();

            bindingSourceCurso.DataSource = dataset1.Tables["Cursos"];
            bindingSourceAsignatura.DataSource = dataset1.Tables["Asignaturas"];

            ColCurso = dataset1.Tables["Cursos"].Columns["COD_CUR"];
            ColAsignaturaCUR = dataset1.Tables["Asignaturas"].Columns["COD_CUR"];
            ColAsignaturaASI = dataset1.Tables["Asignaturas"].Columns["COD_ASI"];
            ColNota = dataset1.Tables["Notas"].Columns["COD_ASI"];

            RelacionCursoAsignatura = new DataRelation("RelCursoAsignatura", ColCurso, ColAsignaturaCUR);
            RelacionAsignaturaNota = new DataRelation("RelAsignaturaNota", ColAsignaturaASI, ColNota);

            dataset1.Relations.Clear();
            dataset1.Relations.Add(RelacionCursoAsignatura);
            dataset1.Relations.Add(RelacionAsignaturaNota);

            bindingSourceRelacionCursoAsignatura.DataSource = bindingSourceCurso;
            bindingSourceRelacionCursoAsignatura.DataMember = "RelCursoAsignatura";

            bindingSourceRelacionAsignaturaNota.DataSource = bindingSourceRelacionCursoAsignatura;
            bindingSourceRelacionAsignaturaNota.DataMember = "RelAsignaturaNota";
        }

        protected void Page_Load(object sender, EventArgs e)
        {
            DataSet ds = new DataSet();
            string connStr = @"Data Source=Talha-PC\SQLExpress;Initial Catalog=LocalTestDB;User Id=talha;Password=talha123;Trusted_Connection=True;";
            using (SqlConnection conn = new SqlConnection(connStr))
            {
                string sql = "Select MenuID, Text,Description, ParentID from Menu";
                SqlDataAdapter da = new SqlDataAdapter(sql, conn);
                da.Fill(ds);
                da.Dispose();
            }
            ds.DataSetName = "Menus";
            ds.Tables[0].TableName = "Menu";
            DataRelation relation = new DataRelation("ParentChild",
             ds.Tables["Menu"].Columns["MenuID"],
             ds.Tables["Menu"].Columns["ParentID"], true);

            relation.Nested = true;
            ds.Relations.Add(relation);

            XmlDataSource1.Data = ds.GetXml();

            if (Request.Params["Sel"] != null)
                Page.Controls.Add(new System.Web.UI.LiteralControl("You selected " + Request.Params["Sel"]));
        }

        private void relacionCursoAlumnos()
        {
            //bindingSourceAsignatura = new BindingSource();
            bindingSourceAlumno = new BindingSource();

            bindingSourceRelacionCursoAlumno = new BindingSource();
            bindingSourceRelacionAlumnoNota = new BindingSource();
            bindingSourceAlumno.DataSource = dataset1.Tables["Alumnos"];

            ColAlumnoCUR = dataset1.Tables["Alumnos"].Columns["COD_CUR"];
            ColAlumnoALU = dataset1.Tables["Alumnos"].Columns["COD_ALU"];
            ColNota = dataset1.Tables["Notas"].Columns["COD_ALU"];

            RelacionCursoAlumno = new DataRelation("RelCursoAlumno", ColCurso, ColAlumnoCUR);
            RelacionAlumnoNota = new DataRelation("RelAlumnoNota", ColAlumnoALU, ColNota);

            dataset1.Relations.Add(RelacionCursoAlumno);
            dataset1.Relations.Add(RelacionAlumnoNota);

            bindingSourceRelacionCursoAlumno.DataSource = bindingSourceCurso;
            bindingSourceRelacionCursoAlumno.DataMember = "RelCursoAlumno";

            bindingSourceRelacionAlumnoNota.DataSource = bindingSourceRelacionCursoAlumno;
            bindingSourceRelacionAlumnoNota.DataMember = "RelAlumnoNota";
        }

		public void Add()
		{
			DataRelationCollection drcol = _dataset.Relations;
			DataColumn parentCol = _dataset.Tables["Customer"].Columns["custid"];
			DataColumn childCol = _dataset.Tables["Order"].Columns["custid"];
			DataRelation dr = new DataRelation("CustOrder",parentCol,childCol);
			
			drcol.Add(dr);
			AssertEquals("test#1","CustOrder",drcol[0].RelationName);
			drcol.Clear();
			
			drcol.Add(parentCol,childCol);
			AssertEquals("test#2",1,drcol.Count);
			drcol.Clear();
			
			drcol.Add("NewRelation",parentCol,childCol);
			AssertEquals("test#3","NewRelation",drcol[0].RelationName);
			drcol.Clear();
			
			drcol.Add("NewRelation",parentCol,childCol,false);
			AssertEquals("test#4",1,drcol.Count);
			drcol.Clear();
			
			drcol.Add("NewRelation",parentCol,childCol,true);
			AssertEquals("test#5",1,drcol.Count);
			drcol.Clear();
		}

        private void Load_catesearch()
        {
            var list = per.Load_danhmuc_search(1);
            if (list.Count > 0)
            {
                DataRelation relCat;
                DataTable tbl = DataUtil.LINQToDataTable(list);
                DataSet ds = new DataSet();
                ds.Tables.Add(tbl);

                tbl.PrimaryKey = new DataColumn[] { tbl.Columns["CAT_ID"] };
                relCat = new DataRelation("Category_parent", ds.Tables[0].Columns["CAT_ID"], ds.Tables[0].Columns["CAT_PARENT_ID"], false);

                ds.Relations.Add(relCat);
                DataSet dsCat = ds.Clone();
                DataTable CatTable = ds.Tables[0];

                DataUtil.TransformTableWithSpace(ref CatTable, dsCat.Tables[0], relCat, null);

                Drcate_search.DataSource = dsCat.Tables[0];
                Drcate_search.DataTextField = "CAT_NAME";
                Drcate_search.DataValueField = "CAT_ID";
                Drcate_search.DataBind();
            }
            ListItem l = new ListItem("Tất cả", "0");
            l.Selected = true;
            Drcate_search.Items.Insert(0, l);
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            connectionString = "Data Source=(local);Initial Catalog=Exam-UserRuns;Integrated Security=SSPI;";
            dbConn = new SqlConnection(connectionString);

            usersDA = new SqlDataAdapter("select * from Users", dbConn);
            runsDA = new SqlDataAdapter("select * from Runs", dbConn);

            runsCB = new SqlCommandBuilder(runsDA);

            dataSet = new DataSet();
            usersDA.Fill(dataSet, "Users");
            runsDA.Fill(dataSet, "Runs");

            dataRelation = new DataRelation("User_Runs", dataSet.Tables["Users"].Columns["userID"], dataSet.Tables["Runs"].Columns["userID"]);
            dataSet.Relations.Add(dataRelation);

            usersBS = new BindingSource();
            runsBS = new BindingSource();

            usersBS.DataSource = dataSet;
            usersBS.DataMember = "Users";

            runsBS.DataSource = usersBS;
            runsBS.DataMember = "User_Runs";

            usersComboBox.DataSource = usersBS;
            usersComboBox.DisplayMember = "userName";

            runsDataGridView.DataSource = runsBS;
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            SqlConnection con = new SqlConnection(@"Data Source=.\SQLEXPRESS;AttachDbFilename=|DataDirectory|\Database1.mdf;Integrated Security=True;User Instance=True");
            con.Open();
            SqlCommand comm = new SqlCommand("select * from UserData",con);

            DataTable master = new DataTable();
            DataTable child = new DataTable();

            // Fill Table 2 with Data
            SqlDataAdapter da = new SqlDataAdapter(comm);
            da.Fill(master);

               // Fill Table1 with data
            comm = new SqlCommand("select * from UserDetail",con);
            da.Fill(child);

            con.Close();

            DataSet ds = new DataSet();

            //Add two DataTables  in Dataset
            ds.Tables.Add(master);
            ds.Tables.Add(child);

            // Create a Relation in Memory
            DataRelation relation = new DataRelation("",ds.Tables[0].Columns[0],ds.Tables[1].Columns[0],true);
            ds.Relations.Add(relation);
            dataGrid1.DataSource = ds.Tables[0];
        }

	//Activate This Construntor to log All To Standard output
	//public TestClass():base(true){}

	//Activate this constructor to log Failures to a log file
	//public TestClass(System.IO.TextWriter tw):base(tw, false){}


	//Activate this constructor to log All to a log file
	//public TestClass(System.IO.TextWriter tw):base(tw, true){}

	//BY DEFAULT LOGGING IS DONE TO THE STANDARD OUTPUT ONLY FOR FAILURES

	public void run()
	{
		Exception exp = null;
		DataSet ds = new DataSet();
		DataTable dtChild = GHTUtils.DataProvider.CreateChildDataTable();
		DataTable dtParent = GHTUtils.DataProvider.CreateParentDataTable();
		ds.Tables.Add(dtParent);
		ds.Tables.Add(dtChild);

		DataRelation dRel;
		dRel = new DataRelation("MyRelation",dtParent.Columns[0],dtChild.Columns[0]);
		ds.Relations.Add(dRel);
		
		try
		{
			BeginCase("ParentColumns 1");
			Compare(dRel.ParentColumns.Length , 1 );
		}
		catch(Exception ex)	{exp = ex;}
		finally	{EndCase(exp); exp = null;}

		try
		{
			BeginCase("ParentColumns 2");
			Compare(dRel.ParentColumns[0] , dtParent.Columns[0] );
		}
		catch(Exception ex)	{exp = ex;}
		finally	{EndCase(exp); exp = null;}
	}

		public void Add ()
		{
			DataRelationCollection drcol = _dataset.Relations;
			DataColumn parentCol = _dataset.Tables ["Customer"].Columns ["custid"];
			DataColumn childCol = _dataset.Tables ["Order"].Columns ["custid"];
			DataRelation dr = new DataRelation ("CustOrder", parentCol, childCol);
			
			drcol.Add (dr);
			Assert.That (drcol [0].RelationName, Is.EqualTo ("CustOrder"), "test#1");
			drcol.Clear ();
			
			drcol.Add (parentCol, childCol);
			Assert.That (drcol.Count, Is.EqualTo (1), "test#2");
			drcol.Clear ();
			
			drcol.Add ("NewRelation", parentCol, childCol);
			Assert.That (drcol [0].RelationName, Is.EqualTo ("NewRelation"), "test#3");
			drcol.Clear ();
			
			drcol.Add ("NewRelation", parentCol, childCol, false);
			Assert.That (drcol.Count, Is.EqualTo (1), "test#4");
			drcol.Clear ();
			
			drcol.Add ("NewRelation", parentCol, childCol, true);
			Assert.That (drcol.Count, Is.EqualTo (1), "test#5");
			drcol.Clear ();
		}

	//Activate This Construntor to log All To Standard output
	//public TestClass():base(true){}

	//Activate this constructor to log Failures to a log file
	//public TestClass(System.IO.TextWriter tw):base(tw, false){}


	//Activate this constructor to log All to a log file
	//public TestClass(System.IO.TextWriter tw):base(tw, true){}

	//BY DEFAULT LOGGING IS DONE TO THE STANDARD OUTPUT ONLY FOR FAILURES

	public void run()
	{
		Exception exp = null;
		DataTable dt1 = GHTUtils.DataProvider.CreateParentDataTable();
		DataTable dt2 = GHTUtils.DataProvider.CreateChildDataTable();
		dt1.PrimaryKey  = new DataColumn[] {dt1.Columns[0]};
		dt2.PrimaryKey  = new DataColumn[] {dt2.Columns[0],dt2.Columns[1]};
		DataRelation rel = new DataRelation("Rel",dt1.Columns["ParentId"],dt2.Columns["ParentId"]);
		DataSet ds = new DataSet();
		ds.Tables.AddRange(new DataTable[] {dt1,dt2});
		ds.Relations.Add(rel);
		
		ds.Reset();

		try
		{
			BeginCase("Reset - Relations");
			Compare(ds.Relations.Count  ,0 );
		}
		catch(Exception ex)	{exp = ex;}
		finally	{EndCase(exp); exp = null;}
		try
		{
			BeginCase("Reset - Tables");
			Compare(ds.Tables.Count  ,0 );
		}
		catch(Exception ex)	{exp = ex;}
		finally	{EndCase(exp); exp = null;}
		
	}

 private void Init(InfoBindingSource aBindingSource, DataRelation Relation)
 {
     DataRelation R1;
     lbDetail.Items.Clear();
     if (aBindingSource.DataSource.GetType().Equals(typeof(InfoDataSet)))
     {
         InfoDataSet set1 = (InfoDataSet)aBindingSource.DataSource;
         for (int I = 0; I < set1.RealDataSet.Tables[0].ChildRelations.Count; I++)
         {
             R1 = set1.RealDataSet.Tables[0].ChildRelations[I];
             lbDetail.Items.Add(R1.ChildTable.TableName);
             FDetailList.AddObject(R1.ChildTable.TableName, R1);
         }
     }
     if (aBindingSource.DataSource.GetType().Equals(typeof(InfoBindingSource)))
     {
         while (!aBindingSource.DataSource.GetType().Equals(typeof(InfoDataSet)))
         {
             aBindingSource = (InfoBindingSource)aBindingSource.DataSource;
         }
         InfoDataSet set2 = (InfoDataSet)aBindingSource.DataSource;
         for (int num2 = 0; num2 < set2.RealDataSet.Tables.Count; num2++)
         {
             if (set2.RealDataSet.Tables[num2].TableName.Equals(Relation.ChildTable.TableName))
             {
                 for (int num3 = 0; num3 < set2.RealDataSet.Tables[num2].ChildRelations.Count; num3++)
                 {
                     R1 = set2.RealDataSet.Tables[num2].ChildRelations[num3];
                     lbDetail.Items.Add(R1.ChildTable.TableName);
                     FDetailList.AddObject(R1.ChildTable.TableName, R1);
                 }
             }
         }
     }
 }

        private void Form1_Load(object sender, EventArgs e)
        {
            connectionString = "Data Source=(local);Initial Catalog=Practice-TrackingSystem;Integrated Security=SSPI;";
            dbConn = new SqlConnection(connectionString);

            projectsDA = new SqlDataAdapter("SELECT * FROM Project", dbConn);
            tasksDA = new SqlDataAdapter("SELECT * FROM Task", dbConn);

            tasksCB = new SqlCommandBuilder(tasksDA);

            dataSet = new DataSet();
            projectsDA.Fill(dataSet, "Project");
            tasksDA.Fill(dataSet, "Task");

            dataRelation = new DataRelation("Project_Tasks", dataSet.Tables["Project"].Columns["ProjID"],
                                                            dataSet.Tables["Task"].Columns["ProjID"]);
            dataSet.Relations.Add(dataRelation);

            projectsBS = new BindingSource();
            tasksBS = new BindingSource();

            projectsBS.DataSource = dataSet;
            projectsBS.DataMember = "Project";

            tasksBS.DataSource = projectsBS;
            tasksBS.DataMember = "Project_Tasks";

            projectsComboBox.DataSource = projectsBS;
            projectsComboBox.DisplayMember = "ProjName";

            tasksDataGridView.DataSource = tasksBS;
        }

	protected void Page_Load(object sender, System.EventArgs e)
	{
		// Create the Connection, DataAdapter, and DataSet.
		string connectionString = "Data Source=localhost;Initial Catalog=Northwind;" +
			"Integrated Security=SSPI";
		SqlConnection con = new SqlConnection(connectionString);

		string sqlCat = "SELECT CategoryID, CategoryName FROM Categories";
		string sqlProd = "SELECT ProductName, CategoryID FROM Products";

		SqlDataAdapter da = new SqlDataAdapter(sqlCat, con);
		DataSet ds = new DataSet();

		try
		{
			con.Open();

			// Fill the DataSet with the Categories table.
			da.Fill(ds, "Categories");

			// Change the command text and retrieve the Products table.
			// You could also use another DataAdapter object for this task.
			da.SelectCommand.CommandText = sqlProd;
			da.Fill(ds, "Products");
		}
		finally
		{
			con.Close();
		}

		// Define the relationship between Categories and Products.
		DataRelation relat = new DataRelation("CatProds",
			ds.Tables["Categories"].Columns["CategoryID"],
			ds.Tables["Products"].Columns["CategoryID"]);
		// Add the relationship to the DataSet.
		ds.Relations.Add(relat);

		// Loop through the category records and build the HTML string.
		StringBuilder htmlStr = new StringBuilder("");
		foreach (DataRow row in ds.Tables["Categories"].Rows)
		{
			htmlStr.Append("<b>");
			htmlStr.Append(row["CategoryName"].ToString());
			htmlStr.Append("</b><ul>");

			// Get the children (products) for this parent (category).
			DataRow[] childRows = row.GetChildRows(relat);
			// Loop through all the products in this category.
			foreach (DataRow childRow in childRows)
			{
				htmlStr.Append("<li>");
				htmlStr.Append(childRow["ProductName"].ToString());
				htmlStr.Append("</li>");
			}
			htmlStr.Append("</ul>");
		}

		// Show the generated HTML code.
		HtmlContent.Text = htmlStr.ToString();
	}

        /// <summary>
        /// Adds the relation to the collection.
        /// </summary>
        public void Add(DataRelation relation)
        {
            long logScopeId = DataCommonEventSource.Log.EnterScope("<ds.DataRelationCollection.Add|API> {0}, relation={1}", ObjectID, (relation != null) ? relation.ObjectID : 0);
            try
            {
                if (_inTransition == relation)
                {
                    return;
                }

                _inTransition = relation;
                try
                {
                    OnCollectionChanging(new CollectionChangeEventArgs(CollectionChangeAction.Add, relation));
                    AddCore(relation);
                    OnCollectionChanged(new CollectionChangeEventArgs(CollectionChangeAction.Add, relation));
                }
                finally
                {
                    _inTransition = null;
                }
            }
            finally
            {
                DataCommonEventSource.Log.ExitScope(logScopeId);
            }
        }

    protected void Button1_Click(object sender, EventArgs e)
    {
        SqlConnection con = new SqlConnection(WebConfigurationManager.ConnectionStrings["Nash"].ConnectionString);
        SqlCommand cmd = new SqlCommand("select * from Categories", con);
        SqlCommand cmd1 = new SqlCommand("select * from Products", con);
        SqlDataAdapter adapter = new SqlDataAdapter();
        adapter.SelectCommand = cmd;
        DataSet dataSet = new DataSet();
        con.Open();
        adapter.Fill(dataSet, "Categories");
        adapter.SelectCommand = cmd1;
        adapter.Fill(dataSet, "Products");
        con.Close();
        DataRelation relation = new DataRelation("primary", dataSet.Tables["Categories"].Columns["CategoryID"], dataSet.Tables["Products"].Columns["CategoryID"]);
        dataSet.Relations.Add(relation);

        DataColumn column1 = new DataColumn("no. of products", typeof(int), "Count(Child(primary).CategoryID)");
        dataSet.Tables["Categories"].Columns.Add(column1);
        GridView1.DataSource = dataSet;
        GridView1.DataBind();

        //DataView view = new DataView(dataSet.Tables["Categories"]);
        //view.RowFilter = "Count(Child(primary).CategoryID) > 1";

        //GridView1.DataSource = view;    
        //GridView1.DataBind();

        //GridView1.DataSource = dataSet;
        //GridView1.DataMember = "Categories";
        //GridView1.DataBind();
    }