state_version.sql.go

// Code generated by pggen. DO NOT EDIT.

package pggen

import (
	"context"
	"fmt"

	"github.com/jackc/pgconn"
	"github.com/jackc/pgtype"
	"github.com/jackc/pgx/v4"
)

const insertStateVersionSQL = `INSERT INTO state_versions (
    state_version_id,
    created_at,
    serial,
    state,
    status,
    workspace_id
) VALUES (
    $1,
    $2,
    $3,
    $4,
    $5,
    $6
);`

type InsertStateVersionParams struct {
	ID          pgtype.Text
	CreatedAt   pgtype.Timestamptz
	Serial      pgtype.Int4
	State       []byte
	Status      pgtype.Text
	WorkspaceID pgtype.Text
}

// InsertStateVersion implements Querier.InsertStateVersion.
func (q *DBQuerier) InsertStateVersion(ctx context.Context, params InsertStateVersionParams) (pgconn.CommandTag, error) {
	ctx = context.WithValue(ctx, "pggen_query_name", "InsertStateVersion")
	cmdTag, err := q.conn.Exec(ctx, insertStateVersionSQL, params.ID, params.CreatedAt, params.Serial, params.State, params.Status, params.WorkspaceID)
	if err != nil {
		return cmdTag, fmt.Errorf("exec query InsertStateVersion: %w", err)
	}
	return cmdTag, err
}

// InsertStateVersionBatch implements Querier.InsertStateVersionBatch.
func (q *DBQuerier) InsertStateVersionBatch(batch genericBatch, params InsertStateVersionParams) {
	batch.Queue(insertStateVersionSQL, params.ID, params.CreatedAt, params.Serial, params.State, params.Status, params.WorkspaceID)
}

// InsertStateVersionScan implements Querier.InsertStateVersionScan.
func (q *DBQuerier) InsertStateVersionScan(results pgx.BatchResults) (pgconn.CommandTag, error) {
	cmdTag, err := results.Exec()
	if err != nil {
		return cmdTag, fmt.Errorf("exec InsertStateVersionBatch: %w", err)
	}
	return cmdTag, err
}

const updateStateSQL = `UPDATE state_versions
SET state = $1, status = 'finalized'
WHERE state_version_id = $2;`

// UpdateState implements Querier.UpdateState.
func (q *DBQuerier) UpdateState(ctx context.Context, state []byte, stateVersionID pgtype.Text) (pgconn.CommandTag, error) {
	ctx = context.WithValue(ctx, "pggen_query_name", "UpdateState")
	cmdTag, err := q.conn.Exec(ctx, updateStateSQL, state, stateVersionID)
	if err != nil {
		return cmdTag, fmt.Errorf("exec query UpdateState: %w", err)
	}
	return cmdTag, err
}

// UpdateStateBatch implements Querier.UpdateStateBatch.
func (q *DBQuerier) UpdateStateBatch(batch genericBatch, state []byte, stateVersionID pgtype.Text) {
	batch.Queue(updateStateSQL, state, stateVersionID)
}

// UpdateStateScan implements Querier.UpdateStateScan.
func (q *DBQuerier) UpdateStateScan(results pgx.BatchResults) (pgconn.CommandTag, error) {
	cmdTag, err := results.Exec()
	if err != nil {
		return cmdTag, fmt.Errorf("exec UpdateStateBatch: %w", err)
	}
	return cmdTag, err
}

const discardPendingStateVersionsByWorkspaceIDSQL = `UPDATE state_versions
SET status = 'discarded'
WHERE workspace_id = $1
AND status = 'pending';`

// DiscardPendingStateVersionsByWorkspaceID implements Querier.DiscardPendingStateVersionsByWorkspaceID.
func (q *DBQuerier) DiscardPendingStateVersionsByWorkspaceID(ctx context.Context, workspaceID pgtype.Text) (pgconn.CommandTag, error) {
	ctx = context.WithValue(ctx, "pggen_query_name", "DiscardPendingStateVersionsByWorkspaceID")
	cmdTag, err := q.conn.Exec(ctx, discardPendingStateVersionsByWorkspaceIDSQL, workspaceID)
	if err != nil {
		return cmdTag, fmt.Errorf("exec query DiscardPendingStateVersionsByWorkspaceID: %w", err)
	}
	return cmdTag, err
}

