372 lines
8.4 KiB
Go
372 lines
8.4 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.31.1
|
|
// source: resources.sql
|
|
|
|
package postgresdb
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
)
|
|
|
|
const insertResource = `-- name: InsertResource :one
|
|
INSERT INTO resources (org_id, kind, value, version, updated_at)
|
|
VALUES ($1, $2, $3, 1, $4)
|
|
RETURNING kind, value, version, updated_at, org_id
|
|
`
|
|
|
|
type InsertResourceParams struct {
|
|
OrgID string
|
|
Kind string
|
|
Value []byte
|
|
UpdatedAt time.Time
|
|
}
|
|
|
|
func (q *Queries) InsertResource(ctx context.Context, arg InsertResourceParams) (Resource, error) {
|
|
row := q.db.QueryRow(ctx, insertResource,
|
|
arg.OrgID,
|
|
arg.Kind,
|
|
arg.Value,
|
|
arg.UpdatedAt,
|
|
)
|
|
var i Resource
|
|
err := row.Scan(
|
|
&i.Kind,
|
|
&i.Value,
|
|
&i.Version,
|
|
&i.UpdatedAt,
|
|
&i.OrgID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const insertResourceHistory = `-- name: InsertResourceHistory :one
|
|
INSERT INTO resource_history (
|
|
org_id, kind, value, version, actor, source, request_id, expected_version,
|
|
current_version, at
|
|
)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
|
|
RETURNING org_id, kind, value, version, actor, source, request_id, expected_version,
|
|
current_version, at
|
|
`
|
|
|
|
type InsertResourceHistoryParams struct {
|
|
OrgID string
|
|
Kind string
|
|
Value []byte
|
|
Version int64
|
|
Actor string
|
|
Source string
|
|
RequestID string
|
|
ExpectedVersion int64
|
|
CurrentVersion int64
|
|
At time.Time
|
|
}
|
|
|
|
type InsertResourceHistoryRow struct {
|
|
OrgID string
|
|
Kind string
|
|
Value []byte
|
|
Version int64
|
|
Actor string
|
|
Source string
|
|
RequestID string
|
|
ExpectedVersion int64
|
|
CurrentVersion int64
|
|
At time.Time
|
|
}
|
|
|
|
func (q *Queries) InsertResourceHistory(ctx context.Context, arg InsertResourceHistoryParams) (InsertResourceHistoryRow, error) {
|
|
row := q.db.QueryRow(ctx, insertResourceHistory,
|
|
arg.OrgID,
|
|
arg.Kind,
|
|
arg.Value,
|
|
arg.Version,
|
|
arg.Actor,
|
|
arg.Source,
|
|
arg.RequestID,
|
|
arg.ExpectedVersion,
|
|
arg.CurrentVersion,
|
|
arg.At,
|
|
)
|
|
var i InsertResourceHistoryRow
|
|
err := row.Scan(
|
|
&i.OrgID,
|
|
&i.Kind,
|
|
&i.Value,
|
|
&i.Version,
|
|
&i.Actor,
|
|
&i.Source,
|
|
&i.RequestID,
|
|
&i.ExpectedVersion,
|
|
&i.CurrentVersion,
|
|
&i.At,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const listResources = `-- name: ListResources :many
|
|
SELECT kind, value, version, updated_at, org_id FROM resources
|
|
ORDER BY org_id, kind
|
|
`
|
|
|
|
func (q *Queries) ListResources(ctx context.Context) ([]Resource, error) {
|
|
rows, err := q.db.Query(ctx, listResources)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Resource
|
|
for rows.Next() {
|
|
var i Resource
|
|
if err := rows.Scan(
|
|
&i.Kind,
|
|
&i.Value,
|
|
&i.Version,
|
|
&i.UpdatedAt,
|
|
&i.OrgID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const lockResourceWrite = `-- name: LockResourceWrite :exec
|
|
SELECT pg_advisory_xact_lock(hashtextextended($1::text || '/' || $2::text, 0))
|
|
`
|
|
|
|
type LockResourceWriteParams struct {
|
|
OrgID string
|
|
Kind string
|
|
}
|
|
|
|
// This lock is acquired in its own statement before a resource read. PostgreSQL
|
|
// takes a fresh Read Committed snapshot for the subsequent read, so concurrent
|
|
// optimistic writers see the committed revision rather than both writing v1.
|
|
// The lock is per (org, kind): two orgs writing the same kind do not contend.
|
|
func (q *Queries) LockResourceWrite(ctx context.Context, arg LockResourceWriteParams) error {
|
|
_, err := q.db.Exec(ctx, lockResourceWrite, arg.OrgID, arg.Kind)
|
|
return err
|
|
}
|
|
|
|
const reinsertResource = `-- name: ReinsertResource :one
|
|
INSERT INTO resources (org_id, kind, value, version, updated_at)
|
|
VALUES ($1, $2, $3, $4, $5)
|
|
RETURNING kind, value, version, updated_at, org_id
|
|
`
|
|
|
|
type ReinsertResourceParams struct {
|
|
OrgID string
|
|
Kind string
|
|
Value []byte
|
|
Version int64
|
|
UpdatedAt time.Time
|
|
}
|
|
|
|
// Re-creates the current row for a revision resource_history already records.
|
|
// The ledger outlives the row it describes, so a resource an operator removed
|
|
// still has its revisions; putting one back needs the row re-created without a
|
|
// second ledger entry, which idx_resource_history_org_kind_request would refuse.
|
|
// The revision is the ledger's, not a fresh one: this is the row that write
|
|
// produced, restored.
|
|
func (q *Queries) ReinsertResource(ctx context.Context, arg ReinsertResourceParams) (Resource, error) {
|
|
row := q.db.QueryRow(ctx, reinsertResource,
|
|
arg.OrgID,
|
|
arg.Kind,
|
|
arg.Value,
|
|
arg.Version,
|
|
arg.UpdatedAt,
|
|
)
|
|
var i Resource
|
|
err := row.Scan(
|
|
&i.Kind,
|
|
&i.Value,
|
|
&i.Version,
|
|
&i.UpdatedAt,
|
|
&i.OrgID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const resourceByKind = `-- name: ResourceByKind :one
|
|
SELECT kind, value, version, updated_at, org_id FROM resources
|
|
WHERE org_id = $1 AND kind = $2
|
|
`
|
|
|
|
type ResourceByKindParams struct {
|
|
OrgID string
|
|
Kind string
|
|
}
|
|
|
|
func (q *Queries) ResourceByKind(ctx context.Context, arg ResourceByKindParams) (Resource, error) {
|
|
row := q.db.QueryRow(ctx, resourceByKind, arg.OrgID, arg.Kind)
|
|
var i Resource
|
|
err := row.Scan(
|
|
&i.Kind,
|
|
&i.Value,
|
|
&i.Version,
|
|
&i.UpdatedAt,
|
|
&i.OrgID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const resourceByRequest = `-- name: ResourceByRequest :one
|
|
SELECT org_id, kind, value, version, actor, source, request_id, expected_version,
|
|
current_version, at
|
|
FROM resource_history
|
|
WHERE org_id = $1 AND kind = $2 AND request_id = $3
|
|
`
|
|
|
|
type ResourceByRequestParams struct {
|
|
OrgID string
|
|
Kind string
|
|
RequestID string
|
|
}
|
|
|
|
type ResourceByRequestRow struct {
|
|
OrgID string
|
|
Kind string
|
|
Value []byte
|
|
Version int64
|
|
Actor string
|
|
Source string
|
|
RequestID string
|
|
ExpectedVersion int64
|
|
CurrentVersion int64
|
|
At time.Time
|
|
}
|
|
|
|
func (q *Queries) ResourceByRequest(ctx context.Context, arg ResourceByRequestParams) (ResourceByRequestRow, error) {
|
|
row := q.db.QueryRow(ctx, resourceByRequest, arg.OrgID, arg.Kind, arg.RequestID)
|
|
var i ResourceByRequestRow
|
|
err := row.Scan(
|
|
&i.OrgID,
|
|
&i.Kind,
|
|
&i.Value,
|
|
&i.Version,
|
|
&i.Actor,
|
|
&i.Source,
|
|
&i.RequestID,
|
|
&i.ExpectedVersion,
|
|
&i.CurrentVersion,
|
|
&i.At,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const resourceHistory = `-- name: ResourceHistory :many
|
|
SELECT org_id, kind, value, version, actor, source, request_id, expected_version,
|
|
current_version, at
|
|
FROM resource_history
|
|
WHERE org_id = $1 AND kind = $2
|
|
ORDER BY version DESC
|
|
LIMIT NULLIF($3::bigint, 0)
|
|
`
|
|
|
|
type ResourceHistoryParams struct {
|
|
OrgID string
|
|
Kind string
|
|
EntryLimit int64
|
|
}
|
|
|
|
type ResourceHistoryRow struct {
|
|
OrgID string
|
|
Kind string
|
|
Value []byte
|
|
Version int64
|
|
Actor string
|
|
Source string
|
|
RequestID string
|
|
ExpectedVersion int64
|
|
CurrentVersion int64
|
|
At time.Time
|
|
}
|
|
|
|
func (q *Queries) ResourceHistory(ctx context.Context, arg ResourceHistoryParams) ([]ResourceHistoryRow, error) {
|
|
rows, err := q.db.Query(ctx, resourceHistory, arg.OrgID, arg.Kind, arg.EntryLimit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []ResourceHistoryRow
|
|
for rows.Next() {
|
|
var i ResourceHistoryRow
|
|
if err := rows.Scan(
|
|
&i.OrgID,
|
|
&i.Kind,
|
|
&i.Value,
|
|
&i.Version,
|
|
&i.Actor,
|
|
&i.Source,
|
|
&i.RequestID,
|
|
&i.ExpectedVersion,
|
|
&i.CurrentVersion,
|
|
&i.At,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const resourceVersion = `-- name: ResourceVersion :one
|
|
SELECT version FROM resources WHERE org_id = $1 AND kind = $2
|
|
`
|
|
|
|
type ResourceVersionParams struct {
|
|
OrgID string
|
|
Kind string
|
|
}
|
|
|
|
func (q *Queries) ResourceVersion(ctx context.Context, arg ResourceVersionParams) (int64, error) {
|
|
row := q.db.QueryRow(ctx, resourceVersion, arg.OrgID, arg.Kind)
|
|
var version int64
|
|
err := row.Scan(&version)
|
|
return version, err
|
|
}
|
|
|
|
const updateResource = `-- name: UpdateResource :one
|
|
UPDATE resources
|
|
SET value = $3, version = version + 1, updated_at = $4
|
|
WHERE org_id = $1 AND kind = $2 AND version = $5
|
|
RETURNING kind, value, version, updated_at, org_id
|
|
`
|
|
|
|
type UpdateResourceParams struct {
|
|
OrgID string
|
|
Kind string
|
|
Value []byte
|
|
UpdatedAt time.Time
|
|
Version int64
|
|
}
|
|
|
|
func (q *Queries) UpdateResource(ctx context.Context, arg UpdateResourceParams) (Resource, error) {
|
|
row := q.db.QueryRow(ctx, updateResource,
|
|
arg.OrgID,
|
|
arg.Kind,
|
|
arg.Value,
|
|
arg.UpdatedAt,
|
|
arg.Version,
|
|
)
|
|
var i Resource
|
|
err := row.Scan(
|
|
&i.Kind,
|
|
&i.Value,
|
|
&i.Version,
|
|
&i.UpdatedAt,
|
|
&i.OrgID,
|
|
)
|
|
return i, err
|
|
}
|