plpgsql: pass options struct to plpgsqlBuilder

This commit moves the bool arguments used when constructing a
`plpgsqlBuilder` instance to an options struct. This will simplify
adding new options in the future.

Informs #105240

Release note: None

Author: DrewKimball

pkg/sql/opt/optbuilder/create_function.go

@@ -427,8 +427,7 @@ func (b *Builder) buildCreateFunction(cf *tree.CreateRoutine, inScope *scope) (o
 		}
 
 		// Special handling for trigger functions.
-		buildSQL := true
-		isTriggerFn := false
+		var skipSQL, isTriggerFn bool
 		if funcReturnType.Identical(types.Trigger) {
 			// Trigger functions cannot have user-defined parameters. However, they do
 			// have a set of implicitly defined parameters.
@@ -449,17 +448,21 @@ func (b *Builder) buildCreateFunction(cf *tree.CreateRoutine, inScope *scope) (o
 
 			// Analysis of SQL expressions for trigger functions must be deferred
 			// until the function is bound to a trigger.
-			buildSQL = false
 			isTriggerFn = true
+			skipSQL = true
 		}
 
 		// We need to disable stable function folding because we want to catch the
 		// volatility of stable functions. If folded, we only get a scalar and lose
 		// the volatility.
+		options := basePLOptions().
+      SetIsProcedure(cf.IsProcedure).
+      SetIsTriggerFn(isTriggerFn).
+      SetSkipSQL(skipSQL)
 		b.factory.FoldingControl().TemporarilyDisallowStableFolds(func() {
 			plBuilder := newPLpgSQLBuilder(
-				b, cf.Name.Object(), stmt.AST.Label, nil /* colRefs */, routineParams, funcReturnType,
-				cf.IsProcedure, false /* isDoBlock */, isTriggerFn, buildSQL, nil, /* outScope */
+				b, options, cf.Name.Object(), stmt.AST.Label, nil /* colRefs */, routineParams,
+				funcReturnType, nil, /* outScope */
 			)
 			stmtScope = plBuilder.buildRootBlock(stmt.AST, bodyScope, routineParams)
 		})

pkg/sql/opt/optbuilder/create_trigger.go

@@ -244,9 +244,8 @@ func (b *Builder) buildFunctionForTrigger(
 	}
 	b.factory.FoldingControl().TemporarilyDisallowStableFolds(func() {
 		plBuilder := newPLpgSQLBuilder(
-			b, ct.FuncName.String(), stmt.AST.Label, nil /* colRefs */, triggerFuncParams, tableTyp,
-			false /* isProcedure */, false, /* isDoBlock */
-			true /* isTriggerFn */, true /* buildSQL */, nil, /* outScope */
+			b, basePLOptions().WithIsTriggerFn(), ct.FuncName.String(), stmt.AST.Label,
+			nil /* colRefs */, triggerFuncParams, tableTyp, nil, /* outScope */
 		)
 		funcScope = plBuilder.buildRootBlock(stmt.AST, funcScope, triggerFuncParams)
 	})

pkg/sql/opt/optbuilder/plpgsql.go

@@ -156,7 +156,8 @@ import (
 // not follow here, although they may be good routes for optimization in the
 // future.
 type plpgsqlBuilder struct {
-	ob *Builder
+	ob      *Builder
+	options plOptions
 
 	// colRefs, if non-nil, tracks the set of columns referenced by scalar
 	// expressions.
@@ -190,13 +191,68 @@ type plpgsqlBuilder struct {
 	outScope *scope
 
 	routineName  string
-	isProcedure  bool
-	isDoBlock    bool
-	isTriggerFn  bool
-	buildSQL     bool
 	identCounter int
 }
 
+// plOptions is a set of options that can be used to modify the behavior of the
+// PLpgSQL builder.
+type plOptions struct {
+	isProcedure bool
+	isDoBlock   bool
+	isTriggerFn bool
+
+	// skipSQL is true if SQL statements and expressions should not be built.
+	// This is used during trigger function creation.
+	skipSQL bool
+}
+
+// basePLOptions returns a new plOptions struct with default values.
+func basePLOptions() plOptions {
+	return plOptions{}
+}
+
+// WithIsProcedure returns a new plOptions struct with the isProcedure flag set
+// to true.
+func (opts plOptions) WithIsProcedure() plOptions {
+	opts.isProcedure = true
+	return opts
+}
+
+// SetIsProcedure returns a new plOptions struct with the isProcedure flag set
+// to the given value.
+func (opts plOptions) SetIsProcedure(isProcedure bool) plOptions {
+	opts.isProcedure = isProcedure
+	return opts
+}
+
+// WithIsDoBlock returns a new plOptions struct with the isDoBlock flag set to
+// true.
+func (opts plOptions) WithIsDoBlock() plOptions {
+	opts.isDoBlock = true
+	return opts
+}
+
+// WithIsTriggerFn returns a new plOptions struct with the isTriggerFn flag
+// set to true.
+func (opts plOptions) WithIsTriggerFn() plOptions {
+	opts.isTriggerFn = true
+	return opts
+}
+
+// SetIsTriggerFn returns a new plOptions struct with the isTriggerFn flag set
+// to the given value.
+func (opts plOptions) SetIsTriggerFn(isTriggerFn bool) plOptions {
+	opts.isTriggerFn = isTriggerFn
+	return opts
+}
+
+// SetSkipSQL returns a new plOptions struct with the skipSQL flag set to the
+// given value.
+func (opts plOptions) SetSkipSQL(skipSQL bool) plOptions {
+	opts.skipSQL = skipSQL
+	return opts
+}
+
 // routineParam is similar to tree.RoutineParam but stores the resolved type.
 type routineParam struct {
 	name  ast.Variable
@@ -206,24 +262,21 @@ type routineParam struct {
 
 func newPLpgSQLBuilder(
 	ob *Builder,
+	options plOptions,
 	routineName, rootBlockLabel string,
 	colRefs *opt.ColSet,
 	routineParams []routineParam,
 	returnType *types.T,
-	isProcedure, isDoBlock, isTriggerFn, buildSQL bool,
 	outScope *scope,
 ) *plpgsqlBuilder {
 	const initialBlocksCap = 2
 	b := &plpgsqlBuilder{
 		ob:          ob,
+		options:     options,
 		colRefs:     colRefs,
 		returnType:  returnType,
 		blocks:      make([]plBlock, 0, initialBlocksCap),
 		routineName: routineName,
-		isProcedure: isProcedure,
-		isDoBlock:   isDoBlock,
-		isTriggerFn: isTriggerFn,
-		buildSQL:    buildSQL,
 		outScope:    outScope,
 	}
 	// Build the initial block for the routine parameters, which are considered
@@ -320,7 +373,7 @@ func (b *plpgsqlBuilder) buildRootBlock(
 			s, param.name, &tree.CastExpr{Expr: tree.DNull, Type: param.typ}, noIndirection,
 		)
 	}
-	if b.isProcedure {
+	if b.options.isProcedure {
 		var tc transactionControlVisitor
 		ast.Walk(&tc, astBlock)
 		if tc.foundTxnControlStatement {
@@ -333,7 +386,7 @@ func (b *plpgsqlBuilder) buildRootBlock(
 					"transaction control statements in nested routines",
 				))
 			}
-			if b.isDoBlock {
+			if b.options.isDoBlock {
 				// Disallow transaction control statements in DO blocks for now.
 				panic(unimplemented.NewWithIssue(138704,
 					"transaction control statements in DO blocks",
@@ -521,7 +574,7 @@ func (b *plpgsqlBuilder) buildPLpgSQLStatements(stmts []ast.Statement, s *scope)
 				expr = b.makeReturnForOutParams()
 			} else if b.returnType.Family() == types.VoidFamily {
 				if expr != nil {
-					if b.isProcedure {
+					if b.options.isProcedure {
 						panic(returnWithVoidParameterProcedureErr)
 					} else {
 						panic(returnWithVoidParameterErr)
@@ -1006,7 +1059,7 @@ func (b *plpgsqlBuilder) buildPLpgSQLStatements(stmts []ast.Statement, s *scope)
 			if b.hasExceptionHandler() {
 				panic(txnControlWithExceptionErr)
 			}
-			if !b.isProcedure {
+			if !b.options.isProcedure {
 				panic(txnInUDFErr)
 			}
 			name := "_stmt_commit"
@@ -1425,7 +1478,7 @@ func (b *plpgsqlBuilder) handleIndirectionForAssign(
 
 	// We do not yet support qualifying a variable with a block label.
 	b.checkBlockLabelReference(elemName)
-	if !b.buildSQL {
+	if b.options.skipSQL {
 		// For lazy SQL evaluation, replace all expressions with NULL.
 		return memo.NullSingleton
 	}
@@ -2021,7 +2074,7 @@ func (b *plpgsqlBuilder) makeContinuation(conName string) continuation {
 		// continuation UDFs.
 		paramOrd := len(params)
 		col.setParamOrd(len(params))
-		if b.ob.insideFuncDef && b.isTriggerFn && paramOrd == triggerArgvColIdx {
+		if b.ob.insideFuncDef && b.options.isTriggerFn && paramOrd == triggerArgvColIdx {
 			// Due to #135311, we disallow references to the TG_ARGV param for now.
 			if !b.ob.evalCtx.SessionData().AllowCreateTriggerFunctionWithArgvReferences {
 				col.resolveErr = unimplementedArgvErr
@@ -2213,7 +2266,7 @@ func (b *plpgsqlBuilder) addBarrierIfVolatile(s *scope, expr opt.ScalarExpr) {
 // buildSQLExpr type-checks and builds the given SQL expression into a
 // ScalarExpr within the given scope.
 func (b *plpgsqlBuilder) buildSQLExpr(expr ast.Expr, typ *types.T, s *scope) opt.ScalarExpr {
-	if !b.buildSQL {
+	if b.options.skipSQL {
 		// For lazy SQL evaluation, replace all expressions with NULL.
 		return memo.NullSingleton
 	}
@@ -2250,7 +2303,7 @@ func (b *plpgsqlBuilder) buildSQLExpr(expr ast.Expr, typ *types.T, s *scope) opt
 // buildSQLStatement type-checks and builds the given SQL statement into a
 // RelExpr within the given scope.
 func (b *plpgsqlBuilder) buildSQLStatement(stmt tree.Statement, inScope *scope) (outScope *scope) {
-	if !b.buildSQL {
+	if b.options.skipSQL {
 		// For lazy SQL evaluation, replace all statements with a single row without
 		// any columns.
 		outScope = inScope.push()
@@ -2424,7 +2477,7 @@ func (b *plpgsqlBuilder) makeReturnForOutParams() tree.Expr {
 			exprs[i] = tree.DNull
 		}
 	}
-	if len(exprs) == 1 && !b.isProcedure {
+	if len(exprs) == 1 && !b.options.isProcedure {
 		// For procedures, even a single column is wrapped in a tuple.
 		return exprs[0]
 	}

pkg/sql/opt/optbuilder/routine.go

@@ -445,9 +445,9 @@ func (b *Builder) buildRoutine(
 		}
 		var expr memo.RelExpr
 		var physProps *physical.Required
+		options := basePLOptions().SetIsProcedure(isProc)
 		plBuilder := newPLpgSQLBuilder(
-			b, def.Name, stmt.AST.Label, colRefs, routineParams, f.ResolvedType(),
-			isProc, false /* isDoBlock */, false /* isTriggerFn */, true /* buildSQL */, outScope,
+			b, options, def.Name, stmt.AST.Label, colRefs, routineParams, f.ResolvedType(), outScope,
 		)
 		stmtScope := plBuilder.buildRootBlock(stmt.AST, bodyScope, routineParams)
 		rTyp := b.finalizeRoutineReturnType(f, stmtScope, inScope, oldInsideDataSource)
@@ -857,10 +857,10 @@ func (b *Builder) buildPLpgSQLDoBody(
 	do *plpgsqltree.DoBlock,
 ) (body memo.RelExpr, bodyProps *physical.Required) {
 	// Build an expression for each statement in the function body.
+	options := basePLOptions().WithIsProcedure().WithIsDoBlock()
 	plBuilder := newPLpgSQLBuilder(
-		b, doBlockRoutineName, do.Block.Label, nil /* colRefs */, nil /* routineParams */, types.Void,
-		true /* isProc */, true, /* isDoBlock */
-		false /* isTriggerFn */, true /* buildSQL */, nil, /* outScope */
+		b, options, doBlockRoutineName, do.Block.Label, nil, /* colRefs */
+		nil /* routineParams */, types.Void, nil, /* outScope */
 	)
 	// Allocate a fresh scope, since DO blocks do not take parameters or reference
 	// variables or columns from the calling context.

pkg/sql/opt/optbuilder/trigger.go

@@ -838,9 +838,8 @@ func (b *Builder) buildTriggerFunction(
 		panic(err)
 	}
 	plBuilder := newPLpgSQLBuilder(
-		b, resolvedDef.Name, stmt.AST.Label, nil /* colRefs */, params, tableTyp,
-		false /* isProc */, false, /* isDoBlock */
-		true /* isTriggerFn */, true /* buildSQL */, nil, /* outScope */
+		b, basePLOptions().WithIsTriggerFn(), resolvedDef.Name, stmt.AST.Label, nil, /* colRefs */
+		params, tableTyp, nil, /* outScope */
 	)
 	stmtScope := plBuilder.buildRootBlock(stmt.AST, triggerFuncScope, params)
 	udfDef.Body = []memo.RelExpr{stmtScope.expr}