// DiscardPendingStateVersionsByWorkspaceIDBatch implements Querier.DiscardPendingStateVersionsByWorkspaceIDBatch.
func (q *DBQuerier) DiscardPendingStateVersionsByWorkspaceIDBatch(batch genericBatch, workspaceID pgtype.Text) {
	batch.Queue(discardPendingStateVersionsByWorkspaceIDSQL, workspaceID)
}

// DiscardPendingStateVersionsByWorkspaceIDScan implements Querier.DiscardPendingStateVersionsByWorkspaceIDScan.
func (q *DBQuerier) DiscardPendingStateVersionsByWorkspaceIDScan(results pgx.BatchResults) (pgconn.CommandTag, error) {
	cmdTag, err := results.Exec()
	if err != nil {
		return cmdTag, fmt.Errorf("exec DiscardPendingStateVersionsByWorkspaceIDBatch: %w", err)
	}
	return cmdTag, err
}

const findStateVersionsByWorkspaceIDSQL = `SELECT
    sv.*,
    array_remove(array_agg(state_version_outputs), NULL) AS state_version_outputs
FROM state_versions sv
LEFT JOIN state_version_outputs USING (state_version_id)
WHERE sv.workspace_id = $1
AND   sv.status = 'finalized'
GROUP BY sv.state_version_id
ORDER BY created_at DESC
LIMIT $2
OFFSET $3
;`

type FindStateVersionsByWorkspaceIDParams struct {
	WorkspaceID pgtype.Text
	Limit       pgtype.Int8
	Offset      pgtype.Int8
}

type FindStateVersionsByWorkspaceIDRow struct {
	StateVersionID      pgtype.Text           `json:"state_version_id"`
	CreatedAt           pgtype.Timestamptz    `json:"created_at"`
	Serial              pgtype.Int4           `json:"serial"`
	State               []byte                `json:"state"`
	WorkspaceID         pgtype.Text           `json:"workspace_id"`
	Status              pgtype.Text           `json:"status"`
	StateVersionOutputs []StateVersionOutputs `json:"state_version_outputs"`
}

// FindStateVersionsByWorkspaceID implements Querier.FindStateVersionsByWorkspaceID.
func (q *DBQuerier) FindStateVersionsByWorkspaceID(ctx context.Context, params FindStateVersionsByWorkspaceIDParams) ([]FindStateVersionsByWorkspaceIDRow, error) {
	ctx = context.WithValue(ctx, "pggen_query_name", "FindStateVersionsByWorkspaceID")
	rows, err := q.conn.Query(ctx, findStateVersionsByWorkspaceIDSQL, params.WorkspaceID, params.Limit, params.Offset)
	if err != nil {
		return nil, fmt.Errorf("query FindStateVersionsByWorkspaceID: %w", err)
	}
	defer rows.Close()
	items := []FindStateVersionsByWorkspaceIDRow{}
	stateVersionOutputsArray := q.types.newStateVersionOutputsArray()
	for rows.Next() {
		var item FindStateVersionsByWorkspaceIDRow
		if err := rows.Scan(&item.StateVersionID, &item.CreatedAt, &item.Serial, &item.State, &item.WorkspaceID, &item.Status, stateVersionOutputsArray); err != nil {
			return nil, fmt.Errorf("scan FindStateVersionsByWorkspaceID row: %w", err)
		}
		if err := stateVersionOutputsArray.AssignTo(&item.StateVersionOutputs); err != nil {
			return nil, fmt.Errorf("assign FindStateVersionsByWorkspaceID row: %w", err)
		}
		items = append(items, item)
	}
	if err := rows.Err(); err != nil {
		return nil, fmt.Errorf("close FindStateVersionsByWorkspaceID rows: %w", err)
	}
	return items, err
}

