table: Global filter doesn't run when accessor key points to an object

Describe the bug

If the accessor key points to an object in the data, then the global filter never gets invoked, even if I define a custom filter function.

This wasted a few hours of my time trying to track down why my global filter wasn’t working. I find it very surprising that it would silently ignore my column.

Your minimal, reproducible example

https://codesandbox.io/p/sandbox/elegant-morning-i68tj7?file=%2Fsrc%2Fmain.tsx&selection=[{"endColumn"%3A17%2C"endLineNumber"%3A125%2C"startColumn"%3A17%2C"startLineNumber"%3A125}]

Steps to reproduce

Type things in the global filter, notice the rows are not filtered. Open the console, see that console.log() in fuzzyFilter is never called.

Expected behavior

If the accessor points to an object and there’s a filter defined (either via globalFilterFn or a filterFn on the column), then it should still attempt to filter that column.

Or at the very least, there should be some kind of debug log if debug is turned on to explain why a column isn’t getting filtered. There’s really no observability to discover why the column is ignored.

The docs also make no mention that the column type would make a difference.

How often does this bug happen?

Every time

Screenshots or Videos

No response

Platform

Any

react-table version

8.7.6

TypeScript version

4.9.4

Additional context

No response

Terms & Code of Conduct

  • I agree to follow this project’s Code of Conduct
  • I understand that if my bug cannot be reliable reproduced in a debuggable environment, it will probably not be fixed and this issue may even be closed.

About this issue

  • Original URL
  • State: open
  • Created 4 years ago
  • Reactions: 8
  • Comments: 16 (2 by maintainers)

Most upvoted comments

+1 for this issue

I used to be able to do a global search filter on an array column in v7.8.0, but now I cannot (v8.7.9).

The FilterFnOption type (for a filterFn of a ColumnDef) allows the string values: arrIncludes, arrIncludesAll, arrIncludesSome. Which implies that filtering on array-type column values would work, but it does not. Also, in the globalFilterFn callback passed into useReactTable, the function never runs with the columnId of the array-type column, so I can’t even manually write a filter function that can access the array-type value

This was driving me insane for awhile. My column value is an array and tried adding a filterFn function to my column def so I can hook in my filter logic for it. This was after trying to simply set it to arrIncludes since that implied it works on an array column. Nothing worked. After stumbling on this thread and flattening my array to a string it started searching the field but isn’t a perfect search:

{
  header: 'Tags',
  accessorFn: (row) => row.tags.join(','),
  cell: ({ row }) => <Tags values={row.original.tags} />
}

+1 for this issue

I used to be able to do a global search filter on an array column in v7.8.0, but now I cannot (v8.7.9).

The FilterFnOption type (for a filterFn of a ColumnDef) allows the string values: arrIncludes, arrIncludesAll, arrIncludesSome. Which implies that filtering on array-type column values would work, but it does not. Also, in the globalFilterFn callback passed into useReactTable, the function never runs with the columnId of the array-type column, so I can’t even manually write a filter function that can access the array-type value

Yes exactly, the globalFilterFn never runs and no feedback is provided, so it’s impossible to figure out this is the cause without finding this issue. No console logging from within, type warnings, debug settings on the hook, etc can help point the way.

My accessors were pointing to objects with the shape { value: any, error: boolean } so that the cell could access data via cell: (info) => info.getValue().value, and I could in the markup style the cells that have errors differently.

And just as a side note, as a newcomer to the library I have to say it seems very powerful but I am really struggling with the v8 documentation. v7/react-table seemed to have a bit more in terms of explanation and at least some of the examples were more focused on a specific topic rather than having 4 different table features on display at once.

after digging into this further i’ve found a much easier shortcut to enable this without changing the source code. However, i still think there is merit in my suggested improvement to the source code. As a user, I would expect that if i set the enableGlobalFilter to true for a column, that the column should be used by the global filter. Having that explicit declaration in the definition overridden is unexpected behavior.

But for anyone who’s looking for the quick workaround, you can modify the getColumnCanGlobalFilter option passed to the table creation like below. Make sure that any columns that you don’t want to be used have their enableGlobalFilter key set to false for them to be excluded from the global filter. All other columns, regardless of what you put for the enableGlobalFilter value, will return true and be included in the global filter

here’s the documentation: https://tanstack.com/table/latest/docs/api/features/global-filtering#getcolumncanglobalfilter

//example columns for country data
const columns = [
  { accessorKey: "name", header: "Name" },
  { accessorKey: "code", header: "Code" },
  {
    accessorKey: "capital",
    header: "Capital",
    enableGlobalFilter: false, //global filter will not apply
  },

  {
    id: "languages",
    header: "Languages",
    accessorFn: (row) => {
      return row.languages.map((lan) => lan.name)
    },
    enableGlobalFilter: true, //doesn't need to be set to true with modified "getColumnCanGlobalFilter" function
  },
]

  const table = useReactTable({
    data,
    columns,
    getCoreRowModel: getCoreRowModel(),
    getSortedRowModel: getSortedRowModel(),
    getFilteredRowModel: getFilteredRowModel(),
    globalFilterFn: "includesString", // or a custom fuzzyFilter
    getColumnCanGlobalFilter: (column) =>
      column.columnDef.enableGlobalFilter !== false,
    },
  })

Any updates on this? Or does the TanTable not support objects as values?

