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

package repository

import (
	"context"

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

const addQueryConfig = `-- name: AddQueryConfig :exec
INSERT INTO queryConfigs (queryId, config, addedVersion) VALUES ($1, $2, $3)
`

type AddQueryConfigParams struct {
	Queryid      pgtype.UUID `db:"queryid"`
	Config       []byte      `db:"config"`
	Addedversion int32       `db:"addedversion"`
}

// AddQueryConfig
//
//	INSERT INTO queryConfigs (queryId, config, addedVersion) VALUES ($1, $2, $3)
func (q *Queries) AddQueryConfig(ctx context.Context, arg *AddQueryConfigParams) error {
	_, err := q.db.Exec(ctx, addQueryConfig, arg.Queryid, arg.Config, arg.Addedversion)
	return err
}

const addRequiredQuery = `-- name: AddRequiredQuery :exec
INSERT INTO requiredQueries (queryId, requiredQueryId, addedVersion) VALUES ($1, $2, $3)
`

type AddRequiredQueryParams struct {
	Queryid         pgtype.UUID `db:"queryid"`
	Requiredqueryid pgtype.UUID `db:"requiredqueryid"`
	Addedversion    int32       `db:"addedversion"`
}

// AddRequiredQuery
//
//	INSERT INTO requiredQueries (queryId, requiredQueryId, addedVersion) VALUES ($1, $2, $3)
func (q *Queries) AddRequiredQuery(ctx context.Context, arg *AddRequiredQueryParams) error {
	_, err := q.db.Exec(ctx, addRequiredQuery, arg.Queryid, arg.Requiredqueryid, arg.Addedversion)
	return err
}

const allQueriesExist = `-- name: AllQueriesExist :one
SELECT COUNT(*) = COUNT(DISTINCT id) AS all_exist
    FROM unnest($1::uuid[]) AS input_id
    LEFT JOIN queries ON input_id = queries.id
`

// AllQueriesExist
//
//	SELECT COUNT(*) = COUNT(DISTINCT id) AS all_exist
//	    FROM unnest($1::uuid[]) AS input_id
//	    LEFT JOIN queries ON input_id = queries.id
func (q *Queries) AllQueriesExist(ctx context.Context, dollar_1 []pgtype.UUID) (bool, error) {
	row := q.db.QueryRow(ctx, allQueriesExist, dollar_1)
	var all_exist bool
	err := row.Scan(&all_exist)
	return all_exist, err
}

const createQuery = `-- name: CreateQuery :one
INSERT INTO queries (type) VALUES ($1) RETURNING id
`

// CreateQuery
//
//	INSERT INTO queries (type) VALUES ($1) RETURNING id
func (q *Queries) CreateQuery(ctx context.Context, type_ Querytype) (pgtype.UUID, error) {
	row := q.db.QueryRow(ctx, createQuery, type_)
	var id pgtype.UUID
	err := row.Scan(&id)
	return id, err
}

const getQuery = `-- name: GetQuery :one
SELECT id, type, activeversion, latestversion, config, requiredids FROM fullActiveQueries WHERE id = $1
`

// GetQuery
//
//	SELECT id, type, activeversion, latestversion, config, requiredids FROM fullActiveQueries WHERE id = $1
func (q *Queries) GetQuery(ctx context.Context, id pgtype.UUID) (*Fullactivequery, error) {
	row := q.db.QueryRow(ctx, getQuery, id)
	var i Fullactivequery
	err := row.Scan(
		&i.ID,
		&i.Type,
		&i.Activeversion,
		&i.Latestversion,
		&i.Config,
		&i.Requiredids,
	)
	return &i, err
}

const getQueryConfig = `-- name: GetQueryConfig :one
SELECT id, config FROM queryConfigs where queryId = $1 and addedVersion >= $2 and COALESCE(removedVersion, $2 - 1) < $2
`

type GetQueryConfigParams struct {
	Queryid      pgtype.UUID `db:"queryid"`
	Addedversion int32       `db:"addedversion"`
}

type GetQueryConfigRow struct {
	ID     pgtype.UUID `db:"id"`
	Config []byte      `db:"config"`
}

// GetQueryConfig
//
//	SELECT id, config FROM queryConfigs where queryId = $1 and addedVersion >= $2 and COALESCE(removedVersion, $2 - 1) < $2
func (q *Queries) GetQueryConfig(ctx context.Context, arg *GetQueryConfigParams) (*GetQueryConfigRow, error) {
	row := q.db.QueryRow(ctx, getQueryConfig, arg.Queryid, arg.Addedversion)
	var i GetQueryConfigRow
	err := row.Scan(&i.ID, &i.Config)
	return &i, err
}

const isQueryInDependencyTree = `-- name: IsQueryInDependencyTree :one
SELECT EXISTS (
    SELECT 1 FROM queryActiveDependencies WHERE id = any($1) and requiredQueryId = $2 or $2 = any($1)
)
`

type IsQueryInDependencyTreeParams struct {
	ID              []pgtype.UUID `db:"id"`
	Requiredqueryid pgtype.UUID   `db:"requiredqueryid"`
}

// IsQueryInDependencyTree
//
//	SELECT EXISTS (
//	    SELECT 1 FROM queryActiveDependencies WHERE id = any($1) and requiredQueryId = $2 or $2 = any($1)
//	)
func (q *Queries) IsQueryInDependencyTree(ctx context.Context, arg *IsQueryInDependencyTreeParams) (bool, error) {
	row := q.db.QueryRow(ctx, isQueryInDependencyTree, arg.ID, arg.Requiredqueryid)
	var exists bool
	err := row.Scan(&exists)
	return exists, err
}

const listQueries = `-- name: ListQueries :many
SELECT id, type, activeversion, latestversion, config, requiredids FROM fullActiveQueries
`

// ListQueries
//
//	SELECT id, type, activeversion, latestversion, config, requiredids FROM fullActiveQueries
func (q *Queries) ListQueries(ctx context.Context) ([]*Fullactivequery, error) {
	rows, err := q.db.Query(ctx, listQueries)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []*Fullactivequery{}
	for rows.Next() {
		var i Fullactivequery
		if err := rows.Scan(
			&i.ID,
			&i.Type,
			&i.Activeversion,
			&i.Latestversion,
			&i.Config,
			&i.Requiredids,
		); err != nil {
			return nil, err
		}
		items = append(items, &i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const removeQueryConfig = `-- name: RemoveQueryConfig :exec
UPDATE queryConfigs SET removedVersion = $1 WHERE queryId = $2 and removedVersion is null
`

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

// RemoveQueryConfig
//
//	UPDATE queryConfigs SET removedVersion = $1 WHERE queryId = $2 and removedVersion is null
func (q *Queries) RemoveQueryConfig(ctx context.Context, arg *RemoveQueryConfigParams) error {
	_, err := q.db.Exec(ctx, removeQueryConfig, arg.Removedversion, arg.Queryid)
	return err
}

const removeRequiredQuery = `-- name: RemoveRequiredQuery :exec
UPDATE requiredQueries SET removedVersion = $1 WHERE requiredQueryId = $2 and queryId = $3 and removedVersion is null
`

type RemoveRequiredQueryParams struct {
	Removedversion  *int32      `db:"removedversion"`
	Requiredqueryid pgtype.UUID `db:"requiredqueryid"`
	Queryid         pgtype.UUID `db:"queryid"`
}

// RemoveRequiredQuery
//
//	UPDATE requiredQueries SET removedVersion = $1 WHERE requiredQueryId = $2 and queryId = $3 and removedVersion is null
func (q *Queries) RemoveRequiredQuery(ctx context.Context, arg *RemoveRequiredQueryParams) error {
	_, err := q.db.Exec(ctx, removeRequiredQuery, arg.Removedversion, arg.Requiredqueryid, arg.Queryid)
	return err
}

const updateQuery = `-- name: UpdateQuery :exec
UPDATE queries SET activeVersion = $1, latestVersion = $2 WHERE id = $3
`

type UpdateQueryParams struct {
	Activeversion int32       `db:"activeversion"`
	Latestversion int32       `db:"latestversion"`
	ID            pgtype.UUID `db:"id"`
}

// UpdateQuery
//
//	UPDATE queries SET activeVersion = $1, latestVersion = $2 WHERE id = $3
func (q *Queries) UpdateQuery(ctx context.Context, arg *UpdateQueryParams) error {
	_, err := q.db.Exec(ctx, updateQuery, arg.Activeversion, arg.Latestversion, arg.ID)
	return err
}