stillbox/pkg/database/talkgroups.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.26.0
// source: talkgroups.sql

package database

import (
	"context"
)

const bulkSetTalkgroupTags = `-- name: BulkSetTalkgroupTags :exec
UPDATE talkgroups SET tags = $2
WHERE id = ANY($1)
`

func (q *Queries) BulkSetTalkgroupTags(ctx context.Context, iD int64, tags []string) error {
	_, err := q.db.Exec(ctx, bulkSetTalkgroupTags, iD, tags)
	return err
}

const getSystemName = `-- name: GetSystemName :one
SELECT name FROM systems WHERE id = $1
`

func (q *Queries) GetSystemName(ctx context.Context, systemID int) (string, error) {
	row := q.db.QueryRow(ctx, getSystemName, systemID)
	var name string
	err := row.Scan(&name)
	return name, err
}

const getTalkgroup = `-- name: GetTalkgroup :one
SELECT id, system_id, tgid, name, alpha_tag, tg_group, frequency, metadata, tags, alert, alert_config, weight FROM talkgroups
WHERE id = systg2id($1, $2)
`

func (q *Queries) GetTalkgroup(ctx context.Context, systemID int, tgid int) (Talkgroup, error) {
	row := q.db.QueryRow(ctx, getTalkgroup, systemID, tgid)
	var i Talkgroup
	err := row.Scan(
		&i.ID,
		&i.SystemID,
		&i.Tgid,
		&i.Name,
		&i.AlphaTag,
		&i.TgGroup,
		&i.Frequency,
		&i.Metadata,
		&i.Tags,
		&i.Alert,
		&i.AlertConfig,
		&i.Weight,
	)
	return i, err
}

const getTalkgroupIDsByTags = `-- name: GetTalkgroupIDsByTags :many
SELECT system_id, tgid FROM talkgroups
WHERE (tags @> ARRAY[$1])
AND (tags && ARRAY[$2])
AND NOT (tags @> ARRAY[$3])
`

type GetTalkgroupIDsByTagsRow struct {
	SystemID int32 `json:"system_id"`
	Tgid     int32 `json:"tgid"`
}

