// 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 addActiveQueryVersion = `-- name: AddActiveQueryVersion :exec
INSERT INTO queryActiveVersions (queryId, versionId) VALUES ($1, $2)
`

type AddActiveQueryVersionParams struct {
	Queryid   pgtype.UUID `db:"queryid"`
	Versionid int32       `db:"versionid"`
}

// AddActiveQueryVersion
//
//	INSERT INTO queryActiveVersions (queryId, versionId) VALUES ($1, $2)
func (q *Queries) AddActiveQueryVersion(ctx context.Context, arg *AddActiveQueryVersionParams) error {
	_, err := q.db.Exec(ctx, addActiveQueryVersion, arg.Queryid, arg.Versionid)
	return err
}

const addLatestQueryVersion = `-- name: AddLatestQueryVersion :exec
INSERT INTO queryVersions (queryId) VALUES ($1)
`

// AddLatestQueryVersion
//
//	INSERT INTO queryVersions (queryId) VALUES ($1)
func (q *Queries) AddLatestQueryVersion(ctx context.Context, queryid pgtype.UUID) error {
	_, err := q.db.Exec(ctx, addLatestQueryVersion, queryid)
	return err
}

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 getQueryWithVersion = `-- name: GetQueryWithVersion :one
WITH query as (
    SELECT id, type FROM queries WHERE id = $1
),
config as (
SELECT c.queryId, c.config
    FROM query AS q
    LEFT JOIN queryConfigs AS c ON q.id = c.queryId
        and isInVersion($2, c.addedVersion, c.removedVersion)
),
requiredIds as (
    SELECT r.queryId,
        ARRAY_AGG(DISTINCT r.requiredQueryId)
        FILTER (WHERE r.requiredQueryId != '00000000-0000-0000-0000-000000000000')::uuid[]
        as requiredIds
    FROM query AS q
    LEFT JOIN requiredQueries AS r ON q.id = r.queryId
        and isInVersion($2, r.addedVersion, r.removedVersion)
    GROUP BY r.queryId
)
SELECT DISTINCT q.id, q.type, coalesce(av.id, 0) as activeVersion, coalesce(lv.id, 0) as latestVersion, c.config,
    coalesce(
        r.requiredIds,
        array[]::uuid[]
    )::uuid[] as requiredIds
    FROM query AS q
    LEFT JOIN queryCurrentActiveVersions as av on q.id = av.queryId
    LEFT JOIN queryLatestVersions as lv on lv.queryId = q.id
    LEFT JOIN config AS c ON q.id = c.queryId
    LEFT JOIN requiredIds AS r ON q.id = r.queryId
`

type GetQueryWithVersionParams struct {
	ID      pgtype.UUID `db:"id"`
	Version *int32      `db:"version"`
}

type GetQueryWithVersionRow struct {
	ID            pgtype.UUID   `db:"id"`
	Type          Querytype     `db:"type"`
	Activeversion int32         `db:"activeversion"`
	Latestversion int32         `db:"latestversion"`
	Config        []byte        `db:"config"`
	Requiredids   []pgtype.UUID `db:"requiredids"`
}

// GetQueryWithVersion
//
//	WITH query as (
//	    SELECT id, type FROM queries WHERE id = $1
//	),
//	config as (
//	SELECT c.queryId, c.config
//	    FROM query AS q
//	    LEFT JOIN queryConfigs AS c ON q.id = c.queryId
//	        and isInVersion($2, c.addedVersion, c.removedVersion)
//	),
//	requiredIds as (
//	    SELECT r.queryId,
//	        ARRAY_AGG(DISTINCT r.requiredQueryId)
//	        FILTER (WHERE r.requiredQueryId != '00000000-0000-0000-0000-000000000000')::uuid[]
//	        as requiredIds
//	    FROM query AS q
//	    LEFT JOIN requiredQueries AS r ON q.id = r.queryId
//	        and isInVersion($2, r.addedVersion, r.removedVersion)
//	    GROUP BY r.queryId
//	)
//	SELECT DISTINCT q.id, q.type, coalesce(av.id, 0) as activeVersion, coalesce(lv.id, 0) as latestVersion, c.config,
//	    coalesce(
//	        r.requiredIds,
//	        array[]::uuid[]
//	    )::uuid[] as requiredIds
//	    FROM query AS q
//	    LEFT JOIN queryCurrentActiveVersions as av on q.id = av.queryId
//	    LEFT JOIN queryLatestVersions as lv on lv.queryId = q.id
//	    LEFT JOIN config AS c ON q.id = c.queryId
//	    LEFT JOIN requiredIds AS r ON q.id = r.queryId
func (q *Queries) GetQueryWithVersion(ctx context.Context, arg *GetQueryWithVersionParams) (*GetQueryWithVersionRow, error) {
	row := q.db.QueryRow(ctx, getQueryWithVersion, arg.ID, arg.Version)
	var i GetQueryWithVersionRow
	err := row.Scan(
		&i.ID,
		&i.Type,
		&i.Activeversion,
		&i.Latestversion,
		&i.Config,
		&i.Requiredids,
	)
	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 listQueriesById = `-- name: ListQueriesById :many
SELECT id, type, activeversion, latestversion, config, requiredids FROM fullActiveQueries WHERE id = any($1)
`

// ListQueriesById
//
//	SELECT id, type, activeversion, latestversion, config, requiredids FROM fullActiveQueries WHERE id = any($1)
func (q *Queries) ListQueriesById(ctx context.Context, id []pgtype.UUID) ([]*Fullactivequery, error) {
	rows, err := q.db.Query(ctx, listQueriesById, id)
	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 listQueryDirectDependentsByDocumentID = `-- name: ListQueryDirectDependentsByDocumentID :many
WITH doc AS (
    SELECT id, jobId FROM documents where id = $2
)
SELECT dt.queryId
    FROM collectorQueryDependencyTree as dt
    JOIN doc as d on d.jobId = dt.jobId
    where $1 = any(dt.requiredIds)
`

type ListQueryDirectDependentsByDocumentIDParams struct {
	Requiredids pgtype.UUID `db:"requiredids"`
	ID          pgtype.UUID `db:"id"`
}

// ListQueryDirectDependentsByDocumentID
//
//	WITH doc AS (
//	    SELECT id, jobId FROM documents where id = $2
//	)
//	SELECT dt.queryId
//	    FROM collectorQueryDependencyTree as dt
//	    JOIN doc as d on d.jobId = dt.jobId
//	    where $1 = any(dt.requiredIds)
func (q *Queries) ListQueryDirectDependentsByDocumentID(ctx context.Context, arg *ListQueryDirectDependentsByDocumentIDParams) ([]pgtype.UUID, error) {
	rows, err := q.db.Query(ctx, listQueryDirectDependentsByDocumentID, arg.Requiredids, arg.ID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []pgtype.UUID{}
	for rows.Next() {
		var queryid pgtype.UUID
		if err := rows.Scan(&queryid); err != nil {
			return nil, err
		}
		items = append(items, queryid)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listQueryJobIDs = `-- name: ListQueryJobIDs :many
SELECT jobId FROM collectorQueryDependencyTree WHERE queryId = $1
`

// ListQueryJobIDs
//
//	SELECT jobId FROM collectorQueryDependencyTree WHERE queryId = $1
func (q *Queries) ListQueryJobIDs(ctx context.Context, queryid pgtype.UUID) ([]pgtype.UUID, error) {
	rows, err := q.db.Query(ctx, listQueryJobIDs, queryid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []pgtype.UUID{}
	for rows.Next() {
		var jobid pgtype.UUID
		if err := rows.Scan(&jobid); err != nil {
			return nil, err
		}
		items = append(items, jobid)
	}
	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
}