927 lines
21 KiB
Go
927 lines
21 KiB
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 fetchSleepSchedulesToCheck = `-- name: FetchSleepSchedulesToCheck :many
|
|
SELECT id, created_at, updated_at, worker_id, is_active, days_of_week, start_time, end_time, next_check FROM sleep_schedules
|
|
WHERE is_active
|
|
AND (next_check <= ?1 OR next_check IS NULL OR next_check = '')
|
|
`
|
|
|
|
func (q *Queries) FetchSleepSchedulesToCheck(ctx context.Context, nextCheck sql.NullTime) ([]SleepSchedule, error) {
|
|
rows, err := q.db.QueryContext(ctx, fetchSleepSchedulesToCheck, nextCheck)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []SleepSchedule
|
|
for rows.Next() {
|
|
var i SleepSchedule
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.WorkerID,
|
|
&i.IsActive,
|
|
&i.DaysOfWeek,
|
|
&i.StartTime,
|
|
&i.EndTime,
|
|
&i.NextCheck,
|
|
); 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 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 fetchTimedOutWorkers = `-- name: FetchTimedOutWorkers :many
|
|
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
|
|
last_seen_at <= ?1
|
|
AND deleted_at IS NULL
|
|
AND status NOT IN (/*SLICE:worker_statuses_no_timeout*/?)
|
|
`
|
|
|
|
type FetchTimedOutWorkersParams struct {
|
|
LastSeenBefore sql.NullTime
|
|
WorkerStatusesNoTimeout []string
|
|
}
|
|
|
|
func (q *Queries) FetchTimedOutWorkers(ctx context.Context, arg FetchTimedOutWorkersParams) ([]Worker, error) {
|
|
query := fetchTimedOutWorkers
|
|
var queryParams []interface{}
|
|
queryParams = append(queryParams, arg.LastSeenBefore)
|
|
if len(arg.WorkerStatusesNoTimeout) > 0 {
|
|
for _, v := range arg.WorkerStatusesNoTimeout {
|
|
queryParams = append(queryParams, v)
|
|
}
|
|
query = strings.Replace(query, "/*SLICE:worker_statuses_no_timeout*/?", strings.Repeat(",?", len(arg.WorkerStatusesNoTimeout))[1:], 1)
|
|
} else {
|
|
query = strings.Replace(query, "/*SLICE:worker_statuses_no_timeout*/?", "NULL", 1)
|
|
}
|
|
rows, err := q.db.QueryContext(ctx, query, queryParams...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Worker
|
|
for rows.Next() {
|
|
var i Worker
|
|
if err := rows.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,
|
|
); 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 fetchWorkerByID = `-- name: FetchWorkerByID :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 and deleted_at is NULL
|
|
`
|
|
|
|
// FetchWorkerByID only returns the worker if it wasn't soft-deleted.
|
|
func (q *Queries) FetchWorkerByID(ctx context.Context, workerID int64) (Worker, error) {
|
|
row := q.db.QueryRowContext(ctx, fetchWorkerByID, 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 fetchWorkerSleepSchedule = `-- name: FetchWorkerSleepSchedule :one
|
|
SELECT sleep_schedules.id, sleep_schedules.created_at, sleep_schedules.updated_at, sleep_schedules.worker_id, sleep_schedules.is_active, sleep_schedules.days_of_week, sleep_schedules.start_time, sleep_schedules.end_time, sleep_schedules.next_check
|
|
FROM sleep_schedules
|
|
INNER JOIN workers on workers.id = sleep_schedules.worker_id
|
|
WHERE workers.uuid = ?1
|
|
`
|
|
|
|
func (q *Queries) FetchWorkerSleepSchedule(ctx context.Context, workeruuid string) (SleepSchedule, error) {
|
|
row := q.db.QueryRowContext(ctx, fetchWorkerSleepSchedule, workeruuid)
|
|
var i SleepSchedule
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.WorkerID,
|
|
&i.IsActive,
|
|
&i.DaysOfWeek,
|
|
&i.StartTime,
|
|
&i.EndTime,
|
|
&i.NextCheck,
|
|
)
|
|
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 setWorkerSleepSchedule = `-- name: SetWorkerSleepSchedule :execlastid
|
|
INSERT INTO sleep_schedules (
|
|
created_at,
|
|
updated_at,
|
|
worker_id,
|
|
is_active,
|
|
days_of_week,
|
|
start_time,
|
|
end_time,
|
|
next_check
|
|
) VALUES (
|
|
?1,
|
|
?2,
|
|
?3,
|
|
?4,
|
|
?5,
|
|
?6,
|
|
?7,
|
|
?8
|
|
)
|
|
ON CONFLICT DO UPDATE
|
|
SET updated_at=?2, is_active=?4, days_of_week=?5, start_time=?6, end_time=?7, next_check=?8
|
|
WHERE worker_id=?3
|
|
`
|
|
|
|
type SetWorkerSleepScheduleParams struct {
|
|
CreatedAt time.Time
|
|
UpdatedAt sql.NullTime
|
|
WorkerID int64
|
|
IsActive bool
|
|
DaysOfWeek string
|
|
StartTime string
|
|
EndTime string
|
|
NextCheck sql.NullTime
|
|
}
|
|
|
|
// Note that the use of ?2 and ?3 in the SQL is not desirable, and should be
|
|
// replaced with @updated_at and @job_id as soon as sqlc issue #3334 is fixed.
|
|
// See https://github.com/sqlc-dev/sqlc/issues/3334 for more info.
|
|
func (q *Queries) SetWorkerSleepSchedule(ctx context.Context, arg SetWorkerSleepScheduleParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, setWorkerSleepSchedule,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
arg.WorkerID,
|
|
arg.IsActive,
|
|
arg.DaysOfWeek,
|
|
arg.StartTime,
|
|
arg.EndTime,
|
|
arg.NextCheck,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.LastInsertId()
|
|
}
|
|
|
|
const setWorkerSleepScheduleNextCheck = `-- name: SetWorkerSleepScheduleNextCheck :execrows
|
|
UPDATE sleep_schedules
|
|
SET next_check=?1
|
|
WHERE ID=?2
|
|
`
|
|
|
|
type SetWorkerSleepScheduleNextCheckParams struct {
|
|
NextCheck sql.NullTime
|
|
ScheduleID int64
|
|
}
|
|
|
|
func (q *Queries) SetWorkerSleepScheduleNextCheck(ctx context.Context, arg SetWorkerSleepScheduleNextCheckParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, setWorkerSleepScheduleNextCheck, arg.NextCheck, arg.ScheduleID)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|
|
|
|
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 test_CreateWorkerSleepSchedule = `-- name: Test_CreateWorkerSleepSchedule :execlastid
|
|
INSERT INTO sleep_schedules (
|
|
created_at,
|
|
worker_id,
|
|
is_active,
|
|
days_of_week,
|
|
start_time,
|
|
end_time,
|
|
next_check
|
|
) VALUES (
|
|
?1,
|
|
?2,
|
|
?3,
|
|
?4,
|
|
?5,
|
|
?6,
|
|
?7
|
|
)
|
|
`
|
|
|
|
type Test_CreateWorkerSleepScheduleParams struct {
|
|
CreatedAt time.Time
|
|
WorkerID int64
|
|
IsActive bool
|
|
DaysOfWeek string
|
|
StartTime string
|
|
EndTime string
|
|
NextCheck sql.NullTime
|
|
}
|
|
|
|
func (q *Queries) Test_CreateWorkerSleepSchedule(ctx context.Context, arg Test_CreateWorkerSleepScheduleParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, test_CreateWorkerSleepSchedule,
|
|
arg.CreatedAt,
|
|
arg.WorkerID,
|
|
arg.IsActive,
|
|
arg.DaysOfWeek,
|
|
arg.StartTime,
|
|
arg.EndTime,
|
|
arg.NextCheck,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.LastInsertId()
|
|
}
|
|
|
|
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
|
|
}
|