func (q *Queries) GetTalkgroupIDsByTags(ctx context.Context, anytags []string, alltags []string, nottags []string) ([]GetTalkgroupIDsByTagsRow, error) {
	rows, err := q.db.Query(ctx, getTalkgroupIDsByTags, anytags, alltags, nottags)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetTalkgroupIDsByTagsRow
	for rows.Next() {
		var i GetTalkgroupIDsByTagsRow
		if err := rows.Scan(&i.SystemID, &i.Tgid); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getTalkgroupTags = `-- name: GetTalkgroupTags :one
SELECT tags FROM talkgroups
WHERE id = systg2id($1, $2)
`

func (q *Queries) GetTalkgroupTags(ctx context.Context, sys int, tg int) ([]string, error) {
	row := q.db.QueryRow(ctx, getTalkgroupTags, sys, tg)
	var tags []string
	err := row.Scan(&tags)
	return tags, err
}

const getTalkgroupWithLearned = `-- name: GetTalkgroupWithLearned :one
SELECT
tg.id, tg.system_id, sys.name system_name, tg.tgid, tg.name,
tg.tg_group, tg.frequency, tg.metadata, tg.tags, tg.alpha_tag,
tg.alert, tg.weight, tg.alert_config,
FALSE learned
FROM talkgroups tg
JOIN systems sys ON tg.system_id = sys.id
WHERE tg.id = systg2id($1, $2)
UNION
SELECT
tgl.id::INT8, tgl.system_id::INT4, sys.name system_name, tgl.tgid::INT4, tgl.name,
tgl.alpha_tag, NULL::INTEGER, NULL::JSONB,
CASE WHEN tgl.alpha_tag IS NULL THEN NULL ELSE ARRAY[tgl.alpha_tag] END, tgl.alpha_tag,
TRUE, 1.0, NULL::JSONB,
TRUE learned
FROM talkgroups_learned tgl
JOIN systems sys ON tgl.system_id = sys.id
WHERE tgl.system_id = $1 AND tgl.tgid = $2 AND ignored IS NOT TRUE
`

type GetTalkgroupWithLearnedRow struct {
	ID          int64    `json:"id"`
	SystemID    int32    `json:"system_id"`
	SystemName  string   `json:"system_name"`
	Tgid        int32    `json:"tgid"`
	Name        *string  `json:"name"`
	TgGroup     *string  `json:"tg_group"`
	Frequency   *int32   `json:"frequency"`
	Metadata    []byte   `json:"metadata"`
	Tags        []string `json:"tags"`
	AlphaTag    *string  `json:"alpha_tag"`
	Alert       bool     `json:"alert"`
	Weight      float32  `json:"weight"`
	AlertConfig []byte   `json:"alert_config"`
	Learned     bool     `json:"learned"`
}

func (q *Queries) GetTalkgroupWithLearned(ctx context.Context, systemID int, tgid int) (GetTalkgroupWithLearnedRow, error) {
	row := q.db.QueryRow(ctx, getTalkgroupWithLearned, systemID, tgid)
	var i GetTalkgroupWithLearnedRow
	err := row.Scan(
		&i.ID,
		&i.SystemID,
		&i.SystemName,
		&i.Tgid,
		&i.Name,
		&i.TgGroup,
		&i.Frequency,
		&i.Metadata,
		&i.Tags,
		&i.AlphaTag,
		&i.Alert,
		&i.Weight,
		&i.AlertConfig,
		&i.Learned,
	)
	return i, err
}

const getTalkgroupWithLearnedByPackedIDs = `-- name: GetTalkgroupWithLearnedByPackedIDs :many
SELECT
tg.id, tg.system_id, sys.name system_name, tg.tgid, tg.name,
tg.tg_group, tg.frequency, tg.metadata, tg.tags, tg.alpha_tag,
tg.alert, tg.weight, tg.alert_config,
FALSE learned
FROM talkgroups tg
JOIN systems sys ON tg.system_id = sys.id
WHERE tg.id = ANY($1::INT8[])
UNION
SELECT
tgl.id::INT8, tgl.system_id::INT4, sys.name system_name, tgl.tgid::INT4, tgl.name,
tgl.alpha_tag, NULL::INTEGER, NULL::JSONB,
CASE WHEN tgl.alpha_tag IS NULL THEN NULL ELSE ARRAY[tgl.alpha_tag] END, tgl.alpha_tag,
TRUE, 1.0, NULL::JSONB,
TRUE learned
FROM talkgroups_learned tgl
JOIN systems sys ON tgl.system_id = sys.id
WHERE systg2id(tgl.system_id, tgl.tgid) = ANY($1::INT8[]) AND ignored IS NOT TRUE
`

type GetTalkgroupWithLearnedByPackedIDsRow struct {
	ID          int64    `json:"id"`
	SystemID    int32    `json:"system_id"`
	SystemName  string   `json:"system_name"`
	Tgid        int32    `json:"tgid"`
	Name        *string  `json:"name"`
	TgGroup     *string  `json:"tg_group"`
	Frequency   *int32   `json:"frequency"`
	Metadata    []byte   `json:"metadata"`
	Tags        []string `json:"tags"`
	AlphaTag    *string  `json:"alpha_tag"`
	Alert       bool     `json:"alert"`
	Weight      float32  `json:"weight"`
	AlertConfig []byte   `json:"alert_config"`
	Learned     bool     `json:"learned"`
}

func (q *Queries) GetTalkgroupWithLearnedByPackedIDs(ctx context.Context, dollar_1 []int64) ([]GetTalkgroupWithLearnedByPackedIDsRow, error) {
	rows, err := q.db.Query(ctx, getTalkgroupWithLearnedByPackedIDs, dollar_1)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetTalkgroupWithLearnedByPackedIDsRow
	for rows.Next() {
		var i GetTalkgroupWithLearnedByPackedIDsRow
		if err := rows.Scan(
			&i.ID,
			&i.SystemID,
			&i.SystemName,
			&i.Tgid,
			&i.Name,
			&i.TgGroup,
			&i.Frequency,
			&i.Metadata,
			&i.Tags,
			&i.AlphaTag,
			&i.Alert,
			&i.Weight,
			&i.AlertConfig,
			&i.Learned,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getTalkgroupsByPackedIDs = `-- name: GetTalkgroupsByPackedIDs :many
SELECT tg.id, system_id, tgid, tg.name, alpha_tag, tg_group, frequency, metadata, tags, alert, alert_config, weight, sys.id, sys.name FROM talkgroups tg
JOIN systems sys ON tg.system_id = sys.id
WHERE tg.id = ANY($1::INT8[])
`

type GetTalkgroupsByPackedIDsRow struct {
	ID          int64    `json:"id"`
	SystemID    int32    `json:"system_id"`
	Tgid        int32    `json:"tgid"`
	Name        *string  `json:"name"`
	AlphaTag    *string  `json:"alpha_tag"`
	TgGroup     *string  `json:"tg_group"`
	Frequency   *int32   `json:"frequency"`
	Metadata    []byte   `json:"metadata"`
	Tags        []string `json:"tags"`
	Alert       bool     `json:"alert"`
	AlertConfig []byte   `json:"alert_config"`
	Weight      float32  `json:"weight"`
	ID_2        int      `json:"id_2"`
	Name_2      string   `json:"name_2"`
}

func (q *Queries) GetTalkgroupsByPackedIDs(ctx context.Context, dollar_1 []int64) ([]GetTalkgroupsByPackedIDsRow, error) {
	rows, err := q.db.Query(ctx, getTalkgroupsByPackedIDs, dollar_1)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetTalkgroupsByPackedIDsRow
	for rows.Next() {
		var i GetTalkgroupsByPackedIDsRow
		if err := rows.Scan(
			&i.ID,
			&i.SystemID,
			&i.Tgid,
			&i.Name,
			&i.AlphaTag,
			&i.TgGroup,
			&i.Frequency,
			&i.Metadata,
			&i.Tags,
			&i.Alert,
			&i.AlertConfig,
			&i.Weight,
			&i.ID_2,
			&i.Name_2,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getTalkgroupsWithAllTags = `-- name: GetTalkgroupsWithAllTags :many
SELECT id, system_id, tgid, name, alpha_tag, tg_group, frequency, metadata, tags, alert, alert_config, weight FROM talkgroups
WHERE tags && ARRAY[$1]
`

func (q *Queries) GetTalkgroupsWithAllTags(ctx context.Context, tags []string) ([]Talkgroup, error) {
	rows, err := q.db.Query(ctx, getTalkgroupsWithAllTags, tags)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Talkgroup
	for rows.Next() {
		var i Talkgroup
		if err := rows.Scan(
			&i.ID,
			&i.SystemID,
			&i.Tgid,
			&i.Name,
			&i.AlphaTag,
			&i.TgGroup,
			&i.Frequency,
			&i.Metadata,
			&i.Tags,
			&i.Alert,
			&i.AlertConfig,
			&i.Weight,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getTalkgroupsWithAnyTags = `-- name: GetTalkgroupsWithAnyTags :many
SELECT id, system_id, tgid, name, alpha_tag, tg_group, frequency, metadata, tags, alert, alert_config, weight FROM talkgroups
WHERE tags @> ARRAY[$1]
`

func (q *Queries) GetTalkgroupsWithAnyTags(ctx context.Context, tags []string) ([]Talkgroup, error) {
	rows, err := q.db.Query(ctx, getTalkgroupsWithAnyTags, tags)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Talkgroup
	for rows.Next() {
		var i Talkgroup
		if err := rows.Scan(
			&i.ID,
			&i.SystemID,
			&i.Tgid,
			&i.Name,
			&i.AlphaTag,
			&i.TgGroup,
			&i.Frequency,
			&i.Metadata,
			&i.Tags,
			&i.Alert,
			&i.AlertConfig,
			&i.Weight,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const setTalkgroupTags = `-- name: SetTalkgroupTags :exec
UPDATE talkgroups SET tags = $3
WHERE id = systg2id($1, $2)
`

func (q *Queries) SetTalkgroupTags(ctx context.Context, sys int, tg int, tags []string) error {
	_, err := q.db.Exec(ctx, setTalkgroupTags, sys, tg, tags)
	return err
}