budgeteer/postgres/categories.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.13.0
// source: categories.sql

package postgres

import (
	"context"

	"github.com/google/uuid"
)

const createCategory = `-- name: CreateCategory :one
INSERT INTO categories
(name, category_group_id)
VALUES ($1, $2)
RETURNING id, category_group_id, name
`

type CreateCategoryParams struct {
	Name            string
	CategoryGroupID uuid.UUID
}

func (q *Queries) CreateCategory(ctx context.Context, arg CreateCategoryParams) (Category, error) {
	row := q.db.QueryRowContext(ctx, createCategory, arg.Name, arg.CategoryGroupID)
	var i Category
	err := row.Scan(&i.ID, &i.CategoryGroupID, &i.Name)
	return i, err
}

const createCategoryGroup = `-- name: CreateCategoryGroup :one
INSERT INTO category_groups
(name, budget_id)
VALUES ($1, $2)
RETURNING id, budget_id, name
`

type CreateCategoryGroupParams struct {
	Name     string
	BudgetID uuid.UUID
}

func (q *Queries) CreateCategoryGroup(ctx context.Context, arg CreateCategoryGroupParams) (CategoryGroup, error) {
	row := q.db.QueryRowContext(ctx, createCategoryGroup, arg.Name, arg.BudgetID)
	var i CategoryGroup
	err := row.Scan(&i.ID, &i.BudgetID, &i.Name)
	return i, err
}

const getCategories = `-- name: GetCategories :many
SELECT categories.id, categories.category_group_id, categories.name, category_groups.name as group FROM categories
INNER JOIN category_groups ON categories.category_group_id = category_groups.id
WHERE category_groups.budget_id = $1
ORDER BY category_groups.name, categories.name
`

type GetCategoriesRow struct {
	ID              uuid.UUID
	CategoryGroupID uuid.UUID
	Name            string
	Group           string
}

func (q *Queries) GetCategories(ctx context.Context, budgetID uuid.UUID) ([]GetCategoriesRow, error) {
	rows, err := q.db.QueryContext(ctx, getCategories, budgetID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetCategoriesRow
	for rows.Next() {
		var i GetCategoriesRow
		if err := rows.Scan(
			&i.ID,
			&i.CategoryGroupID,
			&i.Name,
			&i.Group,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getCategoryGroupByName = `-- name: GetCategoryGroupByName :one
SELECT category_groups.id, category_groups.budget_id, category_groups.name FROM category_groups 
WHERE category_groups.budget_id = $1
AND category_groups.name = $2
`

type GetCategoryGroupByNameParams struct {
	BudgetID uuid.UUID
	Name     string
}

func (q *Queries) GetCategoryGroupByName(ctx context.Context, arg GetCategoryGroupByNameParams) (CategoryGroup, error) {
	row := q.db.QueryRowContext(ctx, getCategoryGroupByName, arg.BudgetID, arg.Name)
	var i CategoryGroup
	err := row.Scan(&i.ID, &i.BudgetID, &i.Name)
	return i, err
}

const getCategoryGroups = `-- name: GetCategoryGroups :many
SELECT category_groups.id, category_groups.budget_id, category_groups.name FROM category_groups 
WHERE category_groups.budget_id = $1
`

func (q *Queries) GetCategoryGroups(ctx context.Context, budgetID uuid.UUID) ([]CategoryGroup, error) {
	rows, err := q.db.QueryContext(ctx, getCategoryGroups, budgetID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []CategoryGroup
	for rows.Next() {
		var i CategoryGroup
		if err := rows.Scan(&i.ID, &i.BudgetID, &i.Name); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const searchCategories = `-- name: SearchCategories :many
SELECT CONCAT(category_groups.name, ' : ', categories.name) as name, categories.id, 'category' as type
FROM categories
INNER JOIN category_groups ON categories.category_group_id = category_groups.id
WHERE category_groups.budget_id = $1
AND categories.name ILIKE $2
AND category_groups.name != 'Hidden Categories'
ORDER BY category_groups.name, categories.name
`

type SearchCategoriesParams struct {
	BudgetID uuid.UUID
	Search   string
}

type SearchCategoriesRow struct {
	Name interface{}
	ID   uuid.UUID
	Type interface{}
}

func (q *Queries) SearchCategories(ctx context.Context, arg SearchCategoriesParams) ([]SearchCategoriesRow, error) {
	rows, err := q.db.QueryContext(ctx, searchCategories, arg.BudgetID, arg.Search)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []SearchCategoriesRow
	for rows.Next() {
		var i SearchCategoriesRow
		if err := rows.Scan(&i.Name, &i.ID, &i.Type); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}