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

package repository

import (
	"context"

	"github.com/google/uuid"
)

const addActiveQueryVersion = `-- name: AddActiveQueryVersion :exec
INSERT INTO queryActiveVersions (queryId, versionId) VALUES ($1, $2)
`

type AddActiveQueryVersionParams struct {
	Queryid   uuid.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 :one
INSERT INTO queryVersions (queryId) VALUES ($1) RETURNING id
`

// AddLatestQueryVersion
//
//	INSERT INTO queryVersions (queryId) VALUES ($1) RETURNING id
func (q *Queries) AddLatestQueryVersion(ctx context.Context, queryid uuid.UUID) (int32, error) {
	row := q.db.QueryRow(ctx, addLatestQueryVersion, queryid)
	var id int32
	err := row.Scan(&id)
	return id, err
}

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

type AddRequiredQueryParams struct {
	Queryid         uuid.UUID `db:"queryid"`
	Requiredqueryid uuid.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 []uuid.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) (uuid.UUID, error) {
	row := q.db.QueryRow(ctx, createQuery, type_)
	var id uuid.UUID
	err := row.Scan(&id)
	return id, err
}

const getActiveQueryConfig = `-- name: GetActiveQueryConfig :one
SELECT config FROM queryCurrentConfigs where queryId = $1
`

// GetActiveQueryConfig
//
//	SELECT config FROM queryCurrentConfigs where queryId = $1
func (q *Queries) GetActiveQueryConfig(ctx context.Context, queryid uuid.UUID) ([]byte, error) {
	row := q.db.QueryRow(ctx, getActiveQueryConfig, queryid)
	var config []byte
	err := row.Scan(&config)
	return config, 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 uuid.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 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,
    coalesce(
        ARRAY_AGG(DISTINCT r.requiredQueryId)
        FILTER (WHERE r.requiredQueryId != '00000000-0000-0000-0000-000000000000')::uuid[],
        array[]::uuid[]
    )::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,
    av.activeVersion,
    lv.latestVersion, c.config,
    r.requiredIds
    FROM query AS q
    JOIN queryCurrentActiveVersions as av on q.id = av.queryId
    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      *uuid.UUID `db:"id"`
	Version *int32     `db:"version"`
}

type GetQueryWithVersionRow struct {
	ID            uuid.UUID   `db:"id"`
	Type          Querytype   `db:"type"`
	Activeversion int32       `db:"activeversion"`
	Latestversion int32       `db:"latestversion"`
	Config        []byte      `db:"config"`
	Requiredids   []uuid.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,
//	    coalesce(
//	        ARRAY_AGG(DISTINCT r.requiredQueryId)
//	        FILTER (WHERE r.requiredQueryId != '00000000-0000-0000-0000-000000000000')::uuid[],
//	        array[]::uuid[]
//	    )::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,
//	    av.activeVersion,
//	    lv.latestVersion, c.config,
//	    r.requiredIds
//	    FROM query AS q
//	    JOIN queryCurrentActiveVersions as av on q.id = av.queryId
//	    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 {
	Requiredqueryids []uuid.UUID `db:"requiredqueryids"`
	Queryid          *uuid.UUID  `db:"queryid"`
}

// 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.Requiredqueryids, arg.Queryid)
	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 []uuid.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 listQueryClientIDs = `-- name: ListQueryClientIDs :many
SELECT clientId FROM collectorQueryDependencyTree WHERE queryId = $1
`

// ListQueryClientIDs
//
//	SELECT clientId FROM collectorQueryDependencyTree WHERE queryId = $1
func (q *Queries) ListQueryClientIDs(ctx context.Context, queryid *uuid.UUID) ([]uuid.UUID, error) {
	rows, err := q.db.Query(ctx, listQueryClientIDs, queryid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []uuid.UUID{}
	for rows.Next() {
		var clientid uuid.UUID
		if err := rows.Scan(&clientid); err != nil {
			return nil, err
		}
		items = append(items, clientid)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listQueryDirectDependentsByDocumentID = `-- name: ListQueryDirectDependentsByDocumentID :many
WITH doc AS (
    SELECT id, clientId FROM documents where id = $2
)
SELECT dt.queryId
    FROM doc as d
    JOIN collectorQueryDependencyTree as dt
        on d.clientId = dt.clientId
        and $1 = any(dt.requiredIds)
`

type ListQueryDirectDependentsByDocumentIDParams struct {
	Queryid    uuid.UUID `db:"queryid"`
	Documentid uuid.UUID `db:"documentid"`
}

// ListQueryDirectDependentsByDocumentID
//
//	WITH doc AS (
//	    SELECT id, clientId FROM documents where id = $2
//	)
//	SELECT dt.queryId
//	    FROM doc as d
//	    JOIN collectorQueryDependencyTree as dt
//	        on d.clientId = dt.clientId
//	        and $1 = any(dt.requiredIds)
func (q *Queries) ListQueryDirectDependentsByDocumentID(ctx context.Context, arg *ListQueryDirectDependentsByDocumentIDParams) ([]*uuid.UUID, error) {
	rows, err := q.db.Query(ctx, listQueryDirectDependentsByDocumentID, arg.Queryid, arg.Documentid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []*uuid.UUID{}
	for rows.Next() {
		var queryid *uuid.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 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 uuid.UUID `db:"requiredqueryid"`
	Queryid         uuid.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 setQueryConfig = `-- name: SetQueryConfig :exec
INSERT INTO queryConfigs (queryId, config, addedVersion) VALUES ($1, $2, $3)
`

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

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