// FindStateVersionsByWorkspaceIDBatch implements Querier.FindStateVersionsByWorkspaceIDBatch.
func (q *DBQuerier) FindStateVersionsByWorkspaceIDBatch(batch genericBatch, params FindStateVersionsByWorkspaceIDParams) {
	batch.Queue(findStateVersionsByWorkspaceIDSQL, params.WorkspaceID, params.Limit, params.Offset)
}

// FindStateVersionsByWorkspaceIDScan implements Querier.FindStateVersionsByWorkspaceIDScan.
func (q *DBQuerier) FindStateVersionsByWorkspaceIDScan(results pgx.BatchResults) ([]FindStateVersionsByWorkspaceIDRow, error) {
	rows, err := results.Query()
	if err != nil {
		return nil, fmt.Errorf("query FindStateVersionsByWorkspaceIDBatch: %w", err)
	}
	defer rows.Close()
	items := []FindStateVersionsByWorkspaceIDRow{}
	stateVersionOutputsArray := q.types.newStateVersionOutputsArray()
	for rows.Next() {
		var item FindStateVersionsByWorkspaceIDRow
		if err := rows.Scan(&item.StateVersionID, &item.CreatedAt, &item.Serial, &item.State, &item.WorkspaceID, &item.Status, stateVersionOutputsArray); err != nil {
			return nil, fmt.Errorf("scan FindStateVersionsByWorkspaceIDBatch row: %w", err)
		}
		if err := stateVersionOutputsArray.AssignTo(&item.StateVersionOutputs); err != nil {
			return nil, fmt.Errorf("assign FindStateVersionsByWorkspaceID row: %w", err)
		}
		items = append(items, item)
	}
	if err := rows.Err(); err != nil {
		return nil, fmt.Errorf("close FindStateVersionsByWorkspaceIDBatch rows: %w", err)
	}
	return items, err
}

const countStateVersionsByWorkspaceIDSQL = `SELECT count(*)
FROM state_versions
WHERE workspace_id = $1
AND status = 'finalized'
;`

// CountStateVersionsByWorkspaceID implements Querier.CountStateVersionsByWorkspaceID.
func (q *DBQuerier) CountStateVersionsByWorkspaceID(ctx context.Context, workspaceID pgtype.Text) (pgtype.Int8, error) {
	ctx = context.WithValue(ctx, "pggen_query_name", "CountStateVersionsByWorkspaceID")
	row := q.conn.QueryRow(ctx, countStateVersionsByWorkspaceIDSQL, workspaceID)
	var item pgtype.Int8
	if err := row.Scan(&item); err != nil {
		return item, fmt.Errorf("query CountStateVersionsByWorkspaceID: %w", err)
	}
	return item, nil
}

// CountStateVersionsByWorkspaceIDBatch implements Querier.CountStateVersionsByWorkspaceIDBatch.
func (q *DBQuerier) CountStateVersionsByWorkspaceIDBatch(batch genericBatch, workspaceID pgtype.Text) {
	batch.Queue(countStateVersionsByWorkspaceIDSQL, workspaceID)
}

// CountStateVersionsByWorkspaceIDScan implements Querier.CountStateVersionsByWorkspaceIDScan.
func (q *DBQuerier) CountStateVersionsByWorkspaceIDScan(results pgx.BatchResults) (pgtype.Int8, error) {
	row := results.QueryRow()
	var item pgtype.Int8
	if err := row.Scan(&item); err != nil {
		return item, fmt.Errorf("scan CountStateVersionsByWorkspaceIDBatch row: %w", err)
	}
	return item, nil
}

const findStateVersionByIDSQL = `SELECT
    state_versions.*,
    array_remove(array_agg(state_version_outputs), NULL) AS state_version_outputs
FROM state_versions
LEFT JOIN state_version_outputs USING (state_version_id)
WHERE state_versions.state_version_id = $1
GROUP BY state_versions.state_version_id
;`

