Method Next

server/node/trigger_execution.go:199–288

Next implements the interface sql.RowIter.

(ctx *sql.Context)

// Next implements the interface sql.RowIter.
func (t *triggerExecutionIter) Next(ctx *sql.Context) (sql.Row, error) {
	nextRow, err := t.source.Next(ctx)
	if err != nil {
		return nextRow, err
	}
	var oldRow sql.Row
	var newRow sql.Row
	switch t.split {
	case TriggerExecutionRowHandling_Old:
		oldRow = nextRow
	case TriggerExecutionRowHandling_OldNew:
		oldRow = nextRow[:len(t.sch)]
		newRow = nextRow[len(t.sch):]
	case TriggerExecutionRowHandling_NewOld:
		newRow = nextRow[:len(t.sch)]
		oldRow = nextRow[len(t.sch):]
	case TriggerExecutionRowHandling_New:
		newRow = nextRow
	}

	// TODO: handle other special variables
	triggerVars := make(map[string]any)
	if t.tgOp != "" {
		triggerVars["TG_OP"] = t.tgOp
	}

	for funcIdx, function := range t.functions {
		if t.whens[funcIdx].ID.IsValid() {
			whenValue, err := plpgsql.TriggerCall(ctx, t.whens[funcIdx], t.runner, t.sch, oldRow, newRow, triggerVars)
			if err != nil {
				if strings.Contains(err.Error(), "no valid cast for return value") {
					// TODO: this error should technically be caught during parsing, but interpreted functions don't
					//  have the ability to determine types during parsing yet (also applies to the same error below)
					return nil, fmt.Errorf("argument of WHEN must be type boolean")
				}
				return nil, err
			}
			whenBool, ok := whenValue.(bool)
			if !ok {
				return nil, fmt.Errorf("argument of WHEN must be type boolean")
			}
			if !whenBool {
				continue
			}
		}

		returnedValue, err := plpgsql.TriggerCall(ctx, function, t.runner, t.sch, oldRow, newRow, triggerVars)
		if err != nil {
			return nil, err
		}

		if returnedValue == nil {
			// a returned value of NULL on a BEFORE trigger means to not modify the row, so we return a signal error
			if t.timing == triggers.TriggerTiming_Before {
				return nil, sql.ErrRowEditCanceled.New()
			} else {
				return nextRow, nil
			}