reloading-manager/backend/models/loads/loads.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.29.0
// source: loads.sql

package loads

import (
	"context"

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

const createCartridge = `-- name: CreateCartridge :one
insert into cartridges (name, meta)
values ($1, $2)
returning id
`

type CreateCartridgeParams struct {
	Name string `json:"name"`
	Meta []byte `json:"meta"`
}

func (q *Queries) CreateCartridge(ctx context.Context, arg CreateCartridgeParams) (pgtype.UUID, error) {
	row := q.db.QueryRow(ctx, createCartridge, arg.Name, arg.Meta)
	var id pgtype.UUID
	err := row.Scan(&id)
	return id, err
}

const createLoad = `-- name: CreateLoad :one
insert into loads (cartridge_id, col, powder_id, powder_gr, primer_id, bullet_id, photo, meta)
values ($1, $2, $3, $4, $5, $6, $7, $8)
returning id
`

type CreateLoadParams struct {
	CartridgeID pgtype.UUID `json:"cartridge_id"`
	Col         float32     `json:"col"`
	PowderID    pgtype.UUID `json:"powder_id"`
	PowderGr    float32     `json:"powder_gr"`
	PrimerID    pgtype.UUID `json:"primer_id"`
	BulletID    pgtype.UUID `json:"bullet_id"`
	Photo       []byte      `json:"photo"`
	Meta        []byte      `json:"meta"`
}

func (q *Queries) CreateLoad(ctx context.Context, arg CreateLoadParams) (pgtype.UUID, error) {
	row := q.db.QueryRow(ctx, createLoad,
		arg.CartridgeID,
		arg.Col,
		arg.PowderID,
		arg.PowderGr,
		arg.PrimerID,
		arg.BulletID,
		arg.Photo,
		arg.Meta,
	)
	var id pgtype.UUID
	err := row.Scan(&id)
	return id, err
}

const deleteCartridge = `-- name: DeleteCartridge :exec
delete
from cartridges
where id = $1
`

func (q *Queries) DeleteCartridge(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, deleteCartridge, id)
	return err
}

const deleteLoad = `-- name: DeleteLoad :exec
delete from loads
where id = $1
`

func (q *Queries) DeleteLoad(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, deleteLoad, id)
	return err
}

const getCartridgeById = `-- name: GetCartridgeById :one
select c.id as id, c.name, c.meta
from cartridges c
where id = $1
`

type GetCartridgeByIdRow struct {
	ID   pgtype.UUID `json:"id"`
	Name string      `json:"name"`
	Meta []byte      `json:"meta"`
}

func (q *Queries) GetCartridgeById(ctx context.Context, id pgtype.UUID) (GetCartridgeByIdRow, error) {
	row := q.db.QueryRow(ctx, getCartridgeById, id)
	var i GetCartridgeByIdRow
	err := row.Scan(&i.ID, &i.Name, &i.Meta)
	return i, err
}

const getCartridges = `-- name: GetCartridges :many
select c.id as id, c.name, c.meta
from cartridges c
order by c.name
`

type GetCartridgesRow struct {
	ID   pgtype.UUID `json:"id"`
	Name string      `json:"name"`
	Meta []byte      `json:"meta"`
}

