Method Convert

server/plpgsql/json.go:346–431

Convert converts the JSON statement into its output form.

()

// Convert converts the JSON statement into its output form.
func (stmt *plpgSQL_stmt_case) Convert() (block Block, err error) {
	// If the CASE statement has a main expression, start by assigning it to a variable so
	// we can evaluate it once and only once.
	if stmt.Expression.Expression.Query != "" {
		// TODO: pg_query_go creates the definitions for these variables, and
		//       ideally users shouldn't be able to reference them. We could
		//       update all the references to them (i.e. declaration, assignment,
		//       and WHEN block exprs) to change the name to include a \0 char to
		//       prevent users from referencing them or colliding with them.
		block.Body = append(block.Body, Assignment{
			VariableName: fmt.Sprintf("__Case__Variable_%d__", stmt.VarNo),
			Expression:   stmt.Expression.Expression.Query,
		})
	}

	// Record indexes of all the GOTO ops that jump to the very end of the case block so we
	// can update them later and plug in the correct offsets after we know the final size.
	var gotoEndOpsIndexes []int

	// Add operations for each WHEN statement...
	for _, stmt := range stmt.WhenList {
		when := stmt.When
		if when == nil {
			return Block{}, fmt.Errorf("case statement WHEN clause is nil")
		}

		// TODO: The generated expressions from pg_query_go uses double quotes
		//       around the variable name, which is valid for Postgres, but
		//       our engine doesn't currently resolve double-quoted strings to
		//       variables, so for now, we just extract the double quotes.
		expressionString := when.Expression.Expression.Query
		expressionString = strings.ReplaceAll(expressionString, `"`, "")

		convertedWhenBodyStatements, err := jsonConvertStatements(when.Body)
		if err != nil {
			return Block{}, err
		}

		block.Body = append(block.Body,
			If{
				Condition:  expressionString,
				GotoOffset: 2,
			},
			Goto{
				// This GOTO jumps to the next WHEN block, so step over all the statements
				// from this WHEN block, plus 1 for the GOTO op we add at the end of each
				// block, and plus 1 more to move to the next statement.
				Offset: int32(len(convertedWhenBodyStatements) + 1 + 1),
			})
		block.Body = append(block.Body, convertedWhenBodyStatements...)

		// Add a GOTO op to jump to the end of the entire CASE block, and record its position
		// in the statement block so we can update it later.
		block.Body = append(block.Body, Goto{})
		gotoEndOpsIndexes = append(gotoEndOpsIndexes, len(block.Body)-1)
	}

	if stmt.HasElse {