In my case every time user clicks [+] to expand a row, VB.NET code calls an SQL Server Stored procedure to bring in child rows. I grew suspicious and fired up SQL Profiler. What I saw surprised me. Number of calls to the stored procedure increased the deeper in grid’s hierarchy I expanded the children. When I clicked [+] on the root level it resulted in 1 SP call. Clicking [+] on the child to expand grandchild – 2 calls. Expanding grandchild to see grand-grandchild rows – 3 calls, etc.

I went back to the VB.NET code that calls the SP, it’s the handler for RowIslandsPopulating event:

 Protected Sub xmyGrid_RowIslandsPopulating(ByVal sender As Object, _
ByVal e As ContainerRowCancelEventArgs) Handles xmyGrid.RowIslandsPopulating

   e.Cancel = True
   CreateRowIslands(e.Row)

End Sub

Where CreateRowIslands is a VB sub that calls SQL Server Stored procedure to create child grid. Setting a breakpoint here I confirmed my suspicions: RowIslandsPopulating event is called for rows that already have been expanded. E.g. if I expand grand-child to display grand-grand-child rows, the event will fire for root, child and grand-child – 3 times, in turn calling stored procedure 3 times.

How to avoid this? While comparing the multiple calls I realized that rows already expanded had their Expanded property set to True. And while we can prevent RowIslandsPopulating event from firing multiple times, we can at least tell it not to do anything if RowIslands are already populated. So, the very slight change:

 Protected Sub xmyGrid_RowIslandsPopulating(ByVal sender As Object, _
ByVal e As ContainerRowCancelEventArgs) Handles xmyGrid.RowIslandsPopulating

   e.Cancel = True
   If e.Row.Expanded = False CreateRowIslands(e.Row)

End Sub

Solves the issue.

You’re calling SQL Server stored procedure from your .NET code and it runs extremely slow. When you run same SP with exactly the same parameters (as captured by SQL Server Profiler) directly in SQL Server Management Studio, it runs very fast. What gives?

Chances are – that SP was executed before and query plan was cached for the specific parameters. To avoid this add WITH RECOMPILE option to your CREATE PROCEDURE or ALTER PROCEDURE statement. This will force SQL Server to create a new query plan every time SP runs, perhaps adding slight overhead, but creating an optimized path that will cover that overhead tenfold.

But there’re times when you need to make the relationship work even if those values are not unique. The solution is not to create constrain when creating the relationship. This can be done for example by passing FALSE as value for createConstrains parameter of Dataset.Relations.Add method:

oMyDataSet.Relations.Add("MyRel", _
oMyDataSet.Tables("TheParent").Columns("ParentColumn"), _
dtSet.Tables("TheChild").Columns("ChildColumn"), _
False)

Case in point: Manual Load on Demand. If you have hierarchical data structure, it allows you to retrieve only root level data and then when user clicks “Expand” arrow – get additional data on as needed basis:

This is achieved by handling RowIslandsPopulating grid’s event in which you can run a DB query based on parent row data, then manually create a ContainerGrid object bind it to the data and add it to parent row RowIslands collection:

Protected Sub myGrid_RowIslandsPopulating(ByVal sender As Object, ByVal e As ContainerRowCancelEventArgs) Handles myGrid_.RowIslandsPopulating

     e.Cancel = True

     Dim oData as SomeDataType = GetData()
     Dim oChildGrid As New ContainerGrid()

     e.Row.RowIslands.Add(oChildGrid)

     oChildGrid.DataKeyFields = "SOME_ID"
     oChildGrid.Level = e.Row.Level + 1
     oChildGrid.DataSource = oData
     oChildGrid.DataBind()

End Sub

For this approach to work top-level rows need to display “Expand” arrows that user can click. This is done by looping thru all top-level rows in grid’s PreRender event, setting each row’s IsEmptyParent property to true:

Protected Sub myGrid_PreRender(ByVal sender As Object, ByVal e As System.EventArgs) Handles myGrid.PreRender

    If myGrid.DataSource IsNot Nothing Then
        For Each oRow As ContainerGridRecord In myGrid.GridView.Rows
            Row.IsEmptyParent = True
        Next
    End If

