Virtual scrolling in Angular Pivot Table component

19 Mar 202420 minutes to read

Virtual Scrolling

The virtual scrolling option allows you to load the large amounts of data without performance degradation by rendering rows and columns only in the content viewport. The data will refresh dynamically on vertical or horizontal scroll. This feature can be enabled by setting the enableVirtualization property to true.

To use the virtual scrolling feature, inject the VirtualScroll module in to the pivot table.

app.component.ts
app.module.ts
main.ts
import { Component, OnInit } from '@angular/core';
import { IDataOptions, IDataSet, PivotView, VirtualScrollService } from '@syncfusion/ej2-angular-pivotview';
import { Pivot_Data } from './datasource';

@Component({
  selector: 'app-container',
  providers: [VirtualScrollService],
  // specifies the template string for the pivot table component
  template: `<ejs-pivotview #pivotview id='PivotView' [dataSourceSettings]=dataSourceSettings enableVirtualization='true' height='350'></ejs-pivotview>`
})

export class AppComponent implements OnInit  {
public dataSourceSettings?: IDataOptions;
public date1?: number;
public date2?: number;
data(count: number) {
  let result: Object[] = [];
  let dt: number = 0;
  for (let i: number = 1; i < count + 1; i++) {
    dt++;
    let round: string;
    let toString: string = i.toString();
    if (toString.length === 1) {
      round = "0000" + i;
    } else if (toString.length === 2) {
      round = "000" + i;
    } else if (toString.length === 3) {
      round = "00" + i;
    } else if (toString.length === 4) {
      round = "0" + i;
    } else {
      round = toString;
    }
    result.push({
      ProductID: "PRO-" + round,
      Year: "FY " + (dt + 2013),
      Price: Math.round(Math.random() * 5000) + 5000,
      Sold: Math.round(Math.random() * 80) + 10
    });
    if (dt / 4 == 1) {
        dt = 0;
    }
  }
  return result;
}
    ngOnInit(): void {
        this.dataSourceSettings = {
        dataSource: this.data(1000) as IDataSet[],
        enableSorting: false,
        expandAll: true,
        formatSettings: [{ name: 'Price', format: 'C0' }],
        rows: [{ name: 'ProductID' }],
        columns: [{ name: 'Year' }],
        values: [{ name: 'Price', caption: 'Unit Price' }, { name: 'Sold', caption: 'Unit Sold' }]
        };
    }
}
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { PivotViewAllModule, PivotFieldListAllModule } from '@syncfusion/ej2-angular-pivotview';
import { AppComponent } from './app.component';

/**
 * Module
 */
@NgModule({
    imports: [
        BrowserModule,
        PivotViewAllModule,
        PivotFieldListAllModule
    ],
    declarations: [AppComponent],
    bootstrap: [AppComponent]
})
export class AppModule { }
import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
import { enableProdMode } from '@angular/core';
import { AppModule } from './app.module';

import 'zone.js';
enableProdMode();
platformBrowserDynamic().bootstrapModule(AppModule);

Virtual scrolling with single page mode

When virtual scrolling is enabled, the pivot table renders not only the current view page, but also the previous and next pages by default. This default behavior, however, can cause performance delays when dealing with a large number of rows and columns. This is because the same number of rows and columns from adjacent pages are also processed, resulting in additional computational load. This performance constraint can be avoided by setting the allowSinglePage property to true within the virtualScrollSettings.

Enabling this property causes the pivot table to render only the rows and columns that are relevant to the current view page during virtual scrolling. This optimization significantly improves the performance of the pivot table during initial rendering and when performing UI actions such as drill up/down, sorting, filtering, and more.

app.component.ts
app.module.ts
main.ts
import { Component, OnInit } from '@angular/core';
import { IDataOptions, IDataSet, VirtualScrollService, VirtualScrollSettingsModel } from '@syncfusion/ej2-angular-pivotview';

@Component({
  selector: 'app-container',
  providers: [VirtualScrollService],
  template: `<ejs-pivotview #pivotview id='PivotView' width='100%' height='350'
    [dataSourceSettings]='dataSourceSettings' enableVirtualization='true' [virtualScrollSettings]='virtualScrollSettings'>
  </ejs-pivotview>`
})

