flamenco/internal/manager/persistence/sqlc/query_workers.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.26.0
// source: query_workers.sql

package sqlc

import (
	"context"
	"database/sql"
	"strings"
	"time"
)

const countWorkerTags = `-- name: CountWorkerTags :one
SELECT count(id) as count FROM worker_tags
`

func (q *Queries) CountWorkerTags(ctx context.Context) (int64, error) {
	row := q.db.QueryRowContext(ctx, countWorkerTags)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const createWorker = `-- name: CreateWorker :one
INSERT INTO workers (
  created_at,
  uuid,
  secret,
  name,
  address,
  platform,
  software,
  status,
  last_seen_at,
  status_requested,
  lazy_status_request,
  supported_task_types,
  deleted_at,
  can_restart
) values (
  ?1,
  ?2,
  ?3,
  ?4,
  ?5,
  ?6,
  ?7,
  ?8,
  ?9,
  ?10,
  ?11,
  ?12,
  ?13,
  ?14
)
RETURNING id
`

type CreateWorkerParams struct {
	CreatedAt          time.Time
	UUID               string
	Secret             string
	Name               string
	Address            string
	Platform           string
	Software           string
	Status             string
	LastSeenAt         sql.NullTime
	StatusRequested    string
	LazyStatusRequest  bool
	SupportedTaskTypes string
	DeletedAt          sql.NullTime
	CanRestart         bool
}

func (q *Queries) CreateWorker(ctx context.Context, arg CreateWorkerParams) (int64, error) {
	row := q.db.QueryRowContext(ctx, createWorker,
		arg.CreatedAt,
		arg.UUID,
		arg.Secret,
		arg.Name,
		arg.Address,
		arg.Platform,
		arg.Software,
		arg.Status,
		arg.LastSeenAt,
		arg.StatusRequested,
		arg.LazyStatusRequest,
		arg.SupportedTaskTypes,
		arg.DeletedAt,
		arg.CanRestart,
	)
	var id int64
	err := row.Scan(&id)
	return id, err
}

const createWorkerTag = `-- name: CreateWorkerTag :execlastid
INSERT INTO worker_tags (
  created_at,
  uuid,
  name,
  description
) VALUES (
  ?1,
  ?2,
  ?3,
  ?4
)
`

type CreateWorkerTagParams struct {
	CreatedAt   time.Time
	UUID        string
	Name        string
	Description string
}

func (q *Queries) CreateWorkerTag(ctx context.Context, arg CreateWorkerTagParams) (int64, error) {
	result, err := q.db.ExecContext(ctx, createWorkerTag,
		arg.CreatedAt,
		arg.UUID,
		arg.Name,
		arg.Description,
	)
	if err != nil {
		return 0, err
	}
	return result.LastInsertId()
}

const deleteWorkerTag = `-- name: DeleteWorkerTag :execrows
DELETE FROM worker_tags
WHERE uuid=?1
`

func (q *Queries) DeleteWorkerTag(ctx context.Context, uuid string) (int64, error) {
	result, err := q.db.ExecContext(ctx, deleteWorkerTag, uuid)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected()
}

const fetchTagsOfWorker = `-- name: FetchTagsOfWorker :many
SELECT worker_tags.id, worker_tags.created_at, worker_tags.updated_at, worker_tags.uuid, worker_tags.name, worker_tags.description
FROM worker_tags
LEFT JOIN worker_tag_membership m ON (m.worker_tag_id = worker_tags.id)
LEFT JOIN workers on (m.worker_id = workers.id)
WHERE workers.uuid = ?1
`

func (q *Queries) FetchTagsOfWorker(ctx context.Context, uuid string) ([]WorkerTag, error) {
	rows, err := q.db.QueryContext(ctx, fetchTagsOfWorker, uuid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []WorkerTag
	for rows.Next() {
		var i WorkerTag
		if err := rows.Scan(
			&i.ID,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.UUID,
			&i.Name,
			&i.Description,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const fetchWorker = `-- name: FetchWorker :one
SELECT id, created_at, updated_at, uuid, secret, name, address, platform, software, status, last_seen_at, status_requested, lazy_status_request, supported_task_types, deleted_at, can_restart FROM workers WHERE workers.uuid = ?1 and deleted_at is NULL
`

// FetchWorker only returns the worker if it wasn't soft-deleted.
func (q *Queries) FetchWorker(ctx context.Context, uuid string) (Worker, error) {
	row := q.db.QueryRowContext(ctx, fetchWorker, uuid)
	var i Worker
	err := row.Scan(
		&i.ID,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.UUID,
		&i.Secret,
		&i.Name,
		&i.Address,
		&i.Platform,
		&i.Software,
		&i.Status,
		&i.LastSeenAt,
		&i.StatusRequested,
		&i.LazyStatusRequest,
		&i.SupportedTaskTypes,
		&i.DeletedAt,
		&i.CanRestart,
	)
	return i, err
}

const fetchWorkerTagByID = `-- name: FetchWorkerTagByID :one
SELECT id, created_at, updated_at, uuid, name, description
FROM worker_tags
WHERE id=?1
`

func (q *Queries) FetchWorkerTagByID(ctx context.Context, workerTagID int64) (WorkerTag, error) {
	row := q.db.QueryRowContext(ctx, fetchWorkerTagByID, workerTagID)
	var i WorkerTag
	err := row.Scan(
		&i.ID,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.UUID,
		&i.Name,
		&i.Description,
	)
	return i, err
}

const fetchWorkerTagByUUID = `-- name: FetchWorkerTagByUUID :one
SELECT id, created_at, updated_at, uuid, name, description
FROM worker_tags
WHERE worker_tags.uuid = ?1
`

func (q *Queries) FetchWorkerTagByUUID(ctx context.Context, uuid string) (WorkerTag, error) {
	row := q.db.QueryRowContext(ctx, fetchWorkerTagByUUID, uuid)
	var i WorkerTag
	err := row.Scan(
		&i.ID,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.UUID,
		&i.Name,
		&i.Description,
	)
	return i, err
}

const fetchWorkerTags = `-- name: FetchWorkerTags :many
SELECT id, created_at, updated_at, uuid, name, description
FROM worker_tags
`

func (q *Queries) FetchWorkerTags(ctx context.Context) ([]WorkerTag, error) {
	rows, err := q.db.QueryContext(ctx, fetchWorkerTags)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []WorkerTag
	for rows.Next() {
		var i WorkerTag
		if err := rows.Scan(
			&i.ID,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.UUID,
			&i.Name,
			&i.Description,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const fetchWorkerTagsByUUIDs = `-- name: FetchWorkerTagsByUUIDs :many
SELECT id, created_at, updated_at, uuid, name, description
FROM worker_tags
WHERE uuid in (/*SLICE:uuids*/?)
`

func (q *Queries) FetchWorkerTagsByUUIDs(ctx context.Context, uuids []string) ([]WorkerTag, error) {
	query := fetchWorkerTagsByUUIDs
	var queryParams []interface{}
	if len(uuids) > 0 {
		for _, v := range uuids {
			queryParams = append(queryParams, v)
		}
		query = strings.Replace(query, "/*SLICE:uuids*/?", strings.Repeat(",?", len(uuids))[1:], 1)
	} else {
		query = strings.Replace(query, "/*SLICE:uuids*/?", "NULL", 1)
	}
	rows, err := q.db.QueryContext(ctx, query, queryParams...)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []WorkerTag
	for rows.Next() {
		var i WorkerTag
		if err := rows.Scan(
			&i.ID,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.UUID,
			&i.Name,
			&i.Description,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const fetchWorkerUnconditional = `-- name: FetchWorkerUnconditional :one
SELECT id, created_at, updated_at, uuid, secret, name, address, platform, software, status, last_seen_at, status_requested, lazy_status_request, supported_task_types, deleted_at, can_restart FROM workers WHERE workers.uuid = ?1
`

// FetchWorkerUnconditional ignores soft-deletion status and just returns the worker.
func (q *Queries) FetchWorkerUnconditional(ctx context.Context, uuid string) (Worker, error) {
	row := q.db.QueryRowContext(ctx, fetchWorkerUnconditional, uuid)
	var i Worker
	err := row.Scan(
		&i.ID,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.UUID,
		&i.Secret,
		&i.Name,
		&i.Address,
		&i.Platform,
		&i.Software,
		&i.Status,
		&i.LastSeenAt,
		&i.StatusRequested,
		&i.LazyStatusRequest,
		&i.SupportedTaskTypes,
		&i.DeletedAt,
		&i.CanRestart,
	)
	return i, err
}

const fetchWorkerUnconditionalByID = `-- name: FetchWorkerUnconditionalByID :one
SELECT id, created_at, updated_at, uuid, secret, name, address, platform, software, status, last_seen_at, status_requested, lazy_status_request, supported_task_types, deleted_at, can_restart FROM workers WHERE workers.id = ?1
`

// FetchWorkerUnconditional ignores soft-deletion status and just returns the worker.
func (q *Queries) FetchWorkerUnconditionalByID(ctx context.Context, workerID int64) (Worker, error) {
	row := q.db.QueryRowContext(ctx, fetchWorkerUnconditionalByID, workerID)
	var i Worker
	err := row.Scan(
		&i.ID,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.UUID,
		&i.Secret,
		&i.Name,
		&i.Address,
		&i.Platform,
		&i.Software,
		&i.Status,
		&i.LastSeenAt,
		&i.StatusRequested,
		&i.LazyStatusRequest,
		&i.SupportedTaskTypes,
		&i.DeletedAt,
		&i.CanRestart,
	)
	return i, err
}

const fetchWorkers = `-- name: FetchWorkers :many
SELECT workers.id, workers.created_at, workers.updated_at, workers.uuid, workers.secret, workers.name, workers.address, workers.platform, workers.software, workers.status, workers.last_seen_at, workers.status_requested, workers.lazy_status_request, workers.supported_task_types, workers.deleted_at, workers.can_restart FROM workers
WHERE deleted_at IS NULL
`

type FetchWorkersRow struct {
	Worker Worker
}

func (q *Queries) FetchWorkers(ctx context.Context) ([]FetchWorkersRow, error) {
	rows, err := q.db.QueryContext(ctx, fetchWorkers)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []FetchWorkersRow
	for rows.Next() {
		var i FetchWorkersRow
		if err := rows.Scan(
			&i.Worker.ID,
			&i.Worker.CreatedAt,
			&i.Worker.UpdatedAt,
			&i.Worker.UUID,
			&i.Worker.Secret,
			&i.Worker.Name,
			&i.Worker.Address,
			&i.Worker.Platform,
			&i.Worker.Software,
			&i.Worker.Status,
			&i.Worker.LastSeenAt,
			&i.Worker.StatusRequested,
			&i.Worker.LazyStatusRequest,
			&i.Worker.SupportedTaskTypes,
			&i.Worker.DeletedAt,
			&i.Worker.CanRestart,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const saveWorker = `-- name: SaveWorker :exec
UPDATE workers SET
  updated_at=?1,
  uuid=?2,
  secret=?3,
  name=?4,
  address=?5,
  platform=?6,
  software=?7,
  status=?8,
  last_seen_at=?9,
  status_requested=?10,
  lazy_status_request=?11,
  supported_task_types=?12,
  can_restart=?13
WHERE id=?14
`

type SaveWorkerParams struct {
	UpdatedAt          sql.NullTime
	UUID               string
	Secret             string
	Name               string
	Address            string
	Platform           string
	Software           string
	Status             string
	LastSeenAt         sql.NullTime
	StatusRequested    string
	LazyStatusRequest  bool
	SupportedTaskTypes string
	CanRestart         bool
	ID                 int64
}

func (q *Queries) SaveWorker(ctx context.Context, arg SaveWorkerParams) error {
	_, err := q.db.ExecContext(ctx, saveWorker,
		arg.UpdatedAt,
		arg.UUID,
		arg.Secret,
		arg.Name,
		arg.Address,
		arg.Platform,
		arg.Software,
		arg.Status,
		arg.LastSeenAt,
		arg.StatusRequested,
		arg.LazyStatusRequest,
		arg.SupportedTaskTypes,
		arg.CanRestart,
		arg.ID,
	)
	return err
}

const saveWorkerStatus = `-- name: SaveWorkerStatus :exec
UPDATE workers SET
  updated_at=?1,
  status=?2,
  status_requested=?3,
  lazy_status_request=?4
WHERE id=?5
`

type SaveWorkerStatusParams struct {
	UpdatedAt         sql.NullTime
	Status            string
	StatusRequested   string
	LazyStatusRequest bool
	ID                int64
}

func (q *Queries) SaveWorkerStatus(ctx context.Context, arg SaveWorkerStatusParams) error {
	_, err := q.db.ExecContext(ctx, saveWorkerStatus,
		arg.UpdatedAt,
		arg.Status,
		arg.StatusRequested,
		arg.LazyStatusRequest,
		arg.ID,
	)
	return err
}

const saveWorkerTag = `-- name: SaveWorkerTag :exec
UPDATE worker_tags
SET
  updated_at=?1,
  uuid=?2,
  name=?3,
  description=?4
WHERE id=?5
`

type SaveWorkerTagParams struct {
	UpdatedAt   sql.NullTime
	UUID        string
	Name        string
	Description string
	WorkerTagID int64
}

func (q *Queries) SaveWorkerTag(ctx context.Context, arg SaveWorkerTagParams) error {
	_, err := q.db.ExecContext(ctx, saveWorkerTag,
		arg.UpdatedAt,
		arg.UUID,
		arg.Name,
		arg.Description,
		arg.WorkerTagID,
	)
	return err
}

const softDeleteWorker = `-- name: SoftDeleteWorker :execrows
UPDATE workers SET deleted_at=?1
WHERE uuid=?2
`

type SoftDeleteWorkerParams struct {
	DeletedAt sql.NullTime
	UUID      string
}

func (q *Queries) SoftDeleteWorker(ctx context.Context, arg SoftDeleteWorkerParams) (int64, error) {
	result, err := q.db.ExecContext(ctx, softDeleteWorker, arg.DeletedAt, arg.UUID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected()
}

const summarizeWorkerStatuses = `-- name: SummarizeWorkerStatuses :many
SELECT status, count(id) as status_count FROM workers
WHERE deleted_at is NULL
GROUP BY status
`

type SummarizeWorkerStatusesRow struct {
	Status      string
	StatusCount int64
}

func (q *Queries) SummarizeWorkerStatuses(ctx context.Context) ([]SummarizeWorkerStatusesRow, error) {
	rows, err := q.db.QueryContext(ctx, summarizeWorkerStatuses)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []SummarizeWorkerStatusesRow
	for rows.Next() {
		var i SummarizeWorkerStatusesRow
		if err := rows.Scan(&i.Status, &i.StatusCount); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const workerAddTagMembership = `-- name: WorkerAddTagMembership :exec
INSERT INTO worker_tag_membership (worker_tag_id, worker_id)
VALUES (?1, ?2)
`

type WorkerAddTagMembershipParams struct {
	WorkerTagID int64
	WorkerID    int64
}

func (q *Queries) WorkerAddTagMembership(ctx context.Context, arg WorkerAddTagMembershipParams) error {
	_, err := q.db.ExecContext(ctx, workerAddTagMembership, arg.WorkerTagID, arg.WorkerID)
	return err
}

const workerRemoveTagMemberships = `-- name: WorkerRemoveTagMemberships :exec
DELETE
FROM worker_tag_membership
WHERE worker_id=?1
`

func (q *Queries) WorkerRemoveTagMemberships(ctx context.Context, workerID int64) error {
	_, err := q.db.ExecContext(ctx, workerRemoveTagMemberships, workerID)
	return err
}

const workerSeen = `-- name: WorkerSeen :exec
UPDATE workers SET
  updated_at=?1,
  last_seen_at=?2
WHERE id=?3
`

type WorkerSeenParams struct {
	UpdatedAt  sql.NullTime
	LastSeenAt sql.NullTime
	ID         int64
}

func (q *Queries) WorkerSeen(ctx context.Context, arg WorkerSeenParams) error {
	_, err := q.db.ExecContext(ctx, workerSeen, arg.UpdatedAt, arg.LastSeenAt, arg.ID)
	return err
}