Michael McGuinness
428 lines
13 KiB
Go
428 lines
13 KiB
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 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 :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 pgtype.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 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 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 setQueryConfig = `-- name: SetQueryConfig :exec
|
|
INSERT INTO queryConfigs (queryId, config, addedVersion) VALUES ($1, $2, $3)
|
|
`
|
|
|
|
type SetQueryConfigParams struct {
|
|
Queryid pgtype.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
|
|
}
|