What causes "invalid filter name: %s" in temporalio/temporal?

Rewrite the comparison so a supported column (WorkflowId, RunId, CloseTime, etc.) is on the left side

invalid filter name: %s

Error message

invalid filter name: %s

What it means

convertComparisonExpr in the gcloud archiver query parser requires the left side of every comparison to be a sqlparser.ColName (a recognized filter column like WorkflowId or CloseTime). If the left operand is not a column (e.g. a literal, function call, or arithmetic expression), it returns 'invalid filter name: %s' with the SQL-rendered operand.

Source

Thrown at common/archiver/gcloud/query_parser.go:109

		return errors.New("only comparison and \"and\" expression is supported")
	}
}

func (p *queryParser) convertParenExpr(parenExpr *sqlparser.ParenExpr, parsedQuery *parsedQuery) error {
	return p.convertWhereExpr(parenExpr.Expr, parsedQuery)
}

func (p *queryParser) convertAndExpr(andExpr *sqlparser.AndExpr, parsedQuery *parsedQuery) error {
	if err := p.convertWhereExpr(andExpr.Left, parsedQuery); err != nil {
		return err
	}
	return p.convertWhereExpr(andExpr.Right, parsedQuery)
}

func (p *queryParser) convertComparisonExpr(compExpr *sqlparser.ComparisonExpr, parsedQuery *parsedQuery) error {
	colName, ok := compExpr.Left.(*sqlparser.ColName)
	if !ok {
		return fmt.Errorf("invalid filter name: %s", sqlparser.String(compExpr.Left))
	}
	colNameStr := sqlparser.String(colName)
	op := compExpr.Operator
	valExpr, ok := compExpr.Right.(*sqlparser.SQLVal)
	if !ok {
		return fmt.Errorf("invalid value: %s", sqlparser.String(compExpr.Right))
	}
	valStr := sqlparser.String(valExpr)

	switch colNameStr {
	case WorkflowID:
		val, err := sqlquery.ExtractStringValue(valStr)
		if err != nil {
			return err
		}
		if op != "=" {
			return fmt.Errorf("only operation = is support for %s", WorkflowID)
		}

View on GitHub (pinned to bde624efd1)

Solutions

Rewrite the comparison so a supported column (WorkflowId, RunId, CloseTime, etc.) is on the left side
Remove function calls or arithmetic from the WHERE clause — only literal column comparisons are supported
Use the supported operators (= for IDs, range operators for CloseTime) as documented

Example fix

// before
WHERE UPPER(WorkflowId) = 'mywf'
// after
WHERE WorkflowId = 'mywf'

Defensive patterns

Strategy: validation

Validate before calling

// Keep only simple col-op-value comparisons on the left:
// valid:   WorkflowId = 'x'
// invalid: UPPER(WorkflowId) = 'x'  /  'x' = WorkflowId
if strings.ContainsAny(query, "()+") { // heuristic: expressions unsupported
  return errors.New("archive query must compare a plain column to a literal")
}

Type guard

func isSimpleColumnComparison(where string) bool {
  return !strings.Contains(where, "(") && knownColumns[leftToken(where)]
}

Try / catch

_, err := client.ArchiveQuery(ctx, req)
if err != nil && strings.Contains(err.Error(), "invalid filter name") {
  return fmt.Errorf("unsupported WHERE expression in %q: %w", req.Query, err)
}

Prevention

Put the filter column first, unmodified by functions or arithmetic
Restrict query builders to the documented filter keys
Validate queries against the archiver grammar before submitting

When it happens

Trigger: Issuing an archive search query whose WHERE clause compares something other than a plain column on the left, e.g. `WHERE 'wf-id' = WorkflowId`, `WHERE UPPER(WorkflowId) = 'x'`, or `WHERE CloseTime + 1 > 100`.

Common situations: Users copying standard-SQL queries into the archiver search box; expressions and functions are not supported — only simple column-op-value comparisons on known filter keys.

Related errors

AI-assisted analysis of temporalio/temporal@bde624efd1 (2026-09-01). Data as JSON: /api/errors/1c6541e46a31e062. Report an issue: GitHub.