End Sub

This should work, but unfortunately if your source for the root level grid is DataSet – it doesn’t.

The reason – WebHierarchicalDataGrid expects hierarchy in the data source and if DataSet has a single table and no relationship – the “Expand” arrows will never be rendered. So we have to fake it (Great minds think alike, I found this solution in the same time it was suggested by Infragistics support). Once your root DataSet is filled with data, add following code:

oMyDataSet.Tables.Add()
oMyDataSet.Tables(1).Columns.Add("MY_ID", GetType(Integer))
oMyDataSet.Relations.Add(oMyDataSet.Tables(0).Columns("MY_ID"), oMyDataSet.Tables(1).Columns("MY_ID"))

Just substituted “MY_ID” with some real column ID from your root table. The code will create fake relationship letting grid to render “Expand” arrows when running code from above in PreRender event.

Cannot find column My Column Name.

with stack trace starting from grid databinding and finishing in datatable’s sorting:

at System.Data.DataTable.ParseSortString(String sortString)
at System.Data.DataView.CheckSort(String sort)
at System.Data.DataView.set_Sort(String value)
at Infragistics.WebUI.UltraWebGrid.DBBinding.ProcessDataViewForFillRows(DataView dataView, RowsCollection rows)
at Infragistics.WebUI.UltraWebGrid.DBBinding.FillRows(UltraWebGrid grid, RowsCollection rows, IEnumerable datasource)
at Infragistics.WebUI.UltraWebGrid.DBBinding.BindList(IEnumerable datasource)
at Infragistics.WebUI.UltraWebGrid.DBBinding.DataBind(Object dataSource, String dataMember)
at Infragistics.WebUI.UltraWebGrid.UltraWebGrid.DataBind()

If the grid binds OK without sorting and grouping, but fails with either – most likely the culprit is one of the columns in data table. Sort expression passed to a DataView is a comma separated list of column names to sort by. So, if your column name has a comma in it e.g. “My Column Name, For Real” – this presents a problem, since DataView will try to sort by 2 non-existing columns “My Column Name” (hence the error above) and “For Real”.

One way to deal with the problem is replace the comma with comma-like character “¸” called Cedilla (keystroke Alt+0184). So if after data retrieval you insert a loop like this:

'dtData is a data table already populated with data
For Each oCol As DataColumn In dtData.Columns
    oCol.ColumnName = oCol.ColumnName.Replace(",", "¸")
Next

then the sorting will perform correctly and without errors, and comma-like appearance will be preserved in column name.

In this example data consist of static root column, region, site, type and state. And the data has clearly defined hierarchy (e.g. Region “India” has site “Bangalore”, site “Bangalore” has types “Application” and “Area”, type “Application” has states “N/A” and “Testing”).

To load this data into Infragistics UltraWebTree I put together a small procedure:

Sub PopulateNavigatorTree(ByVal i_dtTable As DataTable, ByVal i_aNodes As Nodes, ByVal i_iGroupNo As Integer, ByVal i_sFilter As String)

    Dim oNode As Node

    Dim aFilteredData = From row As DataRow In i_dtTable _
          Where row.Field(Of String)(i_iGroupNo - 1) = i_sFilter _
          Select row

    Dim aQuery = From row In aFilteredData _
          Select row.Field(Of String)(i_iGroupNo) Distinct

    For Each sGrName As String In aQuery
         oNode = i_aNodes.Add(sGrName)

         If i_iGroupNo < i_dtTable.Columns.Count - 1 Then
              PopulateNavigatorTree(aFilteredData.CopyToDataTable, oNode.Nodes, i_iGroupNo + 1, sGrName)
         End If

    Next

End Sub

As parameters it accepts DataTable with flat data, collection of tree nodes (initially empty), group number (or column number in the table) and field data as a filter. So using data example from above and data table named dtData and tree named xuwtTree the call to the function will be:

PopulateNavigatorTree(dtData, xuwtTree.Nodes, 1, "GR")