func (q *Queries) GetCartridges(ctx context.Context) ([]GetCartridgesRow, error) {
	rows, err := q.db.Query(ctx, getCartridges)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetCartridgesRow
	for rows.Next() {
		var i GetCartridgesRow
		if err := rows.Scan(&i.ID, &i.Name, &i.Meta); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getLoadById = `-- name: GetLoadById :one
select l.id    as id,
       l.photo as photo,
       c.id    as cartridge_id,
       c.name  as cartridge_name,
       c.meta  as cartridge_meta,
       l.col,
       p.id    as powder_id,
       p.name  as powder_name,
       p.meta  as powder_meta,
       l.powder_gr,
       pr.id   as primer_id,
       pr.name as primer_name,
       pr.meta as primer_meta
from public.loads l
         join cartridges c on l.cartridge_id = c.id
         join bullets b on l.bullet_id = b.id
         join powders p on l.powder_id = p.id
         join primers pr on l.primer_id = pr.id
where l.id = $1
`

type GetLoadByIdRow struct {
	ID            pgtype.UUID `json:"id"`
	Photo         []byte      `json:"photo"`
	CartridgeID   pgtype.UUID `json:"cartridge_id"`
	CartridgeName string      `json:"cartridge_name"`
	CartridgeMeta []byte      `json:"cartridge_meta"`
	Col           float32     `json:"col"`
	PowderID      pgtype.UUID `json:"powder_id"`
	PowderName    string      `json:"powder_name"`
	PowderMeta    []byte      `json:"powder_meta"`
	PowderGr      float32     `json:"powder_gr"`
	PrimerID      pgtype.UUID `json:"primer_id"`
	PrimerName    string      `json:"primer_name"`
	PrimerMeta    []byte      `json:"primer_meta"`
}

func (q *Queries) GetLoadById(ctx context.Context, id pgtype.UUID) (GetLoadByIdRow, error) {
	row := q.db.QueryRow(ctx, getLoadById, id)
	var i GetLoadByIdRow
	err := row.Scan(
		&i.ID,
		&i.Photo,
		&i.CartridgeID,
		&i.CartridgeName,
		&i.CartridgeMeta,
		&i.Col,
		&i.PowderID,
		&i.PowderName,
		&i.PowderMeta,
		&i.PowderGr,
		&i.PrimerID,
		&i.PrimerName,
		&i.PrimerMeta,
	)
	return i, err
}

const getLoads = `-- name: GetLoads :many
select l.id       as id,
       l.col,
       l.powder_gr,
       c.id       as cartridge_id,
       c.name     as cartridge_name,
       c.meta     as cartridge_meta,
       p.id       as powder_id,
       p.name     as powder_name,
       p.meta     as powder_meta,
       p_m.name   as powder_manufacturer_name,
       p_m.url    as powder_manufacturer_url,
       pr.id      as primer_id,
       pr.name    as primer_name,
       pr.meta    as primer_meta,
       pr_m.name  as primer_manufacturer_name,
       pr_m.url   as primer_manufacturer_url,
       b.id       as bullet_id,
       b.name     as bullet_name,
       b.meta     as bullet_meta,
       b.weight   as bullet_weight,
       b.diameter as bullet_diameter,
       b_m.name   as bullet_manufacturer_name,
       b_m.url    as bullet_manufacturer_url
from public.loads l
         join cartridges c on l.cartridge_id = c.id
         join bullets b on l.bullet_id = b.id
         join manufacturers b_m on b.manufacturer_id = b_m.id
         join powders p on l.powder_id = p.id
         join manufacturers p_m on p.manufacturer_id = p_m.id
         join primers pr on l.primer_id = pr.id
         join manufacturers pr_m on pr.manufacturer_id = pr_m.id
where 1 = 1

  -- Loose Search By Name
  AND (CASE WHEN $3::bool THEN lower(c.name) like lower($4) ELSE TRUE END)
  AND (CASE WHEN $5::bool THEN lower(b.name) like lower($6) ELSE TRUE END)
  AND (CASE WHEN $7::bool THEN lower(b_m.name) like lower($8) ELSE TRUE END)
  AND (CASE WHEN $9::bool THEN lower(pr.name) like lower($10) ELSE TRUE END)
  AND (CASE WHEN $11::bool THEN lower(pr_m.name) like lower($12) ELSE TRUE END)
  AND (CASE WHEN $13::bool THEN lower(p.name) like lower($14) ELSE TRUE END)
  AND (CASE WHEN $15::bool THEN lower(p_m.name) like lower($16) ELSE TRUE END)

  -- Exact Search By ID
  AND (CASE WHEN $17::bool THEN c.id = $18::uuid ELSE TRUE END)
  AND (CASE WHEN $19::bool THEN b.id = $20::uuid ELSE TRUE END)
  AND (CASE WHEN $21::bool THEN pr.id = $22::uuid ELSE TRUE END)
  AND (CASE WHEN $23::bool THEN p.id = $24::uuid ELSE TRUE END)

order by (case
             when $25 = 'cartridge_name' then c.name
             when $25 = 'bullet_name' then b.name
             when $25 = 'bullet_manufacturer_name' then b_m.name
             when $25 = 'primer_manufacturer_name' then pr_m.name
             when $25 = 'powder_manufacturer_name' then p_m.name
             when $25::text = 'powder_gr' then l.powder_gr
             end)

limit $1 offset $2
`

type GetLoadsParams struct {
	Limit                    int32       `json:"limit"`
	Offset                   int32       `json:"offset"`
	SearchCartridge          bool        `json:"search_cartridge"`
	Cartridge                string      `json:"cartridge"`
	SearchBullet             bool        `json:"search_bullet"`
	Bullet                   string      `json:"bullet"`
	SearchBulletManufacturer bool        `json:"search_bullet_manufacturer"`
	BulletManufacturer       string      `json:"bullet_manufacturer"`
	SearchPrimer             bool        `json:"search_primer"`
	Primer                   string      `json:"primer"`
	SearchPrimerManufacturer bool        `json:"search_primer_manufacturer"`
	PrimeManufacturer        string      `json:"prime_manufacturer"`
	SearchPowder             bool        `json:"search_powder"`
	Powder                   string      `json:"powder"`
	SearchPowderManufacturer bool        `json:"search_powder_manufacturer"`
	PowderManufacturer       string      `json:"powder_manufacturer"`
	SearchCartridgeID        bool        `json:"search_cartridge_id"`
	CartridgeID              pgtype.UUID `json:"cartridge_id"`
	SearchBulletID           bool        `json:"search_bullet_id"`
	BulletID                 pgtype.UUID `json:"bullet_id"`
	SearchPrimerID           bool        `json:"search_primer_id"`
	PrimerID                 pgtype.UUID `json:"primer_id"`
	SearchPowderID           bool        `json:"search_powder_id"`
	PowderID                 pgtype.UUID `json:"powder_id"`
	OrderBy                  interface{} `json:"order_by"`
}

type GetLoadsRow struct {
	ID                     pgtype.UUID `json:"id"`
	Col                    float32     `json:"col"`
	PowderGr               float32     `json:"powder_gr"`
	CartridgeID            pgtype.UUID `json:"cartridge_id"`
	CartridgeName          string      `json:"cartridge_name"`
	CartridgeMeta          []byte      `json:"cartridge_meta"`
	PowderID               pgtype.UUID `json:"powder_id"`
	PowderName             string      `json:"powder_name"`
	PowderMeta             []byte      `json:"powder_meta"`
	PowderManufacturerName string      `json:"powder_manufacturer_name"`
	PowderManufacturerUrl  pgtype.Text `json:"powder_manufacturer_url"`
	PrimerID               pgtype.UUID `json:"primer_id"`
	PrimerName             string      `json:"primer_name"`
	PrimerMeta             []byte      `json:"primer_meta"`
	PrimerManufacturerName string      `json:"primer_manufacturer_name"`
	PrimerManufacturerUrl  pgtype.Text `json:"primer_manufacturer_url"`
	BulletID               pgtype.UUID `json:"bullet_id"`
	BulletName             string      `json:"bullet_name"`
	BulletMeta             []byte      `json:"bullet_meta"`
	BulletWeight           int32       `json:"bullet_weight"`
	BulletDiameter         int32       `json:"bullet_diameter"`
	BulletManufacturerName string      `json:"bullet_manufacturer_name"`
	BulletManufacturerUrl  pgtype.Text `json:"bullet_manufacturer_url"`
}

func (q *Queries) GetLoads(ctx context.Context, arg GetLoadsParams) ([]GetLoadsRow, error) {
	rows, err := q.db.Query(ctx, getLoads,
		arg.Limit,
		arg.Offset,
		arg.SearchCartridge,
		arg.Cartridge,
		arg.SearchBullet,
		arg.Bullet,
		arg.SearchBulletManufacturer,
		arg.BulletManufacturer,
		arg.SearchPrimer,
		arg.Primer,
		arg.SearchPrimerManufacturer,
		arg.PrimeManufacturer,
		arg.SearchPowder,
		arg.Powder,
		arg.SearchPowderManufacturer,
		arg.PowderManufacturer,
		arg.SearchCartridgeID,
		arg.CartridgeID,
		arg.SearchBulletID,
		arg.BulletID,
		arg.SearchPrimerID,
		arg.PrimerID,
		arg.SearchPowderID,
		arg.PowderID,
		arg.OrderBy,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetLoadsRow
	for rows.Next() {
		var i GetLoadsRow
		if err := rows.Scan(
			&i.ID,
			&i.Col,
			&i.PowderGr,
			&i.CartridgeID,
			&i.CartridgeName,
			&i.CartridgeMeta,
			&i.PowderID,
			&i.PowderName,
			&i.PowderMeta,
			&i.PowderManufacturerName,
			&i.PowderManufacturerUrl,
			&i.PrimerID,
			&i.PrimerName,
			&i.PrimerMeta,
			&i.PrimerManufacturerName,
			&i.PrimerManufacturerUrl,
			&i.BulletID,
			&i.BulletName,
			&i.BulletMeta,
			&i.BulletWeight,
			&i.BulletDiameter,
			&i.BulletManufacturerName,
			&i.BulletManufacturerUrl,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const totalLoads = `-- name: TotalLoads :one
select count(*)
from loads
`

func (q *Queries) TotalLoads(ctx context.Context) (int64, error) {
	row := q.db.QueryRow(ctx, totalLoads)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const updateLoad = `-- name: UpdateLoad :exec
update loads set
    cartridge_id = $1,
    col = $2,
    powder_id = $3,
    powder_gr = $4,
    primer_id = $5,
    bullet_id = $6,
    photo = $7,
    meta = $8
where id = $9
`

type UpdateLoadParams struct {
	CartridgeID pgtype.UUID `json:"cartridge_id"`
	Col         float32     `json:"col"`
	PowderID    pgtype.UUID `json:"powder_id"`
	PowderGr    float32     `json:"powder_gr"`
	PrimerID    pgtype.UUID `json:"primer_id"`
	BulletID    pgtype.UUID `json:"bullet_id"`
	Photo       []byte      `json:"photo"`
	Meta        []byte      `json:"meta"`
	ID          pgtype.UUID `json:"id"`
}

func (q *Queries) UpdateLoad(ctx context.Context, arg UpdateLoadParams) error {
	_, err := q.db.Exec(ctx, updateLoad,
		arg.CartridgeID,
		arg.Col,
		arg.PowderID,
		arg.PowderGr,
		arg.PrimerID,
		arg.BulletID,
		arg.Photo,
		arg.Meta,
		arg.ID,
	)
	return err
}