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

package repository

import (
	"context"

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

const addResult = `-- name: AddResult :one
INSERT INTO results (queryId, value, textEntryId, queryVersion) VALUES ($1, $2, $3, $4) returning id
`

type AddResultParams struct {
	Queryid      pgtype.UUID `db:"queryid"`
	Value        string      `db:"value"`
	Textentryid  pgtype.UUID `db:"textentryid"`
	Queryversion int32       `db:"queryversion"`
}

// AddResult
//
//	INSERT INTO results (queryId, value, textEntryId, queryVersion) VALUES ($1, $2, $3, $4) returning id
func (q *Queries) AddResult(ctx context.Context, arg *AddResultParams) (pgtype.UUID, error) {
	row := q.db.QueryRow(ctx, addResult,
		arg.Queryid,
		arg.Value,
		arg.Textentryid,
		arg.Queryversion,
	)
	var id pgtype.UUID
	err := row.Scan(&id)
	return id, err
}

const addResultDependency = `-- name: AddResultDependency :exec
INSERT INTO resultDependencies (resultId, requiredResultId) VALUES ($1, $2)
`

type AddResultDependencyParams struct {
	Resultid         pgtype.UUID `db:"resultid"`
	Requiredresultid pgtype.UUID `db:"requiredresultid"`
}

// AddResultDependency
//
//	INSERT INTO resultDependencies (resultId, requiredResultId) VALUES ($1, $2)
func (q *Queries) AddResultDependency(ctx context.Context, arg *AddResultDependencyParams) error {
	_, err := q.db.Exec(ctx, addResultDependency, arg.Resultid, arg.Requiredresultid)
	return err
}

const getResultValueWithVersion = `-- name: GetResultValueWithVersion :one
WITH doc as (
    SELECT id, clientId
    FROM documents
    WHERE id = $3
)
SELECT r.id, r.value
    FROM doc as d
    JOIN currentTextEntries as cte on cte.documentId = d.id
    LEFT JOIN results as r
        on r.queryId = $1
        and r.queryVersion = $2
        and r.textEntryId = cte.id
`

type GetResultValueWithVersionParams struct {
	Queryid      pgtype.UUID `db:"queryid"`
	Queryversion *int32      `db:"queryversion"`
	Documentid   pgtype.UUID `db:"documentid"`
}

type GetResultValueWithVersionRow struct {
	ID    pgtype.UUID `db:"id"`
	Value *string     `db:"value"`
}

// GetResultValueWithVersion
//
//	WITH doc as (
//	    SELECT id, clientId
//	    FROM documents
//	    WHERE id = $3
//	)
//	SELECT r.id, r.value
//	    FROM doc as d
//	    JOIN currentTextEntries as cte on cte.documentId = d.id
//	    LEFT JOIN results as r
//	        on r.queryId = $1
//	        and r.queryVersion = $2
//	        and r.textEntryId = cte.id
func (q *Queries) GetResultValueWithVersion(ctx context.Context, arg *GetResultValueWithVersionParams) (*GetResultValueWithVersionRow, error) {
	row := q.db.QueryRow(ctx, getResultValueWithVersion, arg.Queryid, arg.Queryversion, arg.Documentid)
	var i GetResultValueWithVersionRow
	err := row.Scan(&i.ID, &i.Value)
	return &i, err
}

const listQueryRequirementValues = `-- name: ListQueryRequirementValues :many
WITH reqQueries as (
    SELECT av.queryId, av.activeVersion, q.type
    FROM requiredQueries as rq
    JOIN queryCurrentActiveVersions as av on av.queryId = rq.requiredQueryId
    JOIN queries as q on q.id = av.queryId
    WHERE rq.queryId = $1
        and isInVersion($2, rq.addedVersion, rq.removedVersion)
),
docs as (
    SELECT id, clientId
    FROM documents
    WHERE id = $3
),
codeVersions as (
    SELECT
        d.id as documentId,
        mcv.minCleanVersion,
        mtv.minTextVersion
    FROM docs as d
    JOIN currentCollectorMinTextVersions as mtv on mtv.clientId = d.clientId
    JOIN currentCollectorMinCleanVersions as mcv on mcv.clientId = d.clientId
),
latestVersions AS (
    SELECT
        r.id,
        rq.queryId,
        rq.type,
        r.queryVersion,
        r.textEntryId,
        r.value,
        ROW_NUMBER() OVER (
            PARTITION BY r.queryId
            ORDER BY r.id DESC
        ) as rowNumber
    FROM reqQueries as rq
    JOIN currentTextEntries as cte on cte.documentId = $3
    LEFT JOIN results as r ON rq.queryId = r.queryId
        and r.queryVersion = rq.activeVersion
        and cte.id = r.textEntryId
)
SELECT DISTINCT id, queryId, type, value
FROM latestVersions
WHERE rowNumber = 1
`

type ListQueryRequirementValuesParams struct {
	Queryid    pgtype.UUID `db:"queryid"`
	Version    *int32      `db:"version"`
	Documentid pgtype.UUID `db:"documentid"`
}

type ListQueryRequirementValuesRow struct {
	ID      pgtype.UUID `db:"id"`
	Queryid pgtype.UUID `db:"queryid"`
	Type    Querytype   `db:"type"`
	Value   *string     `db:"value"`
}

// ListQueryRequirementValues
//
//	WITH reqQueries as (
//	    SELECT av.queryId, av.activeVersion, q.type
//	    FROM requiredQueries as rq
//	    JOIN queryCurrentActiveVersions as av on av.queryId = rq.requiredQueryId
//	    JOIN queries as q on q.id = av.queryId
//	    WHERE rq.queryId = $1
//	        and isInVersion($2, rq.addedVersion, rq.removedVersion)
//	),
//	docs as (
//	    SELECT id, clientId
//	    FROM documents
//	    WHERE id = $3
//	),
//	codeVersions as (
//	    SELECT
//	        d.id as documentId,
//	        mcv.minCleanVersion,
//	        mtv.minTextVersion
//	    FROM docs as d
//	    JOIN currentCollectorMinTextVersions as mtv on mtv.clientId = d.clientId
//	    JOIN currentCollectorMinCleanVersions as mcv on mcv.clientId = d.clientId
//	),
//	latestVersions AS (
//	    SELECT
//	        r.id,
//	        rq.queryId,
//	        rq.type,
//	        r.queryVersion,
//	        r.textEntryId,
//	        r.value,
//	        ROW_NUMBER() OVER (
//	            PARTITION BY r.queryId
//	            ORDER BY r.id DESC
//	        ) as rowNumber
//	    FROM reqQueries as rq
//	    JOIN currentTextEntries as cte on cte.documentId = $3
//	    LEFT JOIN results as r ON rq.queryId = r.queryId
//	        and r.queryVersion = rq.activeVersion
//	        and cte.id = r.textEntryId
//	)
//	SELECT DISTINCT id, queryId, type, value
//	FROM latestVersions
//	WHERE rowNumber = 1
func (q *Queries) ListQueryRequirementValues(ctx context.Context, arg *ListQueryRequirementValuesParams) ([]*ListQueryRequirementValuesRow, error) {
	rows, err := q.db.Query(ctx, listQueryRequirementValues, arg.Queryid, arg.Version, arg.Documentid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []*ListQueryRequirementValuesRow{}
	for rows.Next() {
		var i ListQueryRequirementValuesRow
		if err := rows.Scan(
			&i.ID,
			&i.Queryid,
			&i.Type,
			&i.Value,
		); err != nil {
			return nil, err
		}
		items = append(items, &i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listUnsyncedNoDepsQueriesByDocId = `-- name: ListUnsyncedNoDepsQueriesByDocId :many
WITH docs as (
    SELECT id, clientId from documents where id = $1
),
unsyncedQueries AS (
    SELECT DISTINCT dt.queryId, dt.requiredIds
        from docs as d
        JOIN collectorQueryDependencyTree as dt on d.clientId = dt.clientId
        JOIN currentTextEntries as cte on cte.documentId = d.id
        LEFT JOIN results as r
            on r.queryId = dt.queryId
            and r.queryVersion = dt.queryVersion
            and cte.id = r.textEntryId
        where r.value is null
)
SELECT DISTINCT queryId FROM unsyncedQueries as baseuq
    WHERE NOT EXISTS (
        SELECT 1 FROM unsyncedQueries as uq WHERE uq.queryId = any(baseuq.requiredIds)
    )
`

// ListUnsyncedNoDepsQueriesByDocId
//
//	WITH docs as (
//	    SELECT id, clientId from documents where id = $1
//	),
//	unsyncedQueries AS (
//	    SELECT DISTINCT dt.queryId, dt.requiredIds
//	        from docs as d
//	        JOIN collectorQueryDependencyTree as dt on d.clientId = dt.clientId
//	        JOIN currentTextEntries as cte on cte.documentId = d.id
//	        LEFT JOIN results as r
//	            on r.queryId = dt.queryId
//	            and r.queryVersion = dt.queryVersion
//	            and cte.id = r.textEntryId
//	        where r.value is null
//	)
//	SELECT DISTINCT queryId FROM unsyncedQueries as baseuq
//	    WHERE NOT EXISTS (
//	        SELECT 1 FROM unsyncedQueries as uq WHERE uq.queryId = any(baseuq.requiredIds)
//	    )
func (q *Queries) ListUnsyncedNoDepsQueriesByDocId(ctx context.Context, dollar_1 pgtype.UUID) ([]pgtype.UUID, error) {
	rows, err := q.db.Query(ctx, listUnsyncedNoDepsQueriesByDocId, dollar_1)
	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
}