// 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
}