TanStack Table doesn’t encourage accessors resolving to objects if you care about sorting filtering, or grouping. Those only work by default with resolved primitive values.

That’s not to say you can’t render complex values in a column though. You can still have multiple values in a custom cell render and access any data in the data row via row.original

Hi @KevinVandy

Is there another way to get cell specific “extra information” into the cell renderer?

Basically what I’m trying to do is the following:

The object structure I want to render have this type:

type Cell<T> = {
  value: T
  href? string;
  target? string;
  tooltip? string;
}

When defining the columns (for simplicity the example only have one column):

type TableData = {
   name: Cell<string>;
}
const data: TableData[] = [
  {
     name: { value: 'John', href: 'www.google.com', target: '_blank', tooltip: 'Person John' }
  },
  {
     name: { value: 'Doe', href: 'www.google.com', target: '_blank', tooltip: 'Person Doe' }
  }
];
const columns = [
  {
     accessorKey: 'name', // If I put 'name.value' here the global filter function is called, but I loose access to href, target and tooltip
     header: 'Name',
     cell: CellRenderer, // this is a function that can handle rendering of links and tooltips
  }
];

It would be nice if the globalFilterFn just received the TableData object in the value property and you could implement your own filter fn. Setting the accessor to an object would mean that you can not use the build in filters. This is fine as the build in filters are for primitive values.

the root of this lies in the getCanGlobalFilter function called when the column is created in the table. basically the default table options getColumnCanGlobalFilter() function checks if the column’s resolved value is a string or a number. if it isn’t (in the case of an object or an array) it returns false . the below logic built into the createColumn function then resolves to false because its a bunch of and statements strung together.

i think adding the feature that allows a user to explicitly set enableGlobalFilter: true in the column definition object should allow the user to override the default number/string check which would allow the column to leveraged in the global filter. i’ve forked and tried this locally and it seems to work, even with some of the baked-in global filter functions (i.e., includesString, equals)

@KevinVandy - i realize that the package discourages object/arrays in the table, but i think this offers a decent compromise, as the current workarounds to get a non-primitive column to be recognized by the global filter are arduous. My guess is that users aren’t explicitly setting the enableGlobalFilter: true, (rather the use case is to set it to false to prevent it from being globally filtered), so this seems like a fairly safe way to enable the feature.

another way to implement the override is to alter the default getColumnCanGlobalFilter function to conditionally return values that are not strings or numbers, but i think the proposed solution is more straightforward and streamlined.

i think i can figure out how to open a pr request to submit the below change if its acceptable by maintainers

also, i should mention that i’ve tried this only with arrays of strings. i imagine you’d have to write a custom global filter function to appropriately access objects and their key/value pairs.

original code (table-core/src/features/GlobalFiltering.ts)

createColumn: <TData extends RowData>(
    column: Column<TData, unknown>,
    table: Table<TData>
  ): void => {
    column.getCanGlobalFilter = () => {
      return (
        (column.columnDef.enableGlobalFilter ?? true) &&
        (table.options.enableGlobalFilter ?? true) &&
        (table.options.enableFilters ?? true) &&
        (table.options.getColumnCanGlobalFilter?.(column) ?? true) &&
        !!column.accessorFn
      )
    }
  },

suggested improvement

createColumn: <TData extends RowData>(
    column: Column<TData, unknown>,
    table: Table<TData>
  ): void => {
    column.getCanGlobalFilter = () => {
      return (
        (column.columnDef.enableGlobalFilter ?? true) &&
        (table.options.enableGlobalFilter ?? true) &&
        (table.options.enableFilters ?? true) &&
        ((table.options.getColumnCanGlobalFilter?.(column) ?? true) ||
          (column.columnDef.enableGlobalFilter ? true : false)) &&
        !!column.accessorFn
      )
    }
  },

Thanks for the discussion. The accessorFn did it for me.

I’m working with a project where we have data that the user can modify, including adding columns. We’re using a solution to send the column definitions with the data from the server to the client, sometimes having to parse the data using a accessor-prop on a columdef field object. Looks something like this. Hope this helps someone some day.

# Data format defined in Python backend for a column header
  "last_used": {
            "title": "Last used", # Visible on the column
            "accessor": "last_used", # Way to get the value
            "type": "dateFromUnix", # Used when determening how to render the value
            "display": True, # If it's supposed to be in the table in the first place. Sometimes tags are excluded because they're added differently
            "hidden": False, # Should the col be hidden by default
            "priority": 4, # Order of column
            "editable": False # Is the content editable, e.g. uuid's are not editable
        },...]
// So in the columndef it works like this:
Object.values(Fields).forEach((field: fieldObject) => {
    if (field.hidden) {
      return
    }

    // The basecolumns already have for example a checkbox-column
    baseColumns.push({
      id: field.accessor,
      ...field.fieldAccessor,
      header: ({ column }) => {
        return (
          <Button
            variant="ghost"
            onClick={() => column.toggleSorting(column.getIsSorted() === "asc")}>
            {field.title}
            <ArrowUpDown className="ml-2 h-4 w-4" />
          </Button>
        )
      },
      cell: ({ row }) => {
        return parseDataFormat(field, row); // A custom function parsing the data according to it's type
      },
      enableGlobalFilter: true,
      accessorFn: (row) => {
        return row[field.accessor] // THIS FIXED THE PROBLEM
      }
    }