plpgsql

type Assignment struct {
	VariableName  string
	Expression    string
	VariableIndex int32 // TODO: figure out what this is used for, probably to get around shadowed variables?
}

type Block struct {
	TriggerNew int32 // When non-zero, indicates that the NEW record exists for use with triggers
	TriggerOld int32 // When non-zero, indicates that the OLD record exists for use with triggers
	Variables  []Variable
	Records    []Record
	Body       []Statement
	Label      string
	IsLoop     bool
	// ContinueTargetOffset gives the loop's next-iteration operation, where a CONTINUE for this loop jumps, as
	// an offset from the body's first operation. It applies only when IsLoop is true, and the zero value suits
	// WHILE and plain LOOP, whose bodies begin with that step rather than with loop setup.
	ContinueTargetOffset int32
}

type DynamicExecute struct {
	Query  string
	Params []string
	Target string
	// TargetIsRecord states that Target names a single RECORD variable that receives the entire result row,
	// rather than a comma-separated list of scalar variables that each receive one column.
	TargetIsRecord bool
}

type ExecuteSQL struct {
	Statement string
	Target    string
	// TargetIsRecord states that Target names a single RECORD variable that receives the entire result row,
	// rather than a comma-separated list of scalar variables that each receive one column.
	TargetIsRecord bool
	// SetsFound states that the statement updates the built-in FOUND variable. PostgreSQL limits that to
	// statements carrying an INTO clause and to data-modifying statements. Everything else leaves FOUND
	// as it was, a utility statement such as CREATE TABLE in particular.
	SetsFound bool
}

type ForQueryInit struct {
	CursorName string
	Query      string
}

type ForQueryNext struct {
	CursorName string
	RecordVar  string
	GotoOffset int32
}

type Goto struct {
	Offset         int32
	Label          string
	NearestScopeOp bool
}

type If struct {
	Condition  string
	GotoOffset int32
	// IsLoopCondition marks this as the conditional jump that advances an integer FOR loop, whose result
	// is the only record of the loop having run its body.
	IsLoopCondition bool
}

type InterpretedFunction interface {
	ApplyBindings(ctx *sql.Context, stack InterpreterStack, stmt string, bindings []string, enforceType bool) (newStmt string, varFound bool, err error)
	GetAllNames() []string
	GetOutputParameterNamesAndTypes() ([]string, []*pgtypes.DoltgresType)
	GetInputParameterNamesAndTypes() ([]string, []*pgtypes.DoltgresType)
	GetReturn() *pgtypes.DoltgresType
	GetStatements() []InterpreterOperation
	QueryMultiReturn(ctx *sql.Context, stack InterpreterStack, stmt string, bindings []string) (schema sql.Schema, rows []sql.Row, err error)
	QueryRowReturn(ctx *sql.Context, stack InterpreterStack, stmt string, targetTypes []*pgtypes.DoltgresType, bindings []string) (row sql.Row, ok bool, err error)
	QuerySingleReturn(ctx *sql.Context, stack InterpreterStack, stmt string, targetType *pgtypes.DoltgresType, bindings []string) (val any, err error)
	// IsSRF returns whether the function is a set returning function, meaning whether the
	// function returns one or more rows as a result.
	IsSRF() bool
}

type InterpreterOperation struct {
	OpCode        OpCode
	PrimaryData   string            // This will represent the "main" data, such as the query for PERFORM, expression for IF, etc.
	SecondaryData []string          // This represents auxiliary data, such as bindings, strictness, etc.
	Target        string            // This is the variable that will store the results (if applicable)
	Index         int               // This is the index that should be set for operations that move the function counter
	Options       map[string]string // This is extra data for operations that need it
}

type InterpreterScopeDetails struct {
	// contains filtered or unexported fields
}

type InterpreterStack struct {
	// contains filtered or unexported fields
}

type InterpreterVariableReference struct {
	Type  *pgtypes.DoltgresType
	Value *any
}

type NoticeLevel uint8

type NoticeOptionType uint8

type OpCode uint16

type Perform struct {
	Statement string
}

type Raise struct {
	Level   string
	Message string
	Params  []string
	Options map[string]string
}

type Record struct {
	Name   string
	Fields []string
	// IsTriggerRecord is true for the NEW and OLD records of a trigger function. Those are created by the
	// trigger invocation rather than by the function body, so they are not declared when the block is entered.
	IsTriggerRecord bool
}

type Return struct {
	Expression string
}

type ReturnQuery struct {
	Query string
}

type Statement interface {
	// OperationSize reports the number of operations that the statement will convert to.
	OperationSize() int32
	// AppendOperations adds the statement to the operation slice.
	AppendOperations(ops *[]InterpreterOperation, stack *InterpreterStack) error
}

type Variable struct {
	Name        string
	Type        string
	IsParameter bool
	Default     string
}