The Metadata API is a GraphQL graph of Tableau content (workbooks, sheets, dashboards,
datasources, fields) and, with the Data Management add-on, physical assets (databases,
tables, columns) and their upstream/downstream lineage.

How to write a correct query:
- Filters are EXACT and case-sensitive: `filter: {name: "X"}` or `filter: {nameWithin: ["X","Y"]}`
  (nameWithin is the only multi/OR match; there is NO substring or regex).
- Every list field has a `<name>Connection` variant with `first`/`offset`/`after` + `pageInfo`
  (page size max 1000). Keep one query under ~20,000 nodes; narrow filters and page.
- Fields is an interface; branch with `__typename` and inline fragments
  (`... on ColumnField { columns { name } }`, `... on CalculatedField { formula }`).
- Reach a field's owning workbook via `datasource { ... on EmbeddedDatasource { workbook { name } } }`.
- `downstream*` fields (downstreamWorkbooks/Owners, external tables/columns) need Data Management
  (Tableau Catalog) and are often empty otherwise; then resolve via core lineage
  (referencedByFields -> sheets -> workbook), or just call the `where_used` tool.

Entry points include: workbooks, sheets, dashboards, publishedDatasources, embeddedDatasources,
fields, columnFields, calculatedFields, columns, databaseTables, customSQLTables, databases,
flows, tableauUsers, dataQualityWarnings. Call `lineage_examples` for ready-made query templates
and a schema cheat-sheet, or `introspect_schema` to inspect any type's exact fields.

Read-only: mutation and subscription operations are rejected. If a query exceeds the
~20,000-node limit, the response is flagged with `partial_results: true` and a `warning`
(it does NOT auto-page an arbitrary query) so you never mistake a truncated result for a
complete one.

With no argument: returns every Query entry point (with its args) and the full list of
type names. With `type_name` (e.g. "Column", "Workbook", "DatabaseTable", "CalculatedField"):
returns that type's fields, their result types, and args, so you can write a correct query
against exactly what this server exposes.

Categories: impact, provenance, calc, datasource, search, inventory, governance, ownership.
Pass one to filter; omit to get them all. Each example has: question, graphql, variables, notes.

`names` are EXACT, case-sensitive names of any of: a Snowflake/DB column, a Tableau
field or alias, or a database table. Pass several to check them in one call. Results
group by workbook, showing how each matched (column / field / whole table, with schema
and source table) and which worksheets use it.

This uses CORE lineage (referencedByFields -> field.sheets -> workbook, and
field.datasource -> workbook), so it works even without the Data Management add-on where
`downstreamWorkbooks` is empty. For other shapes of question, use `graphql_query`.

This is the "what breaks if I change/drop this?" tool. Unlike `where_used` (one core-lineage
hop), it follows the whole dependency chain — a calc built on a calc built on the column is
included. `name` is exact and case-sensitive. Workbooks are derived from downstream
sheets/dashboards (the flat downstreamWorkbooks edge is unreliable). If it returns nothing on a
site without Data Management, the transitive lineage may not be indexed there — use `where_used`
for the direct references.

Searches workbooks, published datasources, and database tables by default. Pass `types` to
choose from: "workbook", "datasource", "table", "field", "column". Returns matches grouped by
type. It pages through content client-side, so on a very large site it scans the first ~1200
of each type and says so in `note`; once you know the exact name, prefer `graphql_query` or `where_used`.