sql/workload: add triggers to the random schema workload

Added coverage for `CREATE TRIGGER` and `DROP TRIGGER` to
the Random Schema Changer Workload.

Fixes: cockroachdb#146580
Epic: CRDB-42942
Release note: none

Author: Dedej-Bergin

pkg/workload/schemachange/operation_generator.go

@@ -4432,6 +4432,7 @@ FROM
 	})
 	opStmt.potentialExecErrors.addAll(codesWithConditions{
 		{pgcode.InvalidFunctionDefinition, hasFuncRefs},
+		{pgcode.FeatureNotSupported, true},
 	})
 
 	return opStmt, nil
@@ -5338,3 +5339,160 @@ func (og *operationGenerator) randUser(ctx context.Context, tx pgx.Tx) (string,
 	// There should always be at least one user.
 	return "", errors.New("no users found in the database")
 }
+
+// createTrigger generates a CREATE TRIGGER statement.
+func (og *operationGenerator) createTrigger(ctx context.Context, tx pgx.Tx) (*opStmt, error) {
+	tableName, err := og.randTable(ctx, tx, og.pctExisting(true), "")
+	if err != nil {
+		return nil, err
+	}
+
+	tableExists, err := og.tableExists(ctx, tx, tableName)
+	if err != nil {
+		return nil, err
+	}
+
+	// First, ensure the trigger_log table exists
+	_, err = tx.Exec(ctx, `
+CREATE TABLE IF NOT EXISTS trigger_log (
+    changed_at TIMESTAMP DEFAULT current_timestamp
+)`)
+	if err != nil {
+		return nil, err
+	}
+
+	// Create TRIGGER statement components
+	triggerActionTime := "BEFORE"
+	if og.randIntn(2) == 1 {
+		triggerActionTime = "AFTER"
+	}
+
+	eventTypes := []string{"INSERT", "UPDATE", "DELETE"}
+	numEvents := og.randIntn(3) + 1 // 1-3 events
+	events := make([]string, 0, numEvents)
+	eventsSet := make(map[string]bool)
+
+	for i := 0; i < numEvents; i++ {
+		eventIndex := og.randIntn(len(eventTypes))
+		event := eventTypes[eventIndex]
+		if !eventsSet[event] {
+			events = append(events, event)
+			eventsSet[event] = true
+		}
+	}
+
+	// Join events with OR
+	eventClause := strings.Join(events, " OR ")
+
+	triggerName := fmt.Sprintf("trigger_%s", og.newUniqueSeqNumSuffix())
+
+	// Build the SQL statement
+	var sqlStatement strings.Builder
+	sqlStatement.WriteString(fmt.Sprintf("CREATE TRIGGER %s %s %s ON %s FOR EACH ROW EXECUTE FUNCTION log_change_timestamp()",
+		triggerName, triggerActionTime, eventClause, tableName))
+
+	og.LogMessage(fmt.Sprintf("createTrigger: %s", sqlStatement.String()))
+
+	opStmt := makeOpStmt(OpStmtDDL)
+	opStmt.sql = sqlStatement.String()
+
+	opStmt.expectedExecErrors.addAll(codesWithConditions{
+		{code: pgcode.FeatureNotSupported, condition: !og.useDeclarativeSchemaChanger},
+		{code: pgcode.UndefinedTable, condition: !tableExists},
+	})
+
+	opStmt.potentialExecErrors.addAll(codesWithConditions{
+		{code: pgcode.UndefinedFunction, condition: true},
+	})
+
+	return opStmt, nil
+}
+
+// dropTrigger generates a DROP TRIGGER statement.
+func (og *operationGenerator) dropTrigger(ctx context.Context, tx pgx.Tx) (*opStmt, error) {
+	// Find an existing trigger
+	triggerWithInfo, triggerExists, err := findExistingTrigger(ctx, tx, og)
+	if err != nil {
+		return nil, err
+	}
+	if !triggerExists {
+
+		// Build the SQL statement
+		var sqlStatement strings.Builder
+		sqlStatement.WriteString(`DROP TRIGGER dummy_trigger ON dummy_table`)
+
+		// Set up expected errors since we know this trigger doesn't exist
+		opStmt := makeOpStmt(OpStmtDDL)
+		opStmt.sql = sqlStatement.String()
+
+		opStmt.expectedExecErrors.add(pgcode.UndefinedTable)
+
+		og.LogMessage(fmt.Sprintf("dropTrigger (non-existent): %s", sqlStatement.String()))
+
+		return opStmt, nil
+	}
+
+	// Build the SQL statement
+	var sqlStatement strings.Builder
+	sqlStatement.WriteString(fmt.Sprintf("DROP TRIGGER %s ON %s", triggerWithInfo.triggerName, &triggerWithInfo.table))
+
+	// Construct DROP TRIGGER statement
+	og.LogMessage(fmt.Sprintf("dropTrigger: %s", sqlStatement.String()))
+
+	opStmt := makeOpStmt(OpStmtDDL)
+	opStmt.sql = sqlStatement.String()
+
+	return opStmt, nil
+}
+
+// triggerInfo contains information about a trigger.
+type triggerInfo struct {
+	table       tree.TableName
+	triggerName string
+}
+
+// findExistingTrigger returns a triggerInfo struct with the qualified table name and trigger name.
+// It also returns a boolean indicating whether a trigger was found.
+func findExistingTrigger(
+	ctx context.Context, tx pgx.Tx, og *operationGenerator,
+) (*triggerInfo, bool, error) {
+	var triggerWithInfo triggerInfo
+	triggerExists := false
+
+	// Query to find all triggers in the database using system tables
+	triggerQuery := `
+		SELECT
+			ns.name AS schema_name,
+			crdb_internal.pb_to_json('descriptor', d.descriptor) -> 'table' ->> 'name' AS table_name,
+			trigger->>'name' AS trigger_name
+		FROM system.descriptor AS d
+		JOIN system.namespace AS ns
+			ON (crdb_internal.pb_to_json('descriptor', d.descriptor) -> 'table' ->> 'unexposedParentSchemaId')::INT = ns.id
+		JOIN LATERAL json_array_elements(
+			crdb_internal.pb_to_json('descriptor', d.descriptor) -> 'table' -> 'triggers'
+		) AS trigger ON TRUE
+		WHERE (crdb_internal.pb_to_json('descriptor', d.descriptor) -> 'table' -> 'triggers') IS NOT NULL
+		ORDER BY random()
+		LIMIT 1
+	`
+
+	var schemaName, tableName, triggerName string
+	err := tx.QueryRow(ctx, triggerQuery).Scan(&schemaName, &tableName, &triggerName)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return nil, false, nil
+		}
+		return nil, false, err
+	}
+
+	triggerWithInfo = triggerInfo{
+		table: tree.MakeTableNameFromPrefix(tree.ObjectNamePrefix{
+			SchemaName:     tree.Name(schemaName),
+			ExplicitSchema: true,
+		}, tree.Name(tableName)),
+		triggerName: triggerName,
+	}
+	triggerExists = true
+
+	return &triggerWithInfo, triggerExists, nil
+}