First LINQ query (Lines 5-7) selects only those DataRows from the DataTable that belong to hierarchy of one level above current (using input parameter as a filter). The second query (lines 9-10) selects distinct field names from the current level. Then the loop (Lines 12-19) iterates thru those names, adding them to tree node collection (Line 13). And if there’re more groups to process (table has more columns) function calls itself recursively (Lines 15-17), passing filtered data, created by LINQ query previously and now converted back to data table, child Nodes collection of newly created node (currently empty), column number incremented by 1 and current field data as filter. The result:

This approach assumes that there is on common root element (“GR” in this case) in the flat data and uses Infragistics UltraWebTree as target control, but it can easly be adapted to other scenarios and controls.

Function GroupBy(ByVal i_sGroupByColumn As String,  ByVal i_sAggregateColumn As String, ByVal i_dSourceTable As DataTable, i_iAggregateType as Integer) As DataTable

     dim aQuery = From row In i_dSourceTable Group By Group1 = row(i_sGroupByColumn) Into Group Select Group1,  Aggr = Choose(i_iAggregateType, Group.Min(Function(row) row(i_sAggregateColumn)), Group.Max(Function(row) row(i_sAggregateColumn)), Group.Sum(Function(row) row(i_sAggregateColumn)), Group.Avg(Function(row) row(i_sAggregateColumn)), Group.Count(Function(row) row(i_sAggregateColumn)))

    return aQuery.toDataTable

End Function

In this example VB.NET function Choose is used inside of a LINQ query’s Select Statement. If i_iAggregateType parameter is equal 1 – Minimum value, will be calculated, 2 – Maximum etc.

Function GroupBy(ByVal i_sGroupByColumn As String,  ByVal i_sAggregateColumn As String, ByVal i_dSourceTable As DataTable) As DataTable

     dim aQuery = From row In i_dSourceTable Group By Group1 = row(i_sGroupByColumn) Into Group Select Group1,  Aggr = Group.Count(Function(row) row(i_sAggregateColumn))

    return aQuery.toDataTable

End Function

The query at line 3 is a LINQ to DataSet query, so reference to System.Data.Linq has to be added to your project. The Group.Count aggregate can be replaced with Group.Max, Group.Min, Group.Sum or Group.Avg to perform respectful function.

There is one caveat though. If you need to return grouped result as a data table, a .toDataTable method needs to be used on query results. Unfortunately this method exists only if your query is of a type IEnumerable(of DataRow) in other words returns datarows. The query above returns anonymous type. So there is no ready-to-use .toDataTable method.

Fortunately the method can be added. Download following 2 code modules (borrowed from the code accompanied “LINQ in Action book):

ObjectShreder.vb
DataSetLinqOperators.vb

Add them to your project. Bingo! Your query of a type IEnumerable(of <anonymous type>) now has .toDataTable method.

Another possibility (if you don’t want to use some external 3-rd party code) is to build a table the standard way creating and filling table rows while looping thru query results.

Function GroupBy(ByVal i_sGroupByColumn As String, ByVal i_sAggregateColumn As String, ByVal i_dSourceTable As DataTable) As DataTable

        Dim dv As New DataView(i_dSourceTable)

        'getting distinct values for group column
        Dim dtGroup As DataTable = dv.ToTable(True, New String() {i_sGroupByColumn}) 

        'adding column for the row count
        dtGroup.Columns.Add("Count", GetType(Integer)) 

        'looping thru distinct values for the group, counting
        For Each dr As DataRow In dtGroup.Rows
            dr("Count") = i_dSourceTable.Compute("Count(" & i_sAggregateColumn & ")", i_sGroupByColumn & " = '" & dr(i_sGroupByColumn) & "'")
        Next        

        'returning grouped/counted result
        Return dtGroup
End Function

The function first gets distinct values for group-by column, by creating a data view from source data table and using DataView’s “ToTable” method. It then loops thru these distinct values performing aggregate function on the source table using DataTable’s “Compute” method – Count in this case, but it can easily be replaced with other aggregates.