type FindStateVersionByIDRow struct {
	StateVersionID      pgtype.Text           `json:"state_version_id"`
	CreatedAt           pgtype.Timestamptz    `json:"created_at"`
	Serial              pgtype.Int4           `json:"serial"`
	State               []byte                `json:"state"`
	WorkspaceID         pgtype.Text           `json:"workspace_id"`
	Status              pgtype.Text           `json:"status"`
	StateVersionOutputs []StateVersionOutputs `json:"state_version_outputs"`
}

// FindStateVersionByID implements Querier.FindStateVersionByID.
func (q *DBQuerier) FindStateVersionByID(ctx context.Context, id pgtype.Text) (FindStateVersionByIDRow, error) {
	ctx = context.WithValue(ctx, "pggen_query_name", "FindStateVersionByID")
	row := q.conn.QueryRow(ctx, findStateVersionByIDSQL, id)
	var item FindStateVersionByIDRow
	stateVersionOutputsArray := q.types.newStateVersionOutputsArray()
	if err := row.Scan(&item.StateVersionID, &item.CreatedAt, &item.Serial, &item.State, &item.WorkspaceID, &item.Status, stateVersionOutputsArray); err != nil {
		return item, fmt.Errorf("query FindStateVersionByID: %w", err)
	}
	if err := stateVersionOutputsArray.AssignTo(&item.StateVersionOutputs); err != nil {
		return item, fmt.Errorf("assign FindStateVersionByID row: %w", err)
	}
	return item, nil
}

// FindStateVersionByIDBatch implements Querier.FindStateVersionByIDBatch.
func (q *DBQuerier) FindStateVersionByIDBatch(batch genericBatch, id pgtype.Text) {
	batch.Queue(findStateVersionByIDSQL, id)
}

// FindStateVersionByIDScan implements Querier.FindStateVersionByIDScan.
func (q *DBQuerier) FindStateVersionByIDScan(results pgx.BatchResults) (FindStateVersionByIDRow, error) {
	row := results.QueryRow()
	var item FindStateVersionByIDRow
	stateVersionOutputsArray := q.types.newStateVersionOutputsArray()
	if err := row.Scan(&item.StateVersionID, &item.CreatedAt, &item.Serial, &item.State, &item.WorkspaceID, &item.Status, stateVersionOutputsArray); err != nil {
		return item, fmt.Errorf("scan FindStateVersionByIDBatch row: %w", err)
	}
	if err := stateVersionOutputsArray.AssignTo(&item.StateVersionOutputs); err != nil {
		return item, fmt.Errorf("assign FindStateVersionByID row: %w", err)
	}
	return item, nil
}

const findStateVersionByIDForUpdateSQL = `SELECT
    sv.*,
    (
        SELECT array_agg(svo.*)
        FROM state_version_outputs svo
        WHERE svo.state_version_id = sv.state_version_id
    ) AS state_version_outputs
FROM state_versions sv
WHERE sv.state_version_id = $1
FOR UPDATE OF sv
;`

type FindStateVersionByIDForUpdateRow struct {
	StateVersionID      pgtype.Text           `json:"state_version_id"`
	CreatedAt           pgtype.Timestamptz    `json:"created_at"`
	Serial              pgtype.Int4           `json:"serial"`
	State               []byte                `json:"state"`
	WorkspaceID         pgtype.Text           `json:"workspace_id"`
	Status              pgtype.Text           `json:"status"`
	StateVersionOutputs []StateVersionOutputs `json:"state_version_outputs"`
}

// FindStateVersionByIDForUpdate implements Querier.FindStateVersionByIDForUpdate.
func (q *DBQuerier) FindStateVersionByIDForUpdate(ctx context.Context, id pgtype.Text) (FindStateVersionByIDForUpdateRow, error) {
	ctx = context.WithValue(ctx, "pggen_query_name", "FindStateVersionByIDForUpdate")
	row := q.conn.QueryRow(ctx, findStateVersionByIDForUpdateSQL, id)
	var item FindStateVersionByIDForUpdateRow
	stateVersionOutputsArray := q.types.newStateVersionOutputsArray()
	if err := row.Scan(&item.StateVersionID, &item.CreatedAt, &item.Serial, &item.State, &item.WorkspaceID, &item.Status, stateVersionOutputsArray); err != nil {
		return item, fmt.Errorf("query FindStateVersionByIDForUpdate: %w", err)
	}
	if err := stateVersionOutputsArray.AssignTo(&item.StateVersionOutputs); err != nil {
		return item, fmt.Errorf("assign FindStateVersionByIDForUpdate row: %w", err)
	}
	return item, nil
}

