query-orchestration/internal/database/repository/collector.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.27.0
// source: collector.sql

package repository

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"
)

const addCollectorQuery = `-- name: AddCollectorQuery :exec
INSERT INTO collectorQueries (collectorId, name, queryId, addedVersion) VALUES ($1, $2, $3, $4)
`

type AddCollectorQueryParams struct {
	Collectorid  pgtype.UUID `db:"collectorid"`
	Name         string      `db:"name"`
	Queryid      pgtype.UUID `db:"queryid"`
	Addedversion int32       `db:"addedversion"`
}

// AddCollectorQuery
//
//	INSERT INTO collectorQueries (collectorId, name, queryId, addedVersion) VALUES ($1, $2, $3, $4)
func (q *Queries) AddCollectorQuery(ctx context.Context, arg *AddCollectorQueryParams) error {
	_, err := q.db.Exec(ctx, addCollectorQuery,
		arg.Collectorid,
		arg.Name,
		arg.Queryid,
		arg.Addedversion,
	)
	return err
}

const addLatestCollectorVersion = `-- name: AddLatestCollectorVersion :one
INSERT INTO collectorVersions (collectorId) VALUES ($1) RETURNING id
`

// AddLatestCollectorVersion
//
//	INSERT INTO collectorVersions (collectorId) VALUES ($1) RETURNING id
func (q *Queries) AddLatestCollectorVersion(ctx context.Context, collectorid pgtype.UUID) (int32, error) {
	row := q.db.QueryRow(ctx, addLatestCollectorVersion, collectorid)
	var id int32
	err := row.Scan(&id)
	return id, err
}

const createCollector = `-- name: CreateCollector :one
INSERT INTO collectors (jobId) VALUES ($1) RETURNING id
`

// CreateCollector
//
//	INSERT INTO collectors (jobId) VALUES ($1) RETURNING id
func (q *Queries) CreateCollector(ctx context.Context, jobid pgtype.UUID) (pgtype.UUID, error) {
	row := q.db.QueryRow(ctx, createCollector, jobid)
	var id pgtype.UUID
	err := row.Scan(&id)
	return id, err
}

const getCollector = `-- name: GetCollector :one
SELECT id, jobid, mincleanversion, mintextversion, activeversion, latestversion, fields FROM fullActiveCollectors WHERE id = $1 LIMIT 1
`

// GetCollector
//
//	SELECT id, jobid, mincleanversion, mintextversion, activeversion, latestversion, fields FROM fullActiveCollectors WHERE id = $1 LIMIT 1
func (q *Queries) GetCollector(ctx context.Context, id pgtype.UUID) (*Fullactivecollector, error) {
	row := q.db.QueryRow(ctx, getCollector, id)
	var i Fullactivecollector
	err := row.Scan(
		&i.ID,
		&i.Jobid,
		&i.Mincleanversion,
		&i.Mintextversion,
		&i.Activeversion,
		&i.Latestversion,
		&i.Fields,
	)
	return &i, err
}

const getCollectorByJobID = `-- name: GetCollectorByJobID :one
SELECT id, jobid, mincleanversion, mintextversion, activeversion, latestversion, fields FROM fullActiveCollectors WHERE jobId = $1 LIMIT 1
`

// GetCollectorByJobID
//
//	SELECT id, jobid, mincleanversion, mintextversion, activeversion, latestversion, fields FROM fullActiveCollectors WHERE jobId = $1 LIMIT 1
func (q *Queries) GetCollectorByJobID(ctx context.Context, jobid pgtype.UUID) (*Fullactivecollector, error) {
	row := q.db.QueryRow(ctx, getCollectorByJobID, jobid)
	var i Fullactivecollector
	err := row.Scan(
		&i.ID,
		&i.Jobid,
		&i.Mincleanversion,
		&i.Mintextversion,
		&i.Activeversion,
		&i.Latestversion,
		&i.Fields,
	)
	return &i, err
}

const listCollectorQueries = `-- name: ListCollectorQueries :many
SELECT collectorid, jobid, queryid, type, queryversion, requiredids FROM collectorQueryDependencyTree WHERE collectorId = $1
`

