diff --git a/app/gui/src/project-view/components/GraphEditor/GraphVisualization.vue b/app/gui/src/project-view/components/GraphEditor/GraphVisualization.vue
index d868d96b67f0..0362e051029c 100644
--- a/app/gui/src/project-view/components/GraphEditor/GraphVisualization.vue
+++ b/app/gui/src/project-view/components/GraphEditor/GraphVisualization.vue
@@ -61,6 +61,7 @@ const {
   setToolbarDefinition,
   visualizationDefinedToolbar,
   toolbarOverlay,
+  executeExpression,
 } = useVisualizationData({
   selectedVis: toRef(props, 'currentType'),
   dataSource: toRef(props, 'dataSource'),
@@ -190,6 +191,7 @@ const visParams = computed(() => {
     data: effectiveVisualizationData.value,
     size: contentElementSize.value,
     nodeType: props.typename,
+    executeExpression,
   }
 })
 </script>
diff --git a/app/gui/src/project-view/components/GraphEditor/GraphVisualization/visualizationData.ts b/app/gui/src/project-view/components/GraphEditor/GraphVisualization/visualizationData.ts
index 5df10df5dc10..7151e8ea9592 100644
--- a/app/gui/src/project-view/components/GraphEditor/GraphVisualization/visualizationData.ts
+++ b/app/gui/src/project-view/components/GraphEditor/GraphVisualization/visualizationData.ts
@@ -1,6 +1,8 @@
 import LoadingErrorVisualization from '@/components/visualizations/LoadingErrorVisualization.vue'
 import LoadingVisualization from '@/components/visualizations/LoadingVisualization.vue'
 import type { ToolbarItem } from '@/components/visualizations/toolbar'
+import { useGraphStore } from '@/stores/graph'
+import { NodeId } from '@/stores/graph/graphDatabase'
 import { useProjectStore } from '@/stores/project'
 import type { NodeVisualizationConfiguration } from '@/stores/project/executionContext'
 import {
@@ -56,6 +58,7 @@ export function useVisualizationData({
 
   const projectStore = useProjectStore()
   const visualizationStore = useVisualizationStore()
+  const graph = useGraphStore()
 
   // Flag used to prevent rendering the visualization with a stale preprocessor while the new preprocessor is being
   // prepared asynchronously.
@@ -92,6 +95,50 @@ export function useVisualizationData({
     },
   )
 
+  const executeExpression = async (
+    visulizationModule: string,
+    expressionString: string,
+    formatFunction:
+      | ((arg: any, tempModule: Ast.MutableModule) => Ast.Owned<Ast.MutableExpression>)
+      | null,
+    ...positionalArgumentsExpressions: any[]
+  ) => {
+    const dataSourceValue = toValue(dataSource)
+    if (dataSourceValue?.type !== 'node') return
+    const graphDb = graph.db
+    const nodeFirstOurputPort = graphDb.getNodeFirstOutputPort(dataSourceValue.nodeId as NodeId)
+    const identifier = graphDb.getOutputPortIdentifier(nodeFirstOurputPort)
+    if (identifier === undefined) return
+    const contextId =
+      dataSourceValue.nodeId &&
+      graphDb.nodeIdToNode.get(dataSourceValue.nodeId as NodeId)?.outerAst.externalId
+    if (contextId === undefined) return
+    try {
+      const tempModule = Ast.MutableModule.Transient()
+      const preprocessorModule = Ast.parseExpression(visulizationModule, tempModule)!
+      const preprocessorQn = Ast.PropertyAccess.new(
+        tempModule,
+        preprocessorModule,
+        Ast.identifier(expressionString)!,
+      )
+
+      const preprocessorInvocation = Ast.App.PositionalSequence(preprocessorQn, [
+        Ast.Wildcard.new(tempModule),
+        ...positionalArgumentsExpressions.map((arg) => {
+          const parsedArg =
+            formatFunction ? formatFunction(arg, tempModule) : Ast.parseExpression(arg, tempModule)!
+          return Ast.Group.new(tempModule, parsedArg)
+        }),
+      ])
+      const rhs = Ast.parseExpression(identifier, tempModule)!
+      const expression = Ast.OprApp.new(tempModule, preprocessorInvocation, '<|', rhs)
+      return projectStore.executeExpression(contextId, expression.code())
+    } catch (e) {
+      console.error(e)
+      throw e
+    }
+  }
+
   const currentType = computed(() => {
     const selectedTypeValue = toValue(selectedVis)
     if (selectedTypeValue) return selectedTypeValue
@@ -260,5 +307,19 @@ export function useVisualizationData({
       (toolbarDefinition.value = definition),
     visualizationDefinedToolbar: computed(() => toValue(toolbarDefinition.value)),
     toolbarOverlay,
+    executeExpression: (
+      visulizationModule: string,
+      expressionString: string,
+      formatFunction:
+        | ((arg: any, tempModule: Ast.MutableModule) => Ast.Owned<Ast.MutableExpression>)
+        | null,
+      ...positionalArgumentsExpressions: string[]
+    ) =>
+      executeExpression(
+        visulizationModule,
+        expressionString,
+        formatFunction,
+        ...positionalArgumentsExpressions,
+      ),
   }
 }
diff --git a/app/gui/src/project-view/components/shared/AgGridTableView.vue b/app/gui/src/project-view/components/shared/AgGridTableView.vue
index c5ebeedc6e32..8f21b2ae5829 100644
--- a/app/gui/src/project-view/components/shared/AgGridTableView.vue
+++ b/app/gui/src/project-view/components/shared/AgGridTableView.vue
@@ -83,16 +83,14 @@ import type {
   ICellEditorComp,
   IHeaderComp,
   IHeaderParams,
+  IServerSideDatasource,
   MenuItemDef,
   ProcessDataFromClipboardParams,
   RowDataUpdatedEvent,
   RowEditingStartedEvent,
   RowEditingStoppedEvent,
-  RowHeightParams,
   SortChangedEvent,
 } from 'ag-grid-enterprise'
-import * as iter from 'enso-common/src/utilities/data/iter'
-import { LINE_BOUNDARIES } from 'enso-common/src/utilities/data/string'
 import {
   Component,
   type ComponentInstance,
@@ -110,8 +108,6 @@ import {
   tableToEnsoExpression,
 } from '../GraphEditor/widgets/WidgetTableEditor/tableParsing'
 
-const DEFAULT_ROW_HEIGHT = 22
-
 const props = defineProps<{
   rowData: TData[]
   columnDefs: (ColDef<TData, TValue> | ColGroupDef<TData>)[] | null
@@ -124,6 +120,9 @@ const props = defineProps<{
   suppressMoveWhenColumnDragging?: boolean
   textFormatOption?: TextFormatOptions
   processDataFromClipboard?: (params: ProcessDataFromClipboardParams<TData>) => string[][] | null
+  datasource?: IServerSideDatasource
+  rowCount?: number
+  isServerSideModel?: boolean
 }>()
 const emit = defineEmits<{
   cellEditingStarted: [event: CellEditingStartedEvent]
@@ -145,24 +144,7 @@ function onGridReady(event: GridReadyEvent<TData>) {
   gridApi.value = event.api
 }
 
-function getRowHeight(params: RowHeightParams): number {
-  if (props.textFormatOption === 'off') {
-    return DEFAULT_ROW_HEIGHT
-  }
-  const rowData = Object.values(params.data)
-  const textValues = rowData.filter((r): r is string => typeof r === 'string')
-
-  if (!textValues.length) {
-    return DEFAULT_ROW_HEIGHT
-  }
-
-  const returnCharsCount = iter.map(textValues, (text) =>
-    iter.count(text.matchAll(LINE_BOUNDARIES)),
-  )
-
-  const maxReturnCharsCount = iter.reduce(returnCharsCount, Math.max, 0)
-  return (maxReturnCharsCount + 1) * DEFAULT_ROW_HEIGHT
-}
+const rowModelType = computed(() => (props.isServerSideModel ? 'serverSide' : 'clientSide'))
 
 watch(
   () => props.textFormatOption,
@@ -360,8 +342,10 @@ const { AgGridVue } = await import('./AgGridTableView/AgGridVue')
       ref="grid"
       class="ag-theme-alpine inner"
       :headerHeight="26"
-      :getRowHeight="getRowHeight"
-      :rowData="rowData"
+      :rowModelType="rowModelType"
+      :serverSideDatasource="datasource"
+      :rowCount="rowCount"
+      :rowData="rowModelType === 'clientSide' ? rowData : null"
       :columnDefs="columnDefs"
       :defaultColDef="defaultColDef"
       :copyHeadersToClipboard="true"
diff --git a/app/gui/src/project-view/components/visualizations/TableVisualization.vue b/app/gui/src/project-view/components/visualizations/TableVisualization.vue
index ecbd3ec15636..a1ab6efda58a 100644
--- a/app/gui/src/project-view/components/visualizations/TableVisualization.vue
+++ b/app/gui/src/project-view/components/visualizations/TableVisualization.vue
@@ -2,7 +2,6 @@
 import icons from '@/assets/icons.svg'
 import AgGridTableView, { commonContextMenuActions } from '@/components/shared/AgGridTableView.vue'
 import {
-  GridFilterModel,
   useTableVizToolbar,
   type SortModel,
 } from '@/components/visualizations/TableVisualization/tableVizToolbar'
@@ -15,11 +14,21 @@ import type {
   CellDoubleClickedEvent,
   ColDef,
   ICellRendererParams,
+  IServerSideDatasource,
+  IServerSideGetRowsRequest,
   ITooltipParams,
+  SetFilterValuesFuncParams,
   SortChangedEvent,
 } from 'ag-grid-enterprise'
 import { computed, onMounted, ref, shallowRef, watchEffect, type Ref } from 'vue'
 import { TableVisualisationTooltip } from './TableVisualization/TableVisualisationTooltip'
+import {
+  convertFilterModel,
+  convertSortModel,
+  parseArgument,
+} from './TableVisualization/TableVizDataSourceUtils'
+import { GridFilterModel, makeFilterModelList } from './TableVisualization/tableVizFilterUtils'
+import { TableVizStatusBar } from './TableVisualization/TableVizStatusBar'
 import { getCellValueType, isNumericType } from './TableVisualization/tableVizUtils'
 
 export const name = 'Table'
@@ -96,6 +105,7 @@ interface UnknownTable {
   child_label: string
   visualization_header: string
   data_quality_metrics?: DataQualityMetric[]
+  is_using_server_sort_and_filter: boolean
 }
 
 type DataQualityMetric = {
@@ -130,7 +140,6 @@ const dataGroupingMap = shallowRef<Map<string, boolean>>()
 const defaultColDef: Ref<ColDef> = ref({
   editable: false,
   sortable: true,
-  filter: true,
   resizable: true,
   minWidth: 25,
   cellRenderer: cellRenderer,
@@ -142,9 +151,33 @@ const defaultColDef: Ref<ColDef> = ref({
     'separator',
     'export',
   ],
+  autoHeight: true,
 } satisfies ColDef)
 const rowData = ref<Record<string, any>[]>([])
 const columnDefs: Ref<ColDef[]> = ref([])
+const allRowCount = computed(() =>
+  typeof props.data === 'object' && 'all_rows_count' in props.data ? props.data.all_rows_count : 0,
+)
+const isSSRM = computed(
+  () => typeof props.data === 'object' && 'is_using_server_sort_and_filter' in props.data && props.data.is_using_server_sort_and_filter,
+)
+const statusBar = computed(() =>
+  allRowCount.value ?
+    {
+      statusPanels:
+        isSSRM.value ?
+          [
+            {
+              statusPanel: TableVizStatusBar,
+              statusPanelParams: {
+                total: allRowCount.value,
+              },
+            },
+          ]
+        : [],
+    }
+  : null,
+)
 
 const textFormatterSelected = ref<TextFormatOptions>('partial')
 
@@ -163,6 +196,17 @@ const selectableRowLimits = computed(() => {
   return defaults
 })
 
+function setRowLimit(newRowLimit: number) {
+  if (newRowLimit !== rowLimit.value) {
+    rowLimit.value = newRowLimit
+    config.setPreprocessor(
+      'Standard.Visualization.Table.Visualization',
+      'prepare_visualization',
+      newRowLimit.toString(),
+    )
+  }
+}
+
 const isFilterSortNodeEnabled = computed(
   () => config.nodeType === TABLE_NODE_TYPE || config.nodeType === DB_TABLE_NODE_TYPE,
 )
@@ -241,14 +285,115 @@ function formatText(params: ICellRendererParams) {
   return `<span > ${newString} <span>`
 }
 
-function setRowLimit(newRowLimit: number) {
-  if (newRowLimit !== rowLimit.value) {
-    rowLimit.value = newRowLimit
-    config.setPreprocessor(
-      'Standard.Visualization.Table.Visualization',
-      'prepare_visualization',
-      newRowLimit.toString(),
+const createRowsForTable = (data: unknown[][], shift: number, isSSrm: boolean) => {
+  const rows = data && data.length > 0 ? (data[0]?.length ?? 0) : 0
+  const getIndexInfo = (i: number) => {
+    return isSSrm ? data?.[0]?.[i] : i
+  }
+  return Array.from({ length: rows }, (_, i) => {
+    return Object.fromEntries(
+      columnDefs.value.map((h, j) => {
+        return [
+          h.field,
+          h.field === INDEX_FIELD_NAME ? getIndexInfo(i) : toRender(data?.[j - shift]?.[i]),
+        ]
+      }),
     )
+  })
+}
+
+async function getFilterValues(params: SetFilterValuesFuncParams) {
+  const colName = params.colDef.field
+  if (typeof props.data === 'object' && 'header' in props.data) {
+    const index = props.data.header?.findIndex((h: string) => colName === h)
+    const server = createServer()
+    const response = await server.getSetFilterValues(index)
+    setTimeout(() => {
+      if (response.success) {
+        params.success(response.data)
+      }
+    }, 500)
+  }
+}
+
+function createServer() {
+  return {
+    getSetFilterValues: async (columnIndex?: number) => {
+      const response = await config.executeExpression(
+        'Standard.Visualization.Table.Visualization',
+        'get_distinct_values_for_column',
+        //null as values dont need parsing
+        null,
+        `${columnIndex}`,
+      )
+      return {
+        success: true,
+        data: response.value.distinct_vals,
+      }
+    },
+    getData: async (request: IServerSideGetRowsRequest) => {
+      const columnHeaders =
+        typeof props.data === 'object' && 'header' in props.data ?
+          props.data.header ?
+            props.data.header
+          : []
+        : []
+
+      const { sortColIndexes, sortDirections } = convertSortModel(request, columnHeaders)
+
+      const { filterColumnIndexList, filterActions, valueList, toValueList } = convertFilterModel(
+        request,
+        columnHeaders,
+        colTypeMap.value,
+      )
+
+      const response = await config.executeExpression(
+        'Standard.Visualization.Table.Visualization',
+        'get_rows_for_table',
+        // function that will parse filter values to enso compaible
+        parseArgument,
+        //the index of the next bucket of rows to get
+        `${request.startRow}`,
+        //column indexes that require a sort
+        sortColIndexes,
+        //direction (Ascending/Descending) for the sorts
+        sortDirections,
+        //column indexes that require a filter
+        filterColumnIndexList,
+        //column actions i.e Greater Than, Between...
+        filterActions,
+        //column values, or From Values if using a Between filter
+        valueList,
+        // To Values (only used in Between filters will be 'Nothing' for any other filter)
+        toValueList,
+      )
+      return {
+        success: true,
+        data: response.value.rows,
+      }
+    },
+  }
+}
+
+interface Response {
+  data: unknown[][]
+  success: boolean
+}
+function createServerSideDatasource(): IServerSideDatasource {
+  return {
+    getRows: async (params) => {
+      const server = createServer()
+      const response: Response = await server.getData(params.request)
+      const startIndex = params.request.startRow ? params.request.startRow : 0
+      const rows = createRowsForTable(response.data, 0, true)
+      setTimeout(() => {
+        if (response.success) {
+          params.success({ rowData: rows })
+        } else {
+          params.fail()
+        }
+      }, 500)
+    },
   }
 }
 
@@ -414,6 +559,7 @@ function toField(
     filter: filterType,
     filterParams: {
       maxNumConditions: 1,
+      values: getFilterValues,
       filterOptions: filterOptions,
     },
     headerComponentParams: {
@@ -522,6 +668,8 @@ watchEffect(() => {
         visualization_header: undefined,
         // eslint-disable-next-line camelcase
         link_value_type: undefined,
+        // eslint-disable-next-line camelcase
+        is_using_server_sort_and_filter: undefined,
       }
   if ('error' in data_) {
     columnDefs.value = [
@@ -631,21 +779,10 @@ watchEffect(() => {
           ...dataHeader,
         ]
       : dataHeader
-    const rows = data_.data && data_.data.length > 0 ? (data_.data[0]?.length ?? 0) : 0
-    rowData.value = Array.from({ length: rows }, (_, i) => {
-      const shift = data_.has_index_col ? 1 : 0
-      return Object.fromEntries(
-        columnDefs.value.map((h, j) => {
-          return [
-            h.field,
-            toRender(h.field === INDEX_FIELD_NAME ? i : data_.data?.[j - shift]?.[i]),
-          ]
-        }),
-      )
-    })
-    isTruncated.value = data_.all_rows_count !== rowData.value.length
+    if (!data_.is_using_server_sort_and_filter) {
+      rowData.value = data_.data ? createRowsForTable(data_.data, 0, data_.is_using_server_sort_and_filter) : []
+    }
   }
-
   // Update paging
   const newRowCount = data_.all_rows_count == null ? 1 : data_.all_rows_count
   showRowCount.value = !(data_.all_rows_count == null)
@@ -656,21 +793,6 @@ watchEffect(() => {
     page.value = newPageLimit
   }
 
-  if (rowData.value[0]) {
-    const headers = Object.keys(rowData.value[0])
-    const headerGroupingMap = new Map()
-    headers.forEach((header) => {
-      const needsGrouping = rowData.value.some((row) => {
-        if (header in row && row[header] != null) {
-          const value = typeof row[header] === 'object' ? row[header].value : row[header]
-          return value > 999999 || value < -999999
-        }
-      })
-      headerGroupingMap.set(header, needsGrouping)
-    })
-    dataGroupingMap.value = headerGroupingMap
-  }
-
   // If data is truncated, we cannot rely on sorting/filtering so will disable.
   defaultColDef.value.filter = !isTruncated.value
   defaultColDef.value.sortable = !isTruncated.value
@@ -765,18 +887,7 @@ function checkSortAndFilter(e: SortChangedEvent) {
       }
     })
     .filter((sort) => sort)
-  const filter = Object.entries(gridFilterModel).map(([key, value]) => {
-    return {
-      columnName: key,
-      filterType: value.filterType,
-      filterAction: value.type,
-      filter: value.filter,
-      filterTo: value.filterTo,
-      dateFrom: value.dateFrom,
-      dateTo: value.dateTo,
-      values: value.values,
-    }
-  })
+  const filter = makeFilterModelList(gridFilterModel)
   if (sort.length || filter.length) {
     isCreateNodeEnabled.value = true
     sortModel.value = sort as SortModel[]
@@ -791,7 +902,6 @@ function checkSortAndFilter(e: SortChangedEvent) {
 // ===============
 // === Updates ===
 // ===============
-
 onMounted(() => {
   setRowLimit(1000)
 })
@@ -815,28 +925,30 @@ config.setToolbar(
 
 <template>
   <div ref="rootNode" class="TableVisualization" @wheel.stop @pointerdown.stop>
-    <div class="table-visualization-status-bar">
-      <select
-        v-if="isRowCountSelectorVisible"
-        @change="setRowLimit(Number(($event.target as HTMLOptionElement).value))"
-      >
-        <option
-          v-for="limit in selectableRowLimits"
-          :key="limit"
-          :value="limit"
-          v-text="limit"
-        ></option>
-      </select>
-      <template v-if="showRowCount">
-        <span
-          v-if="isRowCountSelectorVisible && isTruncated"
-          v-text="` of ${rowCount} rows (Sorting/Filtering disabled).`"
-        ></span>
-        <span v-else-if="isRowCountSelectorVisible" v-text="' rows.'"></span>
-        <span v-else-if="rowCount === 1" v-text="'1 row.'"></span>
-        <span v-else v-text="`${rowCount} rows.`"></span>
-      </template>
-    </div>
+    <template v-if="!isSSRM">
+      <div class="table-visualization-status-bar">
+        <select
+          v-if="isRowCountSelectorVisible"
+          @change="setRowLimit(Number(($event.target as HTMLOptionElement).value))"
+        >
+          <option
+            v-for="limit in selectableRowLimits"
+            :key="limit"
+            :value="limit"
+            v-text="limit"
+          ></option>
+        </select>
+        <template v-if="showRowCount">
+          <span
+            v-if="isRowCountSelectorVisible && isTruncated"
+            v-text="` of ${rowCount} rows (Sorting/Filtering disabled).`"
+          ></span>
+          <span v-else-if="isRowCountSelectorVisible" v-text="' rows.'"></span>
+          <span v-else-if="rowCount === 1" v-text="'1 row.'"></span>
+          <span v-else v-text="`${rowCount} rows.`"></span>
+        </template>
+      </div>
+    </template>
     <!-- TODO[ao]: Suspence in theory is not needed here (the entire visualization is inside
      suspense), but for some reason it causes reactivity loop - see https://github.com/enso-org/enso/issues/10782 -->
     <Suspense>
@@ -846,6 +958,10 @@ config.setToolbar(
         :rowData="rowData"
         :defaultColDef="defaultColDef"
         :textFormatOption="textFormatterSelected"
+        :datasource="createServerSideDatasource()"
+        :rowCount="allRowCount"
+        :isServerSideModel="isSSRM"
+        :statusBar="statusBar"
         @sortOrFilterUpdated="(e) => checkSortAndFilter(e)"
       />
     </Suspense>
diff --git a/app/gui/src/project-view/components/visualizations/TableVisualization/TableVizDataSourceUtils.ts b/app/gui/src/project-view/components/visualizations/TableVisualization/TableVizDataSourceUtils.ts
new file mode 100644
index 000000000000..8a273b02ad31
--- /dev/null
+++ b/app/gui/src/project-view/components/visualizations/TableVisualization/TableVizDataSourceUtils.ts
@@ -0,0 +1,158 @@
+import { Ast } from '@/util/ast'
+import { Pattern } from '@/util/ast/match'
+import { IServerSideGetRowsRequest } from 'ag-grid-community'
+import { request } from 'http'
+import {
+  actionMap,
+  FilterAction,
+  getFilterValue,
+  GridFilterModel,
+  makeFilterModelList,
+} from './tableVizFilterUtils'
+import { getCellValueType } from './tableVizUtils'
+
+type ValueTypes = 'Date' | 'Time' | 'Date_Time' | 'Integer' | 'Char'
+type ValueTypeArgumentChild = { valueType: ValueTypes; value: string }
+type ValueTypeArgumentParent =
+  | { valueType: ValueTypes; value: string }
+  | { valueType: 'Mixed'; value: ValueTypeArgumentChild[] }
+type PossibleArguments = string | ValueTypeArgumentParent
+type Argument = string | Array<PossibleArguments>
+type SortDirection = 'asc' | 'desc'
+const sortDirectionMap = {
+  asc: '1',
+  desc: '-1',
+}
+
+const parseSingleArgument = (
+  value: ValueTypeArgumentParent,
+  tempModule: Ast.MutableModule,
+): Ast.Owned<Ast.MutableExpression> => {
+  switch (value.valueType) {
+    case 'Date': {
+      const datePattern = Pattern.parseExpression('(Date.new __ __ __)')
+      const dateParts = value.value
+        .match(/\d+/g)!
+        .slice(0, 3)
+        .map((part: string) => Ast.tryNumberToEnso(Number(part), tempModule)!)
+      return datePattern.instantiateCopied(dateParts)
+    }
+    case 'Time': {
+      const pattern = Pattern.parseExpression('Time_Of_Day.parse (__)')!
+      return pattern.instantiateCopied([Ast.TextLiteral.new(value.value, tempModule)])
+    }
+    case 'Date_Time': {
+      const pattern = Pattern.parseExpression('Date_Time.parse (__)')!
+      return pattern.instantiateCopied([Ast.TextLiteral.new(value.value, tempModule)])
+    }
+    case 'Integer':
+      return Ast.parseExpression(value.value, tempModule)!
+    case 'Char':
+      return Ast.TextLiteral.new(value.value)
+    case 'Mixed': {
+      const items = value.value.map((val: { valueType: ValueTypes; value: string }) =>
+        parseSingleArgument(val, tempModule),
+      )
+      return Ast.Vector.new(tempModule, items)
+    }
+    default:
+      return Ast.parseExpression(value, tempModule)!
+  }
+}
+
+export const parseArgument = (arg: Argument, tempModule: Ast.MutableModule) => {
+  if (Array.isArray(arg)) {
+    const itemList = arg.map((i) => {
+      return typeof i === 'string' ?
+          Ast.parseExpression(i, tempModule)!
+        : parseSingleArgument(i, tempModule)
+    })
+    return Ast.Vector.new(tempModule, itemList!)
+  }
+  return Ast.parseExpression(arg, tempModule)!
+}
+
+export const convertSortModel = (request: IServerSideGetRowsRequest, columnHeaders: string[]) => {
+  const sortColIndexesMap = request.sortModel.map((sortCol) => {
+    return `${columnHeaders.findIndex((h: string) => sortCol.colId === h)}`
+  })
+  const sortColIndexes = sortColIndexesMap.length ? sortColIndexesMap : 'Nothing'
+  const sortDirections =
+    sortColIndexesMap.length ?
+      request.sortModel.map((sortCol) => {
+        return sortDirectionMap[sortCol.sort as SortDirection]
+      })
+    : 'Nothing'
+  return { sortColIndexes, sortDirections }
+}
+
+export const convertFilterModel = (
+  request: IServerSideGetRowsRequest,
+  columnHeaders: string[],
+  colTypeMap: Map<string, string>,
+) => {
+  const gridFilterModelList: Array<GridFilterModel> =
+    request.filterModel ? makeFilterModelList(request.filterModel) : []
+
+  const filterColumnNames = gridFilterModelList.map((filter) => filter.columnName)
+
+  const filterColumnIndexList =
+    filterColumnNames.length ?
+      filterColumnNames.map((colName) => `${columnHeaders.findIndex((h: string) => colName === h)}`)
+    : 'Nothing'
+
+  const filterActions =
+    filterColumnNames.length ?
+      gridFilterModelList.map((filter) => {
+        return filter.filterType === 'set' ?
+            '..Is_In'
+          : actionMap[filter.filterAction as FilterAction]
+      })
+    : 'Nothing'
+
+  const valueMap = gridFilterModelList.map((filter) => {
+    return {
+      valType: colTypeMap.get(filter.columnName),
+      action: actionMap[filter.filterAction as FilterAction],
+      value: getFilterValue(filter),
+    }
+  })
+
+  const valueList =
+    valueMap.length ?
+      valueMap.map((value) => {
+        if (value.valType === 'Mixed' && Array.isArray(value.value)) {
+          const parseValues = value.value.map((val) => {
+            return { valueType: getCellValueType(val), value: val }
+          })
+          return { valueType: value.valType, value: parseValues }
+        }
+
+        if (
+          value.action === '..Between' &&
+          typeof value.value === 'object' &&
+          'fromValue' in value.value
+        ) {
+          return { valueType: value.valType, value: `${value.value.fromValue}` }
+        }
+
+        return { valueType: value.valType, value: `${value.value}` }
+      })
+    : 'Nothing'
+
+  const toValueList =
+    valueMap.length ?
+      valueMap.map((value) => {
+        if (
+          value.action === '..Between' &&
+          typeof value.value === 'object' &&
+          'fromValue' in value.value
+        ) {
+          return `${value.value.toValue}`
+        }
+        return 'Nothing'
+      })
+    : 'Nothing'
+
+  return { filterColumnIndexList, filterActions, valueList, toValueList }
+}
diff --git a/app/gui/src/project-view/components/visualizations/TableVisualization/TableVizStatusBar.ts b/app/gui/src/project-view/components/visualizations/TableVisualization/TableVizStatusBar.ts
new file mode 100644
index 000000000000..90a66ca3216a
--- /dev/null
+++ b/app/gui/src/project-view/components/visualizations/TableVisualization/TableVizStatusBar.ts
@@ -0,0 +1,24 @@
+/**
+ * Status bar for table visualization.
+ */
+export class TableVizStatusBar {
+  eGui!: HTMLElement
+
+  /**
+   * Initializes the statusbar with the provided parameters.
+   * @param params The statusbar parameter: total row count.
+   */
+  init(params: { total: number }) {
+    this.eGui = document.createElement('div')
+    this.eGui.innerHTML = `
+              <div><b>Total Row Count:</b> ${params.total}</div>
+          `
+  }
+
+  /**
+   * Returns the statusbar DOM element.
+   */
+  getGui() {
+    return this.eGui
+  }
+}
diff --git a/app/gui/src/project-view/components/visualizations/TableVisualization/tableVizFilterUtils.ts b/app/gui/src/project-view/components/visualizations/TableVisualization/tableVizFilterUtils.ts
new file mode 100644
index 000000000000..2cbfae30f9bb
--- /dev/null
+++ b/app/gui/src/project-view/components/visualizations/TableVisualization/tableVizFilterUtils.ts
@@ -0,0 +1,82 @@
+import { FilterModel } from 'ag-grid-community'
+
+export type FilterType = 'number' | 'date' | 'set' | 'text'
+
+/**
+ * Represents the value used for filtering.
+ *
+ * - For comparisons such as 'equals' or 'greater than,' the filter value is a single value (string).
+ * - For 'is in' filtering, the filter value is a list of strings.
+ * - For range filtering, the filter value consists of two values that define the range.
+ */
+export type FilterValue = string | string[] | FilterValueRange
+
+export const actionMap = {
+  equals: '..Equal',
+  notEqual: '..Not_Equal',
+  greaterThan: '..Greater',
+  greaterThanOrEqual: '..Equal_Or_Greater',
+  lessThan: '..Less',
+  lessThanOrEqual: '..Equal_Or_Less',
+  inRange: '..Between',
+  blank: '..Is_Nothing',
+  notBlank: '..Not_Nothing',
+  contains: '..Contains',
+  startsWith: '..Starts_With',
+  endsWith: '..Ends_With',
+}
+export type FilterAction = keyof typeof actionMap
+export type GridFilterModel = {
+  columnName: string
+  filterType: FilterType
+  filter?: string
+  filterTo?: string
+  dateFrom?: string
+  dateTo?: string
+  values?: string[]
+  filterAction?: FilterAction
+}
+export type FilterValueRange = {
+  toValue: string
+  fromValue: string
+}
+
+export const getFilterValue = (filterModel: GridFilterModel) => {
+  const filterType = filterModel.filterType
+  const filterAction = filterModel.filterAction
+  let value: FilterValue
+  switch (filterType) {
+    case 'number':
+      value =
+        filterAction === 'inRange' ?
+          { toValue: filterModel.filterTo!, fromValue: filterModel.filter! }
+        : (filterModel.filter as FilterValue)
+      break
+    case 'date':
+      value =
+        filterAction === 'inRange' ?
+          { toValue: filterModel.dateTo!, fromValue: filterModel.dateFrom! }
+        : (filterModel.dateFrom as FilterValue)
+      break
+    case 'text':
+      value = filterModel.filter as FilterValue
+      break
+    default:
+      value = filterModel.values as FilterValue
+  }
+  return value
+}
+
+export const makeFilterModelList = (gridFilterModel: FilterModel) =>
+  Object.entries(gridFilterModel).map(([key, value]) => {
+    return {
+      columnName: key,
+      filterType: value.filterType,
+      filterAction: value.type,
+      filter: value.filter,
+      filterTo: value.filterTo,
+      dateFrom: value.dateFrom,
+      dateTo: value.dateTo,
+      values: value.values,
+    }
+  })
diff --git a/app/gui/src/project-view/components/visualizations/TableVisualization/tableVizToolbar.ts b/app/gui/src/project-view/components/visualizations/TableVisualization/tableVizToolbar.ts
index 9265601be06e..bd2a8674926e 100644
--- a/app/gui/src/project-view/components/visualizations/TableVisualization/tableVizToolbar.ts
+++ b/app/gui/src/project-view/components/visualizations/TableVisualization/tableVizToolbar.ts
@@ -6,6 +6,15 @@ import type { ToValue } from '@/util/reactivity'
 import { computed, type ComputedRef, type Ref, toValue } from 'vue'
 import { Expression, MutableExpression } from 'ydoc-shared/ast'
 import { TextFormatOptions } from '../TableVisualization.vue'
+import {
+  actionMap,
+  FilterAction,
+  FilterType,
+  FilterValue,
+  FilterValueRange,
+  getFilterValue,
+  GridFilterModel,
+} from './tableVizFilterUtils'
 
 type SortDirection = 'asc' | 'desc'
 export type SortModel = {
@@ -13,46 +22,6 @@ export type SortModel = {
   sortDirection: SortDirection
   sortIndex: number
 }
-type FilterType = 'number' | 'date' | 'set' | 'text'
-
-/**
- * Represents the value used for filtering.
- *
- * - For comparisons such as 'equals' or 'greater than,' the filter value is a single value (string).
- * - For 'is in' filtering, the filter value is a list of strings.
- * - For range filtering, the filter value consists of two values that define the range.
- */
-type FilterValue = string | string[] | FilterValueRange
-
-const actionMap = {
-  equals: '..Equal',
-  notEqual: '..Not_Equal',
-  greaterThan: '..Greater',
-  greaterThanOrEqual: '..Equal_Or_Greater',
-  lessThan: '..Less',
-  lessThanOrEqual: '..Equal_Or_Less',
-  inRange: '..Between',
-  blank: '..Is_Nothing',
-  notBlank: '..Not_Nothing',
-  contains: '..Contains',
-  startsWith: '..Starts_With',
-  endsWith: '..Ends_With',
-}
-type FilterAction = keyof typeof actionMap
-export type GridFilterModel = {
-  columnName: string
-  filterType: FilterType
-  filter?: string
-  filterTo?: string
-  dateFrom?: string
-  dateTo?: string
-  values?: string[]
-  filterAction?: FilterAction
-}
-type FilterValueRange = {
-  toValue: string
-  fromValue: string
-}
 
 export interface SortFilterNodesButtonOptions {
   filterModel: ToValue<GridFilterModel[]>
@@ -269,26 +238,8 @@ function useSortFilterNodesButton({
           patterns.push(filterPatterns)
         }
 
-        let value: FilterValue
-        switch (filterType) {
-          case 'number':
-            value =
-              filterAction === 'inRange' ?
-                { toValue: filterModel.filterTo!, fromValue: filterModel.filter! }
-              : (filterModel.filter as FilterValue)
-            break
-          case 'date':
-            value =
-              filterAction === 'inRange' ?
-                { toValue: filterModel.dateTo!, fromValue: filterModel.dateFrom! }
-              : (filterModel.dateFrom as FilterValue)
-            break
-          case 'text':
-            value = filterModel.filter as FilterValue
-            break
-          default:
-            value = filterModel.values as FilterValue
-        }
+        const value = getFilterValue(filterModel, filterAction)
+
         if (value) {
           const filterPatterns =
             sortModelValue.length ?
diff --git a/app/gui/src/project-view/components/visualizations/VisualizationHost.vue b/app/gui/src/project-view/components/visualizations/VisualizationHost.vue
index 19ca82ab3b66..d539637489f4 100644
--- a/app/gui/src/project-view/components/visualizations/VisualizationHost.vue
+++ b/app/gui/src/project-view/components/visualizations/VisualizationHost.vue
@@ -3,6 +3,7 @@ import type { NodeCreationOptions } from '@/components/GraphEditor/nodeCreation'
 import LoadingVisualization from '@/components/visualizations/LoadingVisualization.vue'
 import type { ToolbarItem } from '@/components/visualizations/toolbar'
 import { provideVisualizationConfig } from '@/providers/visualizationConfig'
+import { Ast } from '@/util/ast'
 import type { Vec2 } from '@/util/data/vec2'
 import type { ToValue } from '@/util/reactivity'
 
@@ -17,6 +18,14 @@ const props = defineProps<{
     nodeType?: string | undefined
     overflow?: boolean
     toolbarOverflow?: boolean
+    executeExpression: (
+      visulizationModule: string,
+      expressionString: string,
+      formatFunction:
+        | ((arg: any, tempModule: Ast.MutableModule) => Ast.Owned<Ast.MutableExpression>)
+        | null,
+      ...positionalArgumentsExpressions: any[]
+    ) => any
   }
 }>()
 
@@ -51,6 +60,15 @@ provideVisualizationConfig({
   setToolbar: (items) => emit('updateToolbar', items),
   setToolbarOverlay: (overlay) => emit('updateToolbarOverlay', overlay),
   createNodes: (...nodes) => emit('createNodes', nodes),
+  executeExpression: (
+    visulizationModule: string,
+    expressionString: string,
+    formatFunction:
+      | ((arg: any, tempModule: Ast.MutableModule) => Ast.Owned<Ast.MutableExpression>)
+      | null,
+    ...args: any[]
+  ) =>
+    props.params.executeExpression(visulizationModule, expressionString, formatFunction, ...args),
 })
 </script>
 
diff --git a/app/gui/src/project-view/providers/visualizationConfig.ts b/app/gui/src/project-view/providers/visualizationConfig.ts
index f5d3c9c05207..db30bcf272b9 100644
--- a/app/gui/src/project-view/providers/visualizationConfig.ts
+++ b/app/gui/src/project-view/providers/visualizationConfig.ts
@@ -1,6 +1,7 @@
 import type { NodeCreationOptions } from '@/components/GraphEditor/nodeCreation'
 import type { ToolbarItem } from '@/components/visualizations/toolbar'
 import { createContextStore } from '@/providers'
+import { Ast } from '@/util/ast'
 import type { Vec2 } from '@/util/data/vec2'
 import type { ToValue } from '@/util/reactivity'
 import { reactive } from 'vue'
@@ -25,6 +26,14 @@ export interface VisualizationConfig {
    * it. By default, this is `false`.
    */
   setToolbarOverlay: (enableOverlay: boolean) => void
+  executeExpression: (
+    visulizationModule: string,
+    expressionString: string,
+    formatFunction:
+      | ((arg: any, tempModule: Ast.MutableModule) => Ast.Owned<Ast.MutableExpression>)
+      | null,
+    ...positionalArgumentsExpressions: any[]
+  ) => any
 }
 
 export { provideVisualizationConfig }
diff --git a/distribution/lib/Standard/Visualization/0.0.0-dev/src/Table/Visualization.enso b/distribution/lib/Standard/Visualization/0.0.0-dev/src/Table/Visualization.enso
index cacd23bbc633..8cc8b3ee7873 100644
--- a/distribution/lib/Standard/Visualization/0.0.0-dev/src/Table/Visualization.enso
+++ b/distribution/lib/Standard/Visualization/0.0.0-dev/src/Table/Visualization.enso
@@ -2,7 +2,7 @@ from Standard.Base import all
 import Standard.Base.Data.Vector.Builder
 
 import Standard.Table.Row.Row
-from Standard.Table import Column, Excel_Workbook, Table, Value_Type
+from Standard.Table import Column, Excel_Workbook, Table, Value_Type, Sort_Column
 
 import Standard.Database.DB_Column.DB_Column
 import Standard.Database.DB_Table.DB_Table
@@ -32,12 +32,12 @@ prepare_visualization y max_rows=1000 = if y.is_error then (make_json_for_error
         v : Row -> make_json_for_row v
         t : Table ->
             all_rows_count = t.row_count
-            make_json_for_table t max_rows all_rows_count True False
+            make_json_for_table t max_rows all_rows_count False
         c : Column -> prepare_visualization c.to_table max_rows
         t : DB_Table ->
             dataframe = t.read (..First max_rows)
             all_rows_count = t.row_count
-            make_json_for_table dataframe max_rows all_rows_count True True
+            make_json_for_table dataframe max_rows all_rows_count True
         c : DB_Column -> prepare_visualization c.to_table max_rows
         f : Function ->
             pairs = [['_display_text_', '[Function '+f.to_text+']']]
@@ -191,18 +191,18 @@ make_json_for_xml_element xml_element max_items type:Text="XML_Element" =
      to display.
    - all_rows_count: the number of all rows in the underlying data, useful if
      only a fragment is displayed.
-make_json_for_table : Table -> Integer -> Integer -> Boolean -> Boolean -> JS_Object
-make_json_for_table dataframe max_rows all_rows_count include_index_col is_db_table =
+make_json_for_table : Table -> Integer -> Integer -> Boolean -> JS_Object
+make_json_for_table dataframe max_rows all_rows_count is_db_table =
     act_max = if max_rows < all_rows_count then max_rows else all_rows_count
     get_vector c         = Warning.set (Vector.new act_max i-> make_json_for_value (c.get i)) []
     columns              = dataframe.columns
     header               = ["header", columns.map .name]
     value_type           = ["value_type", columns.map .value_type]
-    data                 = ["data",   columns.map get_vector]
     all_rows             = ["all_rows_count", all_rows_count]
-    has_index_col        = ["has_index_col", include_index_col]
+    has_index_col        = ["has_index_col", True]
     links                = ["get_child_node_action", "get_row"]
     child_label          = ["child_label", "row"]
+    data                 = if is_db_table then columns.map get_vector else Nothing
     data_quality_metrics = if is_db_table then [] else
         number_nothing = JS_Object.from_pairs [["name", "Count nothings"], ["percentage_value", columns.map .count_nothing]]
         sampled_label = if all_rows_count > Column.default_sample_size then " (sampled)" else ""
@@ -210,9 +210,101 @@ make_json_for_table dataframe max_rows all_rows_count include_index_col is_db_ta
         number_non_triv = JS_Object.from_pairs [["name", "Count non trivial whitespace" + sampled_label], ["percentage_value", columns.map .count_non_trivial_whitespace]]
         JS_Object.from_pairs
         [number_nothing, number_untrimmed, number_non_triv]
-    pairs                = [header, value_type, data, all_rows, has_index_col, links, ["data_quality_metrics", data_quality_metrics] ,["type", "Table"], child_label]
+    pairs                = [header, value_type, ["data", data], all_rows, has_index_col, links, ["data_quality_metrics", data_quality_metrics] ,["type", "Table"], child_label, ["is_using_server_sort_and_filter", is_db_table.not]]
     JS_Object.from_pairs pairs
 
+## PRIVATE
+
+   gets the distinct values of a column, used for filter options 
+
+   Arguments:
+   - table: table containing columns 
+   - column_index: the index of the column to get the distinct values for
+
+get_distinct_values_for_column : Table -> Integer -> JS_Object
+get_distinct_values_for_column table column_index =
+    column = table.at column_index
+    values = column.to_vector.distinct
+    result = JS_Object.from_pairs [["distinct_vals", values]]
+    result.to_text
+
+## PRIVATE
+
+   applies the sort model to the table.
+
+   Arguments:
+   - x: table to sort
+   - sort_col_index_list: indexes of columns to sort
+   - sort_direction_list: list of sort directions 1 for ascending -1 for descending
+
+apply_sort_to_table : Table -> List -> List -> Table
+apply_sort_to_table x sort_col_index_list sort_direction_list =
+    parse_direction d = if d == -1 then Sort_Direction.Descending else Sort_Direction.Ascending
+    get_pattern i = (Sort_Column.Index (sort_col_index_list.get i) (parse_direction (sort_direction_list.get i)))
+    sort_pattern = ((0.up_to sort_col_index_list.length).map idx-> get_pattern idx)
+    x.sort sort_pattern
+
+## PRIVATE
+
+   applies one filter to the table.
+
+   Arguments:
+   - table: table to sort
+   - filter_col: the column index to filter
+   - filter_action: filter action
+   - filter_val: values to filter
+   - filter_to_val: if a Between is the filer action this is the other value to provide a range
+
+apply_single_filter_to_table : Table -> Text -> Filter_Condition -> Any -> Any -> Table
+apply_single_filter_to_table table filter_col filter_action filter_val filter_to_val = 
+    case filter_action of
+      Filter_Condition.Between _ _ _ -> table.filter (filter_col+1) (Filter_Condition.Between filter_val filter_to_val)
+      Filter_Condition.Is_In _ _ -> if filter_val.length > 0 then table.filter (filter_col+1) (Filter_Condition.Is_In filter_val) else table.filter filter_col (Filter_Condition.Is_In [""])
+      _ -> table.filter (filter_col+1) (filter_action (filter_val)) 
+
+## PRIVATE
+
+   applies the filter model to the table.
+
+   Arguments:
+   - table: table to sort
+   - filter_col: indexes of columns with sorts applies
+   - filter_action: list of filter actions 
+   - filter_val: values to filter
+
+apply_filter_to_table : Table -> Integer -> List -> List -> List -> List -> Table
+apply_filter_to_table table i filter_col filter_action filter_val filter_to_val = 
+    if i == filter_col.length then table else
+        col = filter_col.get i
+        action = filter_action.get i
+        val = filter_val.get i
+        to_val = filter_to_val.get i
+        filtered_table = apply_single_filter_to_table table col action val to_val
+        @Tail_Call apply_filter_to_table filtered_table i+1 filter_col filter_action filter_val filter_to_val
+
+## PRIVATE
+
+   Prepares the row data table for visualizations using the server side row model.
+
+   Arguments:
+   - start_number: the start index of the next 100 rows to get
+
+get_rows_for_table : Any -> Integer -> List -> List -> List -> List -> List -> List -> JS_Object
+get_rows_for_table x start_number sort_col_index_list=Nothing sort_direction_list=Nothing filter_col=Nothing filter_action=Nothing filter_val=Nothing filter_extra_val=Nothing =
+    max_rows=100
+    col_name = x.make_temp_column_name
+    table_with_index = x.add_row_number col_name
+    table_with_index_ordered = table_with_index.reorder_columns [col_name] ..Before_Other_Columns
+    filtered_table = if filter_col.is_nothing then table_with_index_ordered else apply_filter_to_table table_with_index_ordered 0 filter_col filter_action filter_val filter_extra_val
+    sorted_table = if sort_col_index_list.is_nothing then filtered_table else apply_sort_to_table filtered_table sort_col_index_list sort_direction_list
+    all_rows_count = filtered_table.row_count
+    bucket_size = if all_rows_count > start_number + max_rows then max_rows else (all_rows_count - (start_number))
+    get_vector c         = Warning.set (Vector.new bucket_size i-> make_json_for_value (c.get (i + start_number))) []
+    columns              = sorted_table.columns
+    rows = columns.map get_vector
+    result = JS_Object.from_pairs [["rows", rows]]
+    result.to_text
+
 ## PRIVATE
    Create JSON serialization of values.
 make_json_for_other : Any -> JS_Object
diff --git a/test/Visualization_Tests/src/Table_Spec.enso b/test/Visualization_Tests/src/Table_Spec.enso
index a5427969ce6e..04536966b68d 100644
--- a/test/Visualization_Tests/src/Table_Spec.enso
+++ b/test/Visualization_Tests/src/Table_Spec.enso
@@ -49,20 +49,21 @@ type Foo_Link
     to_js_object self = JS_Object.from_pairs [["x", self.x], ["links", ["a", "b", "c"]]]
 
 add_specs suite_builder =
-    make_json header data all_rows value_type has_index_col get_child_node number_of_nothing=Nothing number_of_untrimmed_whitespace=Nothing number_of_untrimmed_whitespace_sampled=Nothing number_non_trivial_ws=Nothing number_non_trivial_ws_sampled=Nothing =
+    make_json header data all_rows value_type has_index_col get_child_node is_ssrm number_of_nothing=Nothing number_of_untrimmed_whitespace=Nothing number_of_untrimmed_whitespace_sampled=Nothing number_non_trivial_ws=Nothing number_non_trivial_ws_sampled=Nothing =
         p_header      = ["header", header]
         p_data        = ["data",   data]
         p_all_rows    = ["all_rows_count", all_rows]
         p_value_type  = ["value_type", value_type]
         p_has_index_col = ["has_index_col", has_index_col]
         p_get_child_node = ["get_child_node_action", get_child_node]
+        p_is_ssrm       = ["is_ssrm", is_ssrm]
         p_number_of_nothing = if number_of_nothing.is_nothing then [] else [JS_Object.from_pairs [["name", "Count nothings"], ["percentage_value", number_of_nothing]]]
         p_number_of_untrimmed_whitespace = if number_of_untrimmed_whitespace.is_nothing then [] else [JS_Object.from_pairs [["name", "Count untrimmed whitespace"], ["percentage_value", number_of_untrimmed_whitespace]]]
         p_number_non_trivial_ws = if number_non_trivial_ws.is_nothing then [] else [JS_Object.from_pairs [["name", "Count non trivial whitespace"], ["percentage_value", number_non_trivial_ws]]]
         p_number_of_untrimmed_whitespace_sampled = if number_of_untrimmed_whitespace_sampled.is_nothing then [] else [JS_Object.from_pairs [["name", "Count untrimmed whitespace (sampled)"], ["percentage_value", number_of_untrimmed_whitespace_sampled]]]
         p_number_non_trivial_ws_sampled = if number_non_trivial_ws_sampled.is_nothing then [] else [JS_Object.from_pairs [["name", "Count non trivial whitespace (sampled)"], ["percentage_value", number_non_trivial_ws_sampled]]]
         data_quality_metrics = p_number_of_nothing + p_number_of_untrimmed_whitespace + p_number_of_untrimmed_whitespace_sampled + p_number_non_trivial_ws + p_number_non_trivial_ws_sampled
-        pairs    = [p_header, p_value_type, p_data, p_all_rows, p_has_index_col, p_get_child_node, ["data_quality_metrics", data_quality_metrics], ["type", "Table"], ["child_label", "row"]]
+        pairs    = [p_header, p_value_type, p_data, p_all_rows, p_has_index_col, p_get_child_node, ["data_quality_metrics", data_quality_metrics], ["type", "Table"], ["child_label", "row"], p_is_ssrm]
         JS_Object.from_pairs pairs . to_text
     
     suite_builder.group "Table Visualization" group_builder->
@@ -72,31 +73,31 @@ add_specs suite_builder =
             vis = Visualization.prepare_visualization data.t 1
             value_type_int = JS_Object.from_pairs [["type", "Value_Type"], ["constructor", "Integer"], ["display_text", "Integer (64 bits)"], ["bits", 64]]
             value_type_char = JS_Object.from_pairs [["type", "Value_Type"], ["constructor", "Char"], ["display_text", "Char (variable length, max_size=unlimited)"], ["size", Nothing], ["variable_length", True]]
-            json = make_json header=["A", "B", "C"] data=[['a'], [2], [3]] all_rows=3 value_type=[value_type_char, value_type_int, value_type_int] has_index_col=True get_child_node="get_row"
+            json = make_json header=["A", "B", "C"] data=[['a'], [2], [3]] all_rows=3 value_type=[value_type_char, value_type_int, value_type_int] has_index_col=True get_child_node="get_row" is_ssrm=False
             vis . should_equal json
 
         group_builder.specify "should visualize database columns" <|
             vis = Visualization.prepare_visualization (data.t.at "A") 2
             value_type_char = JS_Object.from_pairs [["type", "Value_Type"], ["constructor", "Char"], ["display_text", "Char (variable length, max_size=unlimited)"], ["size", Nothing], ["variable_length", True]]
             value_type_float = JS_Object.from_pairs [["type", "Value_Type"], ["constructor", "Float"], ["display_text", "Float (64 bits)"], ["bits", 64]]
-            json = make_json header=["A"] data=[['a', 'a']] all_rows=3 value_type=[value_type_char] has_index_col=True get_child_node="get_row"
+            json = make_json header=["A"] data=[['a', 'a']] all_rows=3 value_type=[value_type_char] has_index_col=True get_child_node="get_row" is_ssrm=False
             vis . should_equal json
 
             g = data.t.aggregate ["A", "B"] [Aggregate_Column.Average "C"] . at "Average C"
             vis2 = Visualization.prepare_visualization g 1
-            json2 = make_json header=["Average C"] data=[[4.0]] all_rows=2 value_type=[value_type_float] has_index_col=True get_child_node="get_row"
+            json2 = make_json header=["Average C"] data=[[4.0]]  all_rows=2 value_type=[value_type_float] has_index_col=True get_child_node="get_row" is_ssrm=False
             vis2 . should_equal json2
 
         group_builder.specify "should visualize dataframe tables" <|
             vis = Visualization.prepare_visualization data.t2 1
             value_type_int = JS_Object.from_pairs [["type", "Value_Type"], ["constructor", "Integer"], ["display_text", "Integer (64 bits)"], ["bits", 64]]
-            json = make_json header=["A", "B", "C"] data=[[1], [4], [7]] all_rows=3 value_type=[value_type_int, value_type_int, value_type_int] has_index_col=True get_child_node="get_row" number_of_nothing=[0,0,0] number_of_untrimmed_whitespace=[Nothing, Nothing, Nothing] number_non_trivial_ws=[Nothing, Nothing, Nothing]
+            json = make_json header=["A", "B", "C"] data=Nothing all_rows=3 value_type=[value_type_int, value_type_int, value_type_int] has_index_col=True get_child_node="get_row" is_ssrm=True number_of_nothing=[0,0,0] number_of_untrimmed_whitespace=[Nothing, Nothing, Nothing] number_non_trivial_ws=[Nothing, Nothing, Nothing]
             vis . should_equal json
 
         group_builder.specify "should visualize dataframe columns" <|
             vis = Visualization.prepare_visualization (data.t2.at "A") 2
             value_type_int = JS_Object.from_pairs [["type", "Value_Type"], ["constructor", "Integer"], ["display_text", "Integer (64 bits)"], ["bits", 64]]
-            json = make_json header=["A"] data=[[1, 2]] all_rows=3 value_type=[value_type_int] has_index_col=True get_child_node="get_row" number_of_nothing=[0] number_of_untrimmed_whitespace=[Nothing] number_non_trivial_ws=[Nothing]
+            json = make_json header=["A"] data=Nothing all_rows=3 value_type=[value_type_int] has_index_col=True get_child_node="get_row" is_ssrm=True number_of_nothing=[0] number_of_untrimmed_whitespace=[Nothing] number_non_trivial_ws=[Nothing]
             vis . should_equal json
 
         group_builder.specify "should handle Vectors" <|
@@ -139,21 +140,21 @@ add_specs suite_builder =
         group_builder.specify "should indicate number of Nothing/Nulls" <|
             vis = Visualization.prepare_visualization data.t3_with_nulls 3
             value_type_int = JS_Object.from_pairs [["type", "Value_Type"], ["constructor", "Integer"], ["display_text", "Integer (64 bits)"], ["bits", 64]]
-            json = make_json header=["A", "B", "C"] data=[[1,Nothing,3],[4,Nothing,Nothing],[7,Nothing,Nothing]] all_rows=3 value_type=[value_type_int, value_type_int, value_type_int] has_index_col=True get_child_node="get_row" number_of_nothing=[1, 2, 2] number_of_untrimmed_whitespace=[Nothing, Nothing, Nothing] number_non_trivial_ws=[Nothing, Nothing, Nothing]
+            json = make_json header=["A", "B", "C"] data=Nothing all_rows=3 value_type=[value_type_int, value_type_int, value_type_int] has_index_col=True get_child_node="get_row" is_ssrm=True number_of_nothing=[1, 2, 2] number_of_untrimmed_whitespace=[Nothing, Nothing, Nothing] number_non_trivial_ws=[Nothing, Nothing, Nothing]
             vis . should_equal json
 
         group_builder.specify "should indicate number of leading/trailing whitespace" <|
             vis = Visualization.prepare_visualization data.t4_with_space 3
             value_type_char = JS_Object.from_pairs [["type", "Value_Type"], ["constructor", "Char"], ["display_text", "Char (variable length, max_size=unlimited)"], ["size", Nothing], ["variable_length", True]]
             value_type_int = JS_Object.from_pairs [["type", "Value_Type"], ["constructor", "Integer"], ["display_text", "Integer (64 bits)"], ["bits", 64]]
-            json = make_json header=["A", "B", "C"] data=[['hello', '   leading space', 'trailing space    '],['a', 'b', 'c'],[7, 8, 9]] all_rows=3 value_type=[value_type_char, value_type_char, value_type_int] has_index_col=True get_child_node="get_row" number_of_nothing=[0, 0, 0] number_of_untrimmed_whitespace=[2, 0, Nothing] number_non_trivial_ws=[0, 0, Nothing]
+            json = make_json header=["A", "B", "C"] data=Nothing all_rows=3 value_type=[value_type_char, value_type_char, value_type_int] has_index_col=True get_child_node="get_row" is_ssrm=True number_of_nothing=[0, 0, 0] number_of_untrimmed_whitespace=[2, 0, Nothing] number_non_trivial_ws=[0, 0, Nothing]
             vis . should_equal json
 
         group_builder.specify "should indicate number of non trivial whitespace" <|
             vis = Visualization.prepare_visualization data.t5_with_non_trivial_ws 3
             value_type_char = JS_Object.from_pairs [["type", "Value_Type"], ["constructor", "Char"], ["display_text", "Char (variable length, max_size=unlimited)"], ["size", Nothing], ["variable_length", True]]
             value_type_int = JS_Object.from_pairs [["type", "Value_Type"], ["constructor", "Integer"], ["display_text", "Integer (64 bits)"], ["bits", 64]]
-            json = make_json header=["A", "B", "C"] data=[['hello', 'extra \r space', 'world'],['a', 'b', 'c'],[7, 8, 9]] all_rows=3 value_type=[value_type_char, value_type_char, value_type_int] has_index_col=True get_child_node="get_row" number_of_nothing=[0, 0, 0] number_of_untrimmed_whitespace=[0,0,Nothing] number_non_trivial_ws=[1, 0, Nothing]
+            json = make_json header=["A", "B", "C"] data=Nothing all_rows=3 value_type=[value_type_char, value_type_char, value_type_int] has_index_col=True get_child_node="get_row" is_ssrm=True number_of_nothing=[0, 0, 0] number_of_untrimmed_whitespace=[0,0,Nothing] number_non_trivial_ws=[1, 0, Nothing]
             vis . should_equal json
 
         group_builder.specify "should indicate number of leading/trailing whitespace with sample if more than 10000 rows" <|
@@ -165,7 +166,7 @@ add_specs suite_builder =
             space_table = Table.new [["A", space_data]]
             vis = Visualization.prepare_visualization space_table 1000
             value_type_char = JS_Object.from_pairs [["type", "Value_Type"], ["constructor", "Char"], ["display_text", "Char (variable length, max_size=unlimited)"], ["size", Nothing], ["variable_length", True]]
-            json = make_json header=["A"] data=[space_data.take 1000] all_rows=11000 value_type=[value_type_char] has_index_col=True get_child_node="get_row" number_of_nothing=[0] number_of_untrimmed_whitespace_sampled=[8267] number_non_trivial_ws_sampled=[0]
+            json = make_json header=["A"] data=Nothing all_rows=11000 value_type=[value_type_char] has_index_col=True get_child_node="get_row" is_ssrm=True number_of_nothing=[0] number_of_untrimmed_whitespace_sampled=[8267] number_non_trivial_ws_sampled=[0]
             vis . should_equal json
 
         group_builder.specify "should indicate number of non trivial whitespace with sample if more than 10000 rows" <|
@@ -176,7 +177,7 @@ add_specs suite_builder =
             space_table = Table.new [["A", space_data]]
             vis = Visualization.prepare_visualization space_table 1000
             value_type_char = JS_Object.from_pairs [["type", "Value_Type"], ["constructor", "Char"], ["display_text", "Char (variable length, max_size=unlimited)"], ["size", Nothing], ["variable_length", True]]
-            json = make_json header=["A"] data=[space_data.take 1000] all_rows=11000 value_type=[value_type_char] has_index_col=True get_child_node="get_row" number_of_nothing=[0] number_of_untrimmed_whitespace_sampled=[3659] number_non_trivial_ws_sampled=[7285]
+            json = make_json header=["A"] data=Nothing all_rows=11000 value_type=[value_type_char] has_index_col=True get_child_node="get_row" is_ssrm=True number_of_nothing=[0] number_of_untrimmed_whitespace_sampled=[3659] number_non_trivial_ws_sampled=[7285]
             vis . should_equal json
 
 main filter=Nothing =