Why Big Tables behave differently
A regular Glide Table is small enough that your app loads all of its rows, so computed columns can look at every row. A Big Table can hold millions of rows, so your app only ever loads the rows it needs and asks the database to do the heavy lifting. Anything the database can do for you works at full scale. Anything it can’t gets limited or isn’t supported — that’s where all the rules below come from.
1. The two groups of computed columns
Every rule in this article comes down to whether a computed column is in the supported group or the unsupportedgroup. This list is complete.
✅ Supported computed columns (work at full scale in filters, sorts, and rollups):
Math
If → Then → Else
Make Array
Split Text
Template — only if the template text is fixed (it can insert basic columns, but not other computed columns)
Lookup — only in one narrow case: it goes through a single relation between two Big Tables, both matching columns are basic columns, and the value being looked up is a basic column
❌ Unsupported computed columns (can’t be used in filters, sorts, or full-scale rollups):
Relation
Rollup
Joined List
Query
Single Value
Lookup — any configuration outside the narrow case above
Template — when built from other computed columns
Distance
Generate Image
Construct URL
Experimental Code
All integration/plugin columns — this includes JavaScript, JSON columns, AI columns (Generate Text, etc.), and every other column added from an integration
One extra rule that applies on top of this: any column whose value comes from another table counts as unsupported, even if its type is in the supported list — (Chained lookups between. (Big Tables — ‘Lookups of Lookups’ — is not currently available.)
2. Filtering and sorting
In a Big Table, you can filter, sort, and search by:
Any basic column (Text, Number, Date, Boolean, and the other data types)
Any supported computed column from the list in section 1
You cannot filter or sort by any unsupported computed column from the list in section 1.
3. Rollups and Joined Lists
This is where most of the confusion has been, so here’s the precise rule:
Rollups over basic columns are calculated by the database. They are exact and have no row limit — a Sum over 5 million rows is fine.
Rollups over supported computed columns (section 1) also run at full scale with no limit.
Rollups over unsupported computed columns (section 1) still work, but they only look at the first 100 rows. Glide shows a warning on the column when this applies: “This rollup is limited to 100 rows and will give incorrect results if there are more rows than that.” If you see that warning, don’t trust the number on large tables.
Rollups of Rollups are not supported in Big Tables.
Joined List columns follow exactly the same rules as Rollups.
One special case: tables connected from BigQuery don’t support Rollups at all.
4. Lookups
Lookups through Relations and Query columns work.
A Lookup through a multi-row relation on a Big Table will only return the value from the first matching row, not all of them.
A Lookup only counts as “supported” (usable in filters, sorts, and full-scale rollups) in the narrow case described in section 1.
Lookups of Lookups (chaining across tables) is not currently available.
Lookups that fall outside these rules behave like rollups over unsupported columns: they work, but only against the first 100 rows.
5. Relations
Relations to Big Tables work well, but both columns being matched must be basic columns or supported computed columns (section 1). You can’t build a relation using a JavaScript or Rollup column as the matching key.
You can’t use a Relation column itself as a filter or sort in a Big Table.
6. Query columns
The Query column is designed for Big Tables and is usually the best tool. A few things to know:
If you don’t set a limit, a Query returns at most 1,000 rows by default.
You can only sort by one column, and it must be a basic or supported computed column (section 1).
Some filter options aren’t available: conditions like “array includes,” special values (such as the current date/time), and conditions on unsupported computed columns.
You can’t point a Query at another Query (no query-of-a-query), and you can’t roll up a Query result that’s already a rollup.
7. Single Value columns
A Single Value column cannot point directly at a Big Table.
Through a relation to a Big Table, only the “First” option works. “Last,” “Random,” and “From start/end” are not supported.
⚠️ Heads up in Workflows: if you use an unsupported Single Value configuration in a workflow, the editor currently doesn’t show an error — it just won’t produce a value. In particular, you can’t use a Single Value → whole row to pick the target row of a Set Column Values step. Use a Query column limited to 1 row instead.
8. Actions and integrations
Delete Row: you can’t delete Big Table rows through a multi-row relation. Deleting through a single relation, or deleting the current row, works fine.
User Profiles: a Big Table can’t be your User Profiles table. Use a regular table for user data.
Generate CSV: doesn’t accept a Big Table as its source. Workarounds: build the CSV from a Query/Joined List (mind the limits above), or export via the Glide API with an external tool like Make.
Quick reference
I want to… | Works at full scale? |
Filter/sort by basic columns | ✅ Yes |
Filter/sort by supported computed columns (section 1) | ✅ Yes |
Filter/sort by unsupported computed columns (section 1) | ❌ No |
Rollup over basic or supported computed columns | ✅ Yes, exact, no limit |
Rollup over unsupported computed columns | ⚠️ First 100 rows only (with warning) |
Lookup first matching value | ✅ Yes |
Lookup all matching values (multi-lookup) | ⚠️ Returns first row only |
Single Value → First via relation | ✅ Yes |
Single Value → anything else | ❌ No |
Query with filter + sort + limit | ✅ Yes (1,000-row default limit) |
Delete via multi-relation | ❌ No (single relation is fine) |