// ListCollectorQueries
//
//	SELECT collectorid, jobid, queryid, type, queryversion, requiredids FROM collectorQueryDependencyTree WHERE collectorId = $1
func (q *Queries) ListCollectorQueries(ctx context.Context, collectorid pgtype.UUID) ([]*Collectorquerydependencytree, error) {
	rows, err := q.db.Query(ctx, listCollectorQueries, collectorid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []*Collectorquerydependencytree{}
	for rows.Next() {
		var i Collectorquerydependencytree
		if err := rows.Scan(
			&i.Collectorid,
			&i.Jobid,
			&i.Queryid,
			&i.Type,
			&i.Queryversion,
			&i.Requiredids,
		); err != nil {
			return nil, err
		}
		items = append(items, &i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const removeCollectorQuery = `-- name: RemoveCollectorQuery :exec
UPDATE collectorQueries SET removedVersion = $1 WHERE queryId = $2 and collectorId = $3 and removedVersion is null
`

type RemoveCollectorQueryParams struct {
	Removedversion *int32      `db:"removedversion"`
	Queryid        pgtype.UUID `db:"queryid"`
	Collectorid    pgtype.UUID `db:"collectorid"`
}

// RemoveCollectorQuery
//
//	UPDATE collectorQueries SET removedVersion = $1 WHERE queryId = $2 and collectorId = $3 and removedVersion is null
func (q *Queries) RemoveCollectorQuery(ctx context.Context, arg *RemoveCollectorQueryParams) error {
	_, err := q.db.Exec(ctx, removeCollectorQuery, arg.Removedversion, arg.Queryid, arg.Collectorid)
	return err
}

const setActiveCollectorVersion = `-- name: SetActiveCollectorVersion :exec
INSERT INTO collectorActiveVersions (collectorId, versionId) VALUES ($1, $2)
`

type SetActiveCollectorVersionParams struct {
	Collectorid pgtype.UUID `db:"collectorid"`
	Versionid   int32       `db:"versionid"`
}

// SetActiveCollectorVersion
//
//	INSERT INTO collectorActiveVersions (collectorId, versionId) VALUES ($1, $2)
func (q *Queries) SetActiveCollectorVersion(ctx context.Context, arg *SetActiveCollectorVersionParams) error {
	_, err := q.db.Exec(ctx, setActiveCollectorVersion, arg.Collectorid, arg.Versionid)
	return err
}

const setCollectorCleanVersion = `-- name: SetCollectorCleanVersion :exec
INSERT INTO collectorMinCleanVersions (collectorId, addedVersion, versionId) VALUES ($1, $2, $3)
`

type SetCollectorCleanVersionParams struct {
	Collectorid  pgtype.UUID `db:"collectorid"`
	Addedversion int32       `db:"addedversion"`
	Versionid    int32       `db:"versionid"`
}

// SetCollectorCleanVersion
//
//	INSERT INTO collectorMinCleanVersions (collectorId, addedVersion, versionId) VALUES ($1, $2, $3)
func (q *Queries) SetCollectorCleanVersion(ctx context.Context, arg *SetCollectorCleanVersionParams) error {
	_, err := q.db.Exec(ctx, setCollectorCleanVersion, arg.Collectorid, arg.Addedversion, arg.Versionid)
	return err
}

const setCollectorTextVersion = `-- name: SetCollectorTextVersion :exec
INSERT INTO collectorMinTextVersions (collectorId, addedVersion, versionId) VALUES ($1, $2, $3)
`

type SetCollectorTextVersionParams struct {
	Collectorid  pgtype.UUID `db:"collectorid"`
	Addedversion int32       `db:"addedversion"`
	Versionid    int32       `db:"versionid"`
}

// SetCollectorTextVersion
//
//	INSERT INTO collectorMinTextVersions (collectorId, addedVersion, versionId) VALUES ($1, $2, $3)
func (q *Queries) SetCollectorTextVersion(ctx context.Context, arg *SetCollectorTextVersionParams) error {
	_, err := q.db.Exec(ctx, setCollectorTextVersion, arg.Collectorid, arg.Addedversion, arg.Versionid)
	return err
}