export class AppComponent implements OnInit  {
  public dataSourceSettings?: IDataOptions;
  public virtualScrollSettings?: VirtualScrollSettingsModel;

  data(count: number) {
    let result: Object[] = [];
    let dt: number = 0;
    for (let i: number = 1; i < count + 1; i++) {
      dt++;
      let round: string;
      let toString: string = i.toString();
      if (toString.length === 1) {
        round = "0000" + i;
      } else if (toString.length === 2) {
        round = "000" + i;
      } else if (toString.length === 3) {
        round = "00" + i;
      } else if (toString.length === 4) {
        round = "0" + i;
      } else {
        round = toString;
      }
      result.push({
        ProductID: "PRO-" + round,
        Year: "FY " + (dt + 2013),
        Sold: Math.round(Math.random() * 80) + 10
      });
      if (dt / 4 == 1) {
        dt = 0;
      }
    }
    return result;
  }

  ngOnInit(): void {
    this.virtualScrollSettings = {
      allowSinglePage: true
    } as VirtualScrollSettingsModel;

    this.dataSourceSettings = {
      dataSource: this.data(1000) as IDataSet[],
      enableSorting: false,
      expandAll: true,
      formatSettings: [{ name: 'Price', format: 'C0' }],
      rows: [{ name: 'ProductID' }],
      columns: [{ name: 'Year' }],
      values: [{ name: 'Price', caption: 'Unit Price' },
        { name: 'Sold', caption: 'Unit Sold' }
      ]
    };
  }
}
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { PivotViewAllModule } from '@syncfusion/ej2-angular-pivotview';
import { AppComponent } from './app.component';

/**
 * Module
 */
@NgModule({
    imports: [
        BrowserModule,
        PivotViewAllModule
    ],
    declarations: [AppComponent],
    bootstrap: [AppComponent]
})
export class AppModule { }
import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
import { enableProdMode } from '@angular/core';
import { AppModule } from './app.module';

import 'zone.js';
enableProdMode();
platformBrowserDynamic().bootstrapModule(AppModule);

Limitations for virtual scrolling

In virtual scrolling, the columnWidth property in gridSettings should be in pixels, and percentage values are not accepted.
Resizing columns or setting width to individual columns affects the calculation used to pick the correct page on scrolling.
Grouping, which takes additional time to splitting the raw items into the provided format.
Date Formatting, which takes additional time to convert date format.
Date Formatting with sorting, here additionally full date time format should be framed to perform sorting along with the provided date format which lags the performance.
When using OLAP data, subtotals and grand totals are only displayed when measures are bound at the last position in the rows or columns axis. Otherwise, the data from the pivot table will be shown without summary totals.
Even if virtual scrolling is enabled, not only is the current view port data retrieved, but also the data for the immediate previous page and the immediate next page. As a result, when the end user scrolls slightly ahead or behind, the next or previous page data is displayed immediately without requiring a refresh. Note: If the pivot table’s width and height are large, the loading data count in the current, previous, and next viewports (pages) will also increase, affecting performance.

Virtual scrolling for static field list

Virtual scrolling automatically works with “Popup” field list on setting the enableVirtualization property in the Pivot Table to true. Incase of static field list, which act as a separate component, user need to enable enableVirtualization property in the Pivot Table and also pass the report information to pivot table instance via the load event of the field list.

app.component.ts
app.module.ts
main.ts
import { Component, ViewChild } from '@angular/core';
import { PivotFieldListComponent, PivotViewComponent, FieldListService, IDataOptions, IDataSet,
    EnginePopulatedEventArgs, VirtualScrollService, PivotView } from '@syncfusion/ej2-angular-pivotview';
import { Browser, setStyleAttribute, prepend } from '@syncfusion/ej2-base';

@Component({
  selector: 'app-container',
  providers: [FieldListService, VirtualScrollService],
  styleUrls: ['./app.component.css'],
  template: `<ejs-pivotfieldlist #pivotfieldlist id='PivotFieldList' [dataSourceSettings]=dataSourceSettings renderMode="Fixed" (enginePopulated)='afterPopulate($event)' allowCalculatedField='true' (load)='onLoad()' (dataBound)='ondataBound()'></ejs-pivotfieldlist>
  <ejs-pivotview #pivotview id='PivotViewFieldList' width='99%' height='530' enableVirtualization='true '(enginePopulated)='afterEnginePopulate($event)'></ejs-pivotview>`
})

