Pivoting DataTable Simplified

Share on TwitterShare on TumblrSubmit to StumbleUponSave on DeliciousDigg This


Displaying data in tabular form is an essential part of any application nowadays. But sometimes you need to display a huge amount of data in terms of number of rows. It becomes very difficult to analyse if the number of rows is huge. In such cases, you may wish to summarize your data in the other formats like charts, graphs, groups, pivots, etc. This articles presents a simplified way to pivot your data with an appropriate aggregate function so that you can enhance your reports easily.

Below is a screenshot of pivoted data in a GridView:


How it Works

To simplify the scenario, I have divided the result table into three areas: RowField, DataField, and ColumnFields. Apart from the area, the Pivot class provides you the option to bind your data based on some aggregate functions. The various aggregate options available are:

  • Count: Returns the count of matching data
  • Sum: Returns the sum of matching data (to get the sum, the type of the DataField must be convertible to decimal type)
  • First: Returns the first occurrence of matching data
  • Last: Returns the last occurrence of matching data
  • Average: Returns the average of matching data (to get the average, the type of the DataField must be convertible to decimal type)
  • Max: Returns the maximum value from the matching data
  • Min: Returns the minimum value from the matching data
  • Exists: Returns “true” if there is any matching data, else “false

The code mainly contains a class named “Pivot” that takes the DataTable in the constructor. ColumnFields takes as a string array parameter which allows you to pivot data on more than one column. It contains a function called PivotData() which actually pivots your data.

Collapse | Copy Code
public DataTable PivotData(string RowField, string DataField, 
       AggregateFunction Aggregate, params string[] ColumnFields)
    DataTable dt = new DataTable();
    string Separator = ".";
    var RowList = (from x in _SourceTable.AsEnumerable() 
        select new { Name = x.Field<object>(RowField) }).Distinct();
    var ColList = (from x in _SourceTable.AsEnumerable() 
                   select new { Name = ColumnFields.Select(n => x.Field<object>(n))
                       .Aggregate((a, b) => a += Separator + b.ToString()) })
                       .OrderBy(m => m.Name);

    foreach (var col in ColList)

    foreach (var RowName in RowList)
        DataRow row = dt.NewRow();
        row[RowField] = RowName.Name.ToString();
        foreach (var col in ColList)
            string strFilter = RowField + " = '" + RowName.Name + "'";
            string[] strColValues = 
            for (int i = 0; i < ColumnFields.Length; i++)
                strFilter += " and " + ColumnFields[i] + 
                             " = '" + strColValues[i] + "'";
            row[col.Name.ToString()] = GetData(strFilter, DataField, Aggregate);
    return dt;

First of all, the function determines the number of rows by getting the distinct values in RowList, and the number of columns by getting the distinct values in ColList. Then, the columns are created. It then iterates through each row and gets the matching values to the corresponding cell based on the aggregate function provided. To retrieve the matching value, the GetData() function is called.

Collapse | Copy Code
private object GetData(string Filter, string DataField, AggregateFunction Aggregate)
        DataRow[] FilteredRows = _SourceTable.Select(Filter);
        object[] objList = 
         FilteredRows.Select(x => x.Field<object>(DataField)).ToArray();

        switch (Aggregate)
            case AggregateFunction.Average:
                return GetAverage(objList);
            case AggregateFunction.Count:
                return objList.Count();
            case AggregateFunction.Exists:
                return (objList.Count() == 0) ? "False" : "True";
            case AggregateFunction.First:
                return GetFirst(objList);
            case AggregateFunction.Last:
                return GetLast(objList);
            case AggregateFunction.Max:
                return GetMax(objList);
            case AggregateFunction.Min:
                return GetMin(objList);
            case AggregateFunction.Sum:
                return GetSum(objList);
                return null;
    catch (Exception ex)
        return "#Error";
    return null;

This function first filters out the matching RowField and ColumnFields data in the DataRow[] array and then applies the aggregate function on it.

Using the Code

Using the code is simple. Create an instance of the Pivot class and then call the PivotData method with the required parameters. The PivotData() method returns the DataTable which can directly be used as the DataSource of the GridView.

Collapse | Copy Code
DataTable dt = ExcelLayer.GetDataTable("_Data\\DataForPivot.xls", "Sheet1$");
Pivot pvt = new Pivot(dt);

grdPivot.DataSource = pvt.PivotData("Designation", "CTC", 
   AggregateFunction.Max, "Company", "Department", "Year");

The database used as a sample is an Excel sheet and is present in the “_Data” folder of the root folder of the sample application.

Merge GridView Header Cells

The MergeHeader function is created to merge the header cells to provide a simplified look.

Collapse | Copy Code
private void MergeHeader(GridView gv, GridViewRow row, int PivotLevel)
    for (int iCount = 1; iCount <= PivotLevel; iCount++)
        GridViewRow oGridViewRow = new GridViewRow(0, 0, 
          DataControlRowType.Header, DataControlRowState.Insert);
        var Header = (row.Cells.Cast<tablecell>()
            .Select(x => GetHeaderText(x.Text, iCount, PivotLevel)))
            .GroupBy(x => x);

        foreach (var v in Header)
            TableHeaderCell cell = new TableHeaderCell();
            cell.Text = v.Key.Substring(v.Key.LastIndexOf(_Separator) + 1);
            cell.ColumnSpan = v.Count();
        gv.Controls[0].Controls.AddAt(row.RowIndex, oGridViewRow);
    row.Visible = false;

The function creates a new row for each pivot level and merges accordingly. PivotLevel here is the number of columns on which the pivot is done.

Header gets all the column values in an array, groups the repeated values returned by the GetHeaderText() function, sets the ColumnSpan property of the newly created cell according to the number of repeated HeaderText, and then adds the cell to the GridViewRow. Finally, add the GridViewRow to the GridView.

The GetHeaderText() function returns the header text based on the PivotLevel.

For example, suppose a pivot is done on three ColumnFields, namely, Company, Department, and Year. The result header of the GridView will initially have a header like Company.Department.Year for a PivotLevel 1. GetHeaderText() will return Company. For a PivotLevel 2, GetHeaderText() will return Company.Department. For a PivotLevel 3, GetHeaderText() will return Company.Department.Year, and so on…

Below is the screenshot of the GridView containing the third level pivoted data: