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

// 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 getQueryWithVersion = `-- name: GetQueryWithVersion :one
SELECT DISTINCT q.id, q.type, q.activeVersion, q.latestVersion, coalesce(c.config, null) as config, ARRAY_AGG(DISTINCT r.requiredQueryId)::uuid[] as requiredIds
    FROM queries AS q
    LEFT JOIN queryConfigs AS c ON q.id = c.queryId
        and $2 >= c.addedVersion
        and $2 < COALESCE(c.removedVersion, $2 + 1)
    LEFT JOIN requiredQueries AS r ON q.id = r.queryId
        and $2 >= r.addedVersion
        and $2 < COALESCE(r.removedVersion, $2 + 1)
    WHERE q.id = $1
    GROUP BY q.id, q.type, q.activeversion, q.latestversion, c.config
`

type GetQueryWithVersionParams struct {
	ID           pgtype.UUID `db:"id"`
	Addedversion int32       `db:"addedversion"`
}

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
//
//	SELECT DISTINCT q.id, q.type, q.activeVersion, q.latestVersion, coalesce(c.config, null) as config, ARRAY_AGG(DISTINCT r.requiredQueryId)::uuid[] as requiredIds
//	    FROM queries AS q
//	    LEFT JOIN queryConfigs AS c ON q.id = c.queryId
//	        and $2 >= c.addedVersion
//	        and $2 < COALESCE(c.removedVersion, $2 + 1)
//	    LEFT JOIN requiredQueries AS r ON q.id = r.queryId
//	        and $2 >= r.addedVersion
//	        and $2 < COALESCE(r.removedVersion, $2 + 1)
//	    WHERE q.id = $1
//	    GROUP BY q.id, q.type, q.activeversion, q.latestversion, c.config
func (q *Queries) GetQueryWithVersion(ctx context.Context, arg *GetQueryWithVersionParams) (*GetQueryWithVersionRow, error) {
	row := q.db.QueryRow(ctx, getQueryWithVersion, arg.ID, arg.Addedversion)
	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 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
}