export class AppComponent {
    public dataSourceSettings?: IDataOptions;
    data(count: number) {
      let result: Object[] = [];
      let dt: number = 0;
      for (let i: number = 1; i < count + 1; i++) {
        dt++;
        let round: string;
        let toString: string = i.toString();
        if (toString.length === 1) {
          round = "0000" + i;
        } else if (toString.length === 2) {
          round = "000" + i;
        } else if (toString.length === 3) {
          round = "00" + i;
        } else if (toString.length === 4) {
          round = "0" + i;
        } else {
          round = toString;
        }
        result.push({
          ProductID: "PRO-" + round,
          Year: "FY " + (dt + 2013),
          Price: Math.round(Math.random() * 5000) + 5000,
          Sold: Math.round(Math.random() * 80) + 10
        });
        if (dt / 4 == 1) {
          dt = 0;
        }
      }
      return result;
    }

    @ViewChild('pivotview', {static: false})
    public pivotObj?: PivotViewComponent;

    @ViewChild('pivotfieldlist')
    public fieldListObj?: PivotFieldListComponent;

    afterPopulate(arge: EnginePopulatedEventArgs): void {
      if (this.fieldListObj && this.pivotObj) {
          this.fieldListObj.updateView(this.pivotObj);
      }
    }
    afterEnginePopulate(args: EnginePopulatedEventArgs): void {
      if (this.fieldListObj && this.pivotObj) {
          this.fieldListObj.update(this.pivotObj);
      }
    }
    onLoad(): void {
      if (Browser.isDevice) {
        (this.fieldListObj as PivotFieldListComponent).renderMode = 'Popup';
          (this.fieldListObj as PivotFieldListComponent).target = '.control-section';
          (document.getElementById('PivotFieldList') as HTMLElement).removeAttribute('style');
          setStyleAttribute(document.getElementById('PivotFieldList') as HTMLElement, {
              'height': 0,
              'float': 'left'
          });
      }
      (this.fieldListObj as PivotFieldListComponent).pivotGridModule = this.pivotObj as PivotViewComponent;
      //Assigning report to pivot table component
      (this.pivotObj as PivotViewComponent).dataSourceSettings = (this.fieldListObj as PivotFieldListComponent).dataSourceSettings;
      //Generating page settings based on pivot table component’s size.
      (this.pivotObj as PivotViewComponent).updatePageSettings(true);
      //Assigning page settings to field list component.
      (this.fieldListObj as PivotFieldListComponent).pageSettings = (this.pivotObj as PivotViewComponent).pageSettings;
    }

    ondataBound(): void {
      if (Browser.isDevice) {
        prepend([document.getElementById('PivotFieldList') as HTMLElement], document.getElementById('PivotView') as HTMLElement);
      }
    }

    ngOnInit(): void {
      this.dataSourceSettings = {
          dataSource: this.data(1000) as IDataSet[],
          enableSorting: false,
          expandAll: true,
          formatSettings: [{ name: 'Price', format: 'C0' }],
          rows: [{ name: 'ProductID' }],
          columns: [{ name: 'Year' }],
          values: [{ name: 'Price', caption: 'Unit Price' }, { name: 'Sold', caption: 'Unit Sold' }]
      };
    }
 }
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { PivotViewAllModule, PivotFieldListAllModule } from '@syncfusion/ej2-angular-pivotview';
import { AppComponent } from './app.component';

/**
 * Module
 */
@NgModule({
    imports: [
        BrowserModule,
        PivotViewAllModule,
        PivotFieldListAllModule
    ],
    declarations: [AppComponent],
    bootstrap: [AppComponent]
})
export class AppModule { }
import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
import { enableProdMode } from '@angular/core';
import { AppModule } from './app.module';

import 'zone.js';
enableProdMode();
platformBrowserDynamic().bootstrapModule(AppModule);

Virtual scrolling in Angular Pivot Table component