Method sqlForName

runtime/metricsview/astexpr.go:717–784

(name string)

}

func (b *sqlExprBuilder) sqlForName(name string) (expr string, unnest bool, lookup *lookupMeta, err error) {
	// If node is nil, we are evaluating the expression against the underlying table.
	// In this case, we only allow filters to reference dimension names.
	if b.node == nil {
		// First, search for the dimension in the ASTs dimension fields (this also covers any computed dimension)
		for _, f := range b.ast.dimFields {
			if f.Name == name {
				// Note that we return "false" even though it may be an unnest dimension because it will already have been unnested since it's one of the dimensions included in the query.
				// So we can filter against it as if it's a normal dimension.
				return f.Expr, false, f.LookupMeta, nil
			}
		}

		// Second, search for the dimension in the metrics view's dimensions (since expressions are allowed to reference dimensions not included in the query)
		dim, err := b.ast.LookupDimension(name, b.visible)
		if err != nil {
			return "", false, nil, fmt.Errorf("invalid dimension reference %q: %w", name, err)
		}

		ex, err := b.ast.Dialect.MetricsViewDimensionExpression(dim)
		if err != nil {
			return "", false, nil, fmt.Errorf("invalid dimension reference %q: %w", name, err)
		}

		var lm *lookupMeta
		if dim.LookupTable != "" {
			var keyExpr string
			if dim.Column != "" {
				keyExpr = b.ast.Dialect.EscapeIdentifier(dim.Column)
			} else {
				keyExpr = dim.Expression
			}
			lm = &lookupMeta{
				table:    dim.LookupTable,
				keyExpr:  keyExpr,
				keyCol:   dim.LookupKeyColumn,
				valueCol: dim.LookupValueColumn,
			}
		}
		// Note: If dim.Unnest is true, we need to unnest it inside of the generated expression (because it's not part of the dimFields and therefore not unnested with a LATERAL JOIN).
		return ex, dim.Unnest, lm, nil
	}

	// Since node is not nil, we're in the context of a wrapped SELECT.
	// We only allow expressions against the node's dimensions and measures (not those in scope within sub-queries).

	// Check if it's a dimension name
	for _, f := range b.node.DimFields {
		if f.Name == name {
			// NOTE: We don't need to handle Unnest here because it's always applied at the innermost query (i.e. when node==nil).
			return f.Expr, false, nil, nil
		}
	}

	// Can't have expressions against a measure field unless it's a pseudo-HAVING clause (pseudo because we currently output it as a WHERE in an outer SELECT)
	if !b.pseudoHaving {
		return "", false, nil, fmt.Errorf("name %q in expression is not a dimension available in the current context", name)
	}