Method TypeCheck

postgres/parser/sem/tree/type_check.go:841–1012

TypeCheck implements the Expr interface.

(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
)

// TypeCheck implements the Expr interface.
func (expr *FuncExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error) {
	var searchPath sessiondata.SearchPath
	if semaCtx != nil {
		searchPath = semaCtx.SearchPath
	}
	def, err := expr.Func.Resolve(searchPath)
	if err != nil {
		return nil, err
	}

	if err := semaCtx.checkFunctionUsage(expr, def); err != nil {
		return nil, pgerror.Wrapf(err, pgcode.InvalidParameterValue,
			"%s()", def.Name)
	}
	if semaCtx != nil {
		// We'll need to remember we are in a function application to
		// generate suitable errors in checkFunctionUsage().  We cannot
		// set ctx.inFuncExpr earlier (in particular not before the call
		// to checkFunctionUsage() above) because the top-level FuncExpr
		// must be acceptable even if it is a SRF and
		// RejectNestedGenerators is set.
		defer func(semaCtx *SemaContext, prevFunc bool, prevWindow bool) {
			semaCtx.Properties.Derived.inFuncExpr = prevFunc
			semaCtx.Properties.Derived.InWindowFunc = prevWindow
		}(
			semaCtx,
			semaCtx.Properties.Derived.inFuncExpr,
			semaCtx.Properties.Derived.InWindowFunc,
		)
		semaCtx.Properties.Derived.inFuncExpr = true
		if expr.WindowDef != nil {
			semaCtx.Properties.Derived.InWindowFunc = true
		}
	}

	typedSubExprs, fns, err := typeCheckOverloadedExprs(ctx, semaCtx, desired, def.Definition, false, expr.Exprs...)
	if err != nil {
		return nil, pgerror.Wrapf(err, pgcode.InvalidParameterValue, "%s()", def.Name)
	}

	// If the function is an aggregate that does not accept null arguments and we
	// have arguments of unknown type, see if we can assign type string instead.
	// TODO(rytaft): If there are no overloads with string inputs, Postgres
	// chooses the overload with preferred type for the given category. For
	// example, float8 is the preferred type for the numeric category in Postgres.
	// To match Postgres' behavior, we should add that logic here too.
	if !def.NullableArgs && def.FunctionProperties.Class == AggregateClass {
		for i := range typedSubExprs {
			if typedSubExprs[i].ResolvedType().Family() == types.UnknownFamily {
				var filtered []overloadImpl
				for j := range fns {
					if fns[j].params().GetAt(i).Equivalent(types.String) {
						if filtered == nil {
							filtered = make([]overloadImpl, 0, len(fns)-j)
						}
						filtered = append(filtered, fns[j])