474 lines
13 KiB
Go
474 lines
13 KiB
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 talkgroups.id, talkgroups.system_id, talkgroups.tgid, talkgroups.name, talkgroups.alpha_tag, talkgroups.tg_group, talkgroups.frequency, talkgroups.metadata, talkgroups.tags, talkgroups.alert, talkgroups.alert_config, talkgroups.weight FROM talkgroups
|
|
WHERE id = systg2id($1, $2)
|
|
`
|
|
|
|
type GetTalkgroupRow struct {
|
|
Talkgroup Talkgroup `json:"talkgroup"`
|
|
}
|
|
|
|
func (q *Queries) GetTalkgroup(ctx context.Context, systemID int, tgid int) (GetTalkgroupRow, error) {
|
|
row := q.db.QueryRow(ctx, getTalkgroup, systemID, tgid)
|
|
var i GetTalkgroupRow
|
|
err := row.Scan(
|
|
&i.Talkgroup.ID,
|
|
&i.Talkgroup.SystemID,
|
|
&i.Talkgroup.Tgid,
|
|
&i.Talkgroup.Name,
|
|
&i.Talkgroup.AlphaTag,
|
|
&i.Talkgroup.TgGroup,
|
|
&i.Talkgroup.Frequency,
|
|
&i.Talkgroup.Metadata,
|
|
&i.Talkgroup.Tags,
|
|
&i.Talkgroup.Alert,
|
|
&i.Talkgroup.AlertConfig,
|
|
&i.Talkgroup.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, tg.tgid, tg.name, tg.alpha_tag, tg.tg_group, tg.frequency, tg.metadata, tg.tags, tg.alert, tg.alert_config, tg.weight, sys.id, sys.name,
|
|
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, tgl.tgid::INT4, tgl.name,
|
|
tgl.alpha_tag, tgl.alpha_tag, NULL::INTEGER, NULL::JSONB,
|
|
CASE WHEN tgl.alpha_tag IS NULL THEN NULL ELSE ARRAY[tgl.alpha_tag] END,
|
|
TRUE, NULL::JSONB, 1.0, sys.id, sys.name,
|
|
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 {
|
|
Talkgroup Talkgroup `json:"talkgroup"`
|
|
System System `json:"system"`
|
|
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.Talkgroup.ID,
|
|
&i.Talkgroup.SystemID,
|
|
&i.Talkgroup.Tgid,
|
|
&i.Talkgroup.Name,
|
|
&i.Talkgroup.AlphaTag,
|
|
&i.Talkgroup.TgGroup,
|
|
&i.Talkgroup.Frequency,
|
|
&i.Talkgroup.Metadata,
|
|
&i.Talkgroup.Tags,
|
|
&i.Talkgroup.Alert,
|
|
&i.Talkgroup.AlertConfig,
|
|
&i.Talkgroup.Weight,
|
|
&i.System.ID,
|
|
&i.System.Name,
|
|
&i.Learned,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getTalkgroupsByPackedIDs = `-- name: GetTalkgroupsByPackedIDs :many
|
|
SELECT tg.id, tg.system_id, tg.tgid, tg.name, tg.alpha_tag, tg.tg_group, tg.frequency, tg.metadata, tg.tags, tg.alert, tg.alert_config, tg.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 {
|
|
Talkgroup Talkgroup `json:"talkgroup"`
|
|
System System `json:"system"`
|
|
}
|
|
|
|
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.Talkgroup.ID,
|
|
&i.Talkgroup.SystemID,
|
|
&i.Talkgroup.Tgid,
|
|
&i.Talkgroup.Name,
|
|
&i.Talkgroup.AlphaTag,
|
|
&i.Talkgroup.TgGroup,
|
|
&i.Talkgroup.Frequency,
|
|
&i.Talkgroup.Metadata,
|
|
&i.Talkgroup.Tags,
|
|
&i.Talkgroup.Alert,
|
|
&i.Talkgroup.AlertConfig,
|
|
&i.Talkgroup.Weight,
|
|
&i.System.ID,
|
|
&i.System.Name,
|
|
); 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 talkgroups.id, talkgroups.system_id, talkgroups.tgid, talkgroups.name, talkgroups.alpha_tag, talkgroups.tg_group, talkgroups.frequency, talkgroups.metadata, talkgroups.tags, talkgroups.alert, talkgroups.alert_config, talkgroups.weight FROM talkgroups
|
|
WHERE tags && ARRAY[$1]
|
|
`
|
|
|
|
type GetTalkgroupsWithAllTagsRow struct {
|
|
Talkgroup Talkgroup `json:"talkgroup"`
|
|
}
|
|
|
|
func (q *Queries) GetTalkgroupsWithAllTags(ctx context.Context, tags []string) ([]GetTalkgroupsWithAllTagsRow, error) {
|
|
rows, err := q.db.Query(ctx, getTalkgroupsWithAllTags, tags)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetTalkgroupsWithAllTagsRow
|
|
for rows.Next() {
|
|
var i GetTalkgroupsWithAllTagsRow
|
|
if err := rows.Scan(
|
|
&i.Talkgroup.ID,
|
|
&i.Talkgroup.SystemID,
|
|
&i.Talkgroup.Tgid,
|
|
&i.Talkgroup.Name,
|
|
&i.Talkgroup.AlphaTag,
|
|
&i.Talkgroup.TgGroup,
|
|
&i.Talkgroup.Frequency,
|
|
&i.Talkgroup.Metadata,
|
|
&i.Talkgroup.Tags,
|
|
&i.Talkgroup.Alert,
|
|
&i.Talkgroup.AlertConfig,
|
|
&i.Talkgroup.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 talkgroups.id, talkgroups.system_id, talkgroups.tgid, talkgroups.name, talkgroups.alpha_tag, talkgroups.tg_group, talkgroups.frequency, talkgroups.metadata, talkgroups.tags, talkgroups.alert, talkgroups.alert_config, talkgroups.weight FROM talkgroups
|
|
WHERE tags @> ARRAY[$1]
|
|
`
|
|
|
|
type GetTalkgroupsWithAnyTagsRow struct {
|
|
Talkgroup Talkgroup `json:"talkgroup"`
|
|
}
|
|
|
|
func (q *Queries) GetTalkgroupsWithAnyTags(ctx context.Context, tags []string) ([]GetTalkgroupsWithAnyTagsRow, error) {
|
|
rows, err := q.db.Query(ctx, getTalkgroupsWithAnyTags, tags)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetTalkgroupsWithAnyTagsRow
|
|
for rows.Next() {
|
|
var i GetTalkgroupsWithAnyTagsRow
|
|
if err := rows.Scan(
|
|
&i.Talkgroup.ID,
|
|
&i.Talkgroup.SystemID,
|
|
&i.Talkgroup.Tgid,
|
|
&i.Talkgroup.Name,
|
|
&i.Talkgroup.AlphaTag,
|
|
&i.Talkgroup.TgGroup,
|
|
&i.Talkgroup.Frequency,
|
|
&i.Talkgroup.Metadata,
|
|
&i.Talkgroup.Tags,
|
|
&i.Talkgroup.Alert,
|
|
&i.Talkgroup.AlertConfig,
|
|
&i.Talkgroup.Weight,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getTalkgroupsWithLearned = `-- name: GetTalkgroupsWithLearned :many
|
|
SELECT
|
|
tg.id, tg.system_id, tg.tgid, tg.name, tg.alpha_tag, tg.tg_group, tg.frequency, tg.metadata, tg.tags, tg.alert, tg.alert_config, tg.weight, sys.id, sys.name,
|
|
FALSE learned
|
|
FROM talkgroups tg
|
|
JOIN systems sys ON tg.system_id = sys.id
|
|
UNION
|
|
SELECT
|
|
tgl.id::INT8, tgl.system_id::INT4, tgl.tgid::INT4, tgl.name,
|
|
tgl.alpha_tag, tgl.alpha_tag, NULL::INTEGER, NULL::JSONB,
|
|
CASE WHEN tgl.alpha_tag IS NULL THEN NULL ELSE ARRAY[tgl.alpha_tag] END,
|
|
TRUE, NULL::JSONB, 1.0, sys.id, sys.name,
|
|
TRUE learned
|
|
FROM talkgroups_learned tgl
|
|
JOIN systems sys ON tgl.system_id = sys.id
|
|
WHERE ignored IS NOT TRUE
|
|
`
|
|
|
|
type GetTalkgroupsWithLearnedRow struct {
|
|
Talkgroup Talkgroup `json:"talkgroup"`
|
|
System System `json:"system"`
|
|
Learned bool `json:"learned"`
|
|
}
|
|
|
|
func (q *Queries) GetTalkgroupsWithLearned(ctx context.Context) ([]GetTalkgroupsWithLearnedRow, error) {
|
|
rows, err := q.db.Query(ctx, getTalkgroupsWithLearned)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetTalkgroupsWithLearnedRow
|
|
for rows.Next() {
|
|
var i GetTalkgroupsWithLearnedRow
|
|
if err := rows.Scan(
|
|
&i.Talkgroup.ID,
|
|
&i.Talkgroup.SystemID,
|
|
&i.Talkgroup.Tgid,
|
|
&i.Talkgroup.Name,
|
|
&i.Talkgroup.AlphaTag,
|
|
&i.Talkgroup.TgGroup,
|
|
&i.Talkgroup.Frequency,
|
|
&i.Talkgroup.Metadata,
|
|
&i.Talkgroup.Tags,
|
|
&i.Talkgroup.Alert,
|
|
&i.Talkgroup.AlertConfig,
|
|
&i.Talkgroup.Weight,
|
|
&i.System.ID,
|
|
&i.System.Name,
|
|
&i.Learned,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getTalkgroupsWithLearnedByPackedIDs = `-- name: GetTalkgroupsWithLearnedByPackedIDs :many
|
|
SELECT
|
|
tg.id, tg.system_id, tg.tgid, tg.name, tg.alpha_tag, tg.tg_group, tg.frequency, tg.metadata, tg.tags, tg.alert, tg.alert_config, tg.weight, sys.id, sys.name,
|
|
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, tgl.tgid::INT4, tgl.name,
|
|
tgl.alpha_tag, tgl.alpha_tag, NULL::INTEGER, NULL::JSONB,
|
|
CASE WHEN tgl.alpha_tag IS NULL THEN NULL ELSE ARRAY[tgl.alpha_tag] END,
|
|
TRUE, NULL::JSONB, 1.0, sys.id, sys.name,
|
|
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 GetTalkgroupsWithLearnedByPackedIDsRow struct {
|
|
Talkgroup Talkgroup `json:"talkgroup"`
|
|
System System `json:"system"`
|
|
Learned bool `json:"learned"`
|
|
}
|
|
|
|
func (q *Queries) GetTalkgroupsWithLearnedByPackedIDs(ctx context.Context, dollar_1 []int64) ([]GetTalkgroupsWithLearnedByPackedIDsRow, error) {
|
|
rows, err := q.db.Query(ctx, getTalkgroupsWithLearnedByPackedIDs, dollar_1)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetTalkgroupsWithLearnedByPackedIDsRow
|
|
for rows.Next() {
|
|
var i GetTalkgroupsWithLearnedByPackedIDsRow
|
|
if err := rows.Scan(
|
|
&i.Talkgroup.ID,
|
|
&i.Talkgroup.SystemID,
|
|
&i.Talkgroup.Tgid,
|
|
&i.Talkgroup.Name,
|
|
&i.Talkgroup.AlphaTag,
|
|
&i.Talkgroup.TgGroup,
|
|
&i.Talkgroup.Frequency,
|
|
&i.Talkgroup.Metadata,
|
|
&i.Talkgroup.Tags,
|
|
&i.Talkgroup.Alert,
|
|
&i.Talkgroup.AlertConfig,
|
|
&i.Talkgroup.Weight,
|
|
&i.System.ID,
|
|
&i.System.Name,
|
|
&i.Learned,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getTalkgroupsWithLearnedBySystem = `-- name: GetTalkgroupsWithLearnedBySystem :many
|
|
SELECT
|
|
tg.id, tg.system_id, tg.tgid, tg.name, tg.alpha_tag, tg.tg_group, tg.frequency, tg.metadata, tg.tags, tg.alert, tg.alert_config, tg.weight, sys.id, sys.name,
|
|
FALSE learned
|
|
FROM talkgroups tg
|
|
JOIN systems sys ON tg.system_id = sys.id
|
|
WHERE tg.system_id = $1
|
|
UNION
|
|
SELECT
|
|
tgl.id::INT8, tgl.system_id::INT4, tgl.tgid::INT4, tgl.name,
|
|
tgl.alpha_tag, tgl.alpha_tag, NULL::INTEGER, NULL::JSONB,
|
|
CASE WHEN tgl.alpha_tag IS NULL THEN NULL ELSE ARRAY[tgl.alpha_tag] END,
|
|
TRUE, NULL::JSONB, 1.0, sys.id, sys.name,
|
|
TRUE learned
|
|
FROM talkgroups_learned tgl
|
|
JOIN systems sys ON tgl.system_id = sys.id
|
|
WHERE tgl.system_id = $1 AND ignored IS NOT TRUE
|
|
`
|
|
|
|
type GetTalkgroupsWithLearnedBySystemRow struct {
|
|
Talkgroup Talkgroup `json:"talkgroup"`
|
|
System System `json:"system"`
|
|
Learned bool `json:"learned"`
|
|
}
|
|
|
|
func (q *Queries) GetTalkgroupsWithLearnedBySystem(ctx context.Context, system int32) ([]GetTalkgroupsWithLearnedBySystemRow, error) {
|
|
rows, err := q.db.Query(ctx, getTalkgroupsWithLearnedBySystem, system)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetTalkgroupsWithLearnedBySystemRow
|
|
for rows.Next() {
|
|
var i GetTalkgroupsWithLearnedBySystemRow
|
|
if err := rows.Scan(
|
|
&i.Talkgroup.ID,
|
|
&i.Talkgroup.SystemID,
|
|
&i.Talkgroup.Tgid,
|
|
&i.Talkgroup.Name,
|
|
&i.Talkgroup.AlphaTag,
|
|
&i.Talkgroup.TgGroup,
|
|
&i.Talkgroup.Frequency,
|
|
&i.Talkgroup.Metadata,
|
|
&i.Talkgroup.Tags,
|
|
&i.Talkgroup.Alert,
|
|
&i.Talkgroup.AlertConfig,
|
|
&i.Talkgroup.Weight,
|
|
&i.System.ID,
|
|
&i.System.Name,
|
|
&i.Learned,
|
|
); 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
|
|
}
|