pkg/workload/schemachange/optype.go

@@ -127,6 +127,7 @@ const (
 	createTableAs       // CREATE TABLE <table> AS <def>
 	createView          // CREATE VIEW <view> AS <def>
 	createFunction      // CREATE FUNCTION <function> ...
+	createTrigger       // CREATE TRIGGER <trigger> {...} ON <table> EXECUTE FUNCTION <function>()
 
 	// COMMENT ON ...
 
@@ -140,6 +141,7 @@ const (
 	dropSchema   // DROP SCHEMA <schema>
 	dropSequence // DROP SEQUENCE <sequence>
 	dropTable    // DROP TABLE <table>
+	dropTrigger  // DROP TRIGGER <trigger> ON <table>
 	dropView     // DROP VIEW <view>
 
 	// Unimplemented operations. TODO(sql-foundations): Audit and/or implement these operations.
@@ -246,6 +248,7 @@ var opFuncs = []func(*operationGenerator, context.Context, pgx.Tx) (*opStmt, err
 	createSequence:                    (*operationGenerator).createSequence,
 	createTable:                       (*operationGenerator).createTable,
 	createTableAs:                     (*operationGenerator).createTableAs,
+	createTrigger:                     (*operationGenerator).createTrigger,
 	createTypeEnum:                    (*operationGenerator).createEnum,
 	createTypeComposite:               (*operationGenerator).createCompositeType,
 	createView:                        (*operationGenerator).createView,
@@ -255,6 +258,7 @@ var opFuncs = []func(*operationGenerator, context.Context, pgx.Tx) (*opStmt, err
 	dropSchema:                        (*operationGenerator).dropSchema,
 	dropSequence:                      (*operationGenerator).dropSequence,
 	dropTable:                         (*operationGenerator).dropTable,
+	dropTrigger:                       (*operationGenerator).dropTrigger,
 	dropView:                          (*operationGenerator).dropView,
 	renameIndex:                       (*operationGenerator).renameIndex,
 	renameSequence:                    (*operationGenerator).renameSequence,
@@ -301,6 +305,7 @@ var opWeights = []int{
 	createSequence:                    1,
 	createTable:                       10,
 	createTableAs:                     1,
+	createTrigger:                     1,
 	createTypeEnum:                    1,
 	createTypeComposite:               1,
 	createView:                        1,
@@ -310,6 +315,7 @@ var opWeights = []int{
 	dropSchema:                        1,
 	dropSequence:                      1,
 	dropTable:                         1,
+	dropTrigger:                       1,
 	dropView:                          1,
 	renameIndex:                       1,
 	renameSequence:                    1,
@@ -342,11 +348,13 @@ var opDeclarativeVersion = map[opType]clusterversion.Key{
 	createPolicy:                      clusterversion.V25_2,
 	createSchema:                      clusterversion.MinSupported,
 	createSequence:                    clusterversion.MinSupported,
+	createTrigger:                     clusterversion.MinSupported,
 	dropFunction:                      clusterversion.MinSupported,
 	dropIndex:                         clusterversion.MinSupported,
 	dropPolicy:                        clusterversion.V25_2,
 	dropSchema:                        clusterversion.MinSupported,
 	dropSequence:                      clusterversion.MinSupported,
 	dropTable:                         clusterversion.MinSupported,
+	dropTrigger:                       clusterversion.MinSupported,
 	dropView:                          clusterversion.MinSupported,
 }

pkg/workload/schemachange/optype_string.go

@@ -359,6 +359,54 @@ func (s *schemaChange) setClusterSettings(ctx context.Context, url string) (err
 			return errors.WithStack(err)
 		}
 	}
+
+	// First, ensure the trigger_log table exists
+	_, err = conn.Exec(ctx, `
+CREATE TABLE IF NOT EXISTS trigger_log (
+    changed_at TIMESTAMP DEFAULT current_timestamp
+)`)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	/*	// Save the current declarative schema changer setting
+		var originalDSCValue string
+		err = conn.QueryRow(ctx, `SHOW use_declarative_schema_changer`).Scan(&originalDSCValue)
+		if err != nil {
+			return errors.WithStack(err)
+		}
+
+		// Temporarily disable declarative schema changer for function creation
+		_, err = conn.Exec(ctx, `SET use_declarative_schema_changer=off`)
+		if err != nil {
+			return errors.WithStack(err)
+		}*/
+
+	// Create the function with legacy schema changer
+	_, err = conn.Exec(ctx, `
+CREATE OR REPLACE FUNCTION log_change_timestamp()
+RETURNS TRIGGER AS $$
+BEGIN
+    INSERT INTO trigger_log
+    VALUES (current_timestamp);
+    RETURN NULL;
+END;
+$$ LANGUAGE PLpgSQL`)
+	if err != nil {
+		/*		// Restore original setting even if function creation fails
+				_, restoreErr := conn.Exec(ctx, fmt.Sprintf(`SET use_declarative_schema_changer=%s`, originalDSCValue))
+				if restoreErr != nil {
+					return errors.CombineErrors(err, restoreErr)
+				}*/
+		return errors.WithStack(err)
+	}
+
+	/*	// Restore the original declarative schema changer setting
+		_, err = conn.Exec(ctx, fmt.Sprintf(`SET use_declarative_schema_changer=%s`, originalDSCValue))
+		if err != nil {
+			return errors.WithStack(err)
+		}*/
+
 	return nil
 }