// FindStateVersionByIDForUpdateBatch implements Querier.FindStateVersionByIDForUpdateBatch.
func (q *DBQuerier) FindStateVersionByIDForUpdateBatch(batch genericBatch, id pgtype.Text) {
	batch.Queue(findStateVersionByIDForUpdateSQL, id)
}

// FindStateVersionByIDForUpdateScan implements Querier.FindStateVersionByIDForUpdateScan.
func (q *DBQuerier) FindStateVersionByIDForUpdateScan(results pgx.BatchResults) (FindStateVersionByIDForUpdateRow, error) {
	row := results.QueryRow()
	var item FindStateVersionByIDForUpdateRow
	stateVersionOutputsArray := q.types.newStateVersionOutputsArray()
	if err := row.Scan(&item.StateVersionID, &item.CreatedAt, &item.Serial, &item.State, &item.WorkspaceID, &item.Status, stateVersionOutputsArray); err != nil {
		return item, fmt.Errorf("scan FindStateVersionByIDForUpdateBatch row: %w", err)
	}
	if err := stateVersionOutputsArray.AssignTo(&item.StateVersionOutputs); err != nil {
		return item, fmt.Errorf("assign FindStateVersionByIDForUpdate row: %w", err)
	}
	return item, nil
}

const findCurrentStateVersionByWorkspaceIDSQL = `SELECT
    sv.*,
    array_remove(array_agg(svo), NULL) AS state_version_outputs
FROM state_versions sv
LEFT JOIN state_version_outputs svo USING (state_version_id)
JOIN workspaces w ON w.current_state_version_id = sv.state_version_id
WHERE w.workspace_id = $1
GROUP BY sv.state_version_id
;`

type FindCurrentStateVersionByWorkspaceIDRow struct {
	StateVersionID      pgtype.Text           `json:"state_version_id"`
	CreatedAt           pgtype.Timestamptz    `json:"created_at"`
	Serial              pgtype.Int4           `json:"serial"`
	State               []byte                `json:"state"`
	WorkspaceID         pgtype.Text           `json:"workspace_id"`
	Status              pgtype.Text           `json:"status"`
	StateVersionOutputs []StateVersionOutputs `json:"state_version_outputs"`
}

// FindCurrentStateVersionByWorkspaceID implements Querier.FindCurrentStateVersionByWorkspaceID.
func (q *DBQuerier) FindCurrentStateVersionByWorkspaceID(ctx context.Context, workspaceID pgtype.Text) (FindCurrentStateVersionByWorkspaceIDRow, error) {
	ctx = context.WithValue(ctx, "pggen_query_name", "FindCurrentStateVersionByWorkspaceID")
	row := q.conn.QueryRow(ctx, findCurrentStateVersionByWorkspaceIDSQL, workspaceID)
	var item FindCurrentStateVersionByWorkspaceIDRow
	stateVersionOutputsArray := q.types.newStateVersionOutputsArray()
	if err := row.Scan(&item.StateVersionID, &item.CreatedAt, &item.Serial, &item.State, &item.WorkspaceID, &item.Status, stateVersionOutputsArray); err != nil {
		return item, fmt.Errorf("query FindCurrentStateVersionByWorkspaceID: %w", err)
	}
	if err := stateVersionOutputsArray.AssignTo(&item.StateVersionOutputs); err != nil {
		return item, fmt.Errorf("assign FindCurrentStateVersionByWorkspaceID row: %w", err)
	}
	return item, nil
}

// FindCurrentStateVersionByWorkspaceIDBatch implements Querier.FindCurrentStateVersionByWorkspaceIDBatch.
func (q *DBQuerier) FindCurrentStateVersionByWorkspaceIDBatch(batch genericBatch, workspaceID pgtype.Text) {
	batch.Queue(findCurrentStateVersionByWorkspaceIDSQL, workspaceID)
}

// FindCurrentStateVersionByWorkspaceIDScan implements Querier.FindCurrentStateVersionByWorkspaceIDScan.
func (q *DBQuerier) FindCurrentStateVersionByWorkspaceIDScan(results pgx.BatchResults) (FindCurrentStateVersionByWorkspaceIDRow, error) {
	row := results.QueryRow()
	var item FindCurrentStateVersionByWorkspaceIDRow
	stateVersionOutputsArray := q.types.newStateVersionOutputsArray()
	if err := row.Scan(&item.StateVersionID, &item.CreatedAt, &item.Serial, &item.State, &item.WorkspaceID, &item.Status, stateVersionOutputsArray); err != nil {
		return item, fmt.Errorf("scan FindCurrentStateVersionByWorkspaceIDBatch row: %w", err)
	}
	if err := stateVersionOutputsArray.AssignTo(&item.StateVersionOutputs); err != nil {
		return item, fmt.Errorf("assign FindCurrentStateVersionByWorkspaceID row: %w", err)
	}
	return item, nil
}

const findStateVersionStateByIDSQL = `SELECT state
FROM state_versions
WHERE state_version_id = $1
;`

// FindStateVersionStateByID implements Querier.FindStateVersionStateByID.
func (q *DBQuerier) FindStateVersionStateByID(ctx context.Context, id pgtype.Text) ([]byte, error) {
	ctx = context.WithValue(ctx, "pggen_query_name", "FindStateVersionStateByID")
	row := q.conn.QueryRow(ctx, findStateVersionStateByIDSQL, id)
	item := []byte{}
	if err := row.Scan(&item); err != nil {
		return item, fmt.Errorf("query FindStateVersionStateByID: %w", err)
	}
	return item, nil
}

// FindStateVersionStateByIDBatch implements Querier.FindStateVersionStateByIDBatch.
func (q *DBQuerier) FindStateVersionStateByIDBatch(batch genericBatch, id pgtype.Text) {
	batch.Queue(findStateVersionStateByIDSQL, id)
}

// FindStateVersionStateByIDScan implements Querier.FindStateVersionStateByIDScan.
func (q *DBQuerier) FindStateVersionStateByIDScan(results pgx.BatchResults) ([]byte, error) {
	row := results.QueryRow()
	item := []byte{}
	if err := row.Scan(&item); err != nil {
		return item, fmt.Errorf("scan FindStateVersionStateByIDBatch row: %w", err)
	}
	return item, nil
}

const deleteStateVersionByIDSQL = `DELETE
FROM state_versions
WHERE state_version_id = $1
RETURNING state_version_id
;`

// DeleteStateVersionByID implements Querier.DeleteStateVersionByID.
func (q *DBQuerier) DeleteStateVersionByID(ctx context.Context, stateVersionID pgtype.Text) (pgtype.Text, error) {
	ctx = context.WithValue(ctx, "pggen_query_name", "DeleteStateVersionByID")
	row := q.conn.QueryRow(ctx, deleteStateVersionByIDSQL, stateVersionID)
	var item pgtype.Text
	if err := row.Scan(&item); err != nil {
		return item, fmt.Errorf("query DeleteStateVersionByID: %w", err)
	}
	return item, nil
}

// DeleteStateVersionByIDBatch implements Querier.DeleteStateVersionByIDBatch.
func (q *DBQuerier) DeleteStateVersionByIDBatch(batch genericBatch, stateVersionID pgtype.Text) {
	batch.Queue(deleteStateVersionByIDSQL, stateVersionID)
}

// DeleteStateVersionByIDScan implements Querier.DeleteStateVersionByIDScan.
func (q *DBQuerier) DeleteStateVersionByIDScan(results pgx.BatchResults) (pgtype.Text, error) {
	row := results.QueryRow()
	var item pgtype.Text
	if err := row.Scan(&item); err != nil {
		return item, fmt.Errorf("scan DeleteStateVersionByIDBatch row: %w", err)
	}
	return item, nil
}