stufflog3/ports/mysql/mysqlcore/scopes.sql.go

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

package mysqlcore

import (
	"context"
	"database/sql"

	"git.aiterp.net/stufflog3/stufflog3/ports/mysql/sqltypes"
)

const deleteAllScopeMembers = `-- name: DeleteAllScopeMembers :exec
DELETE FROM scope_member WHERE scope_id=?
`

func (q *Queries) DeleteAllScopeMembers(ctx context.Context, scopeID int) error {
	_, err := q.exec(ctx, q.deleteAllScopeMembersStmt, deleteAllScopeMembers, scopeID)
	return err
}

const deleteScope = `-- name: DeleteScope :exec
DELETE FROM scope WHERE id=?
`

func (q *Queries) DeleteScope(ctx context.Context, id int) error {
	_, err := q.exec(ctx, q.deleteScopeStmt, deleteScope, id)
	return err
}

const deleteScopeMember = `-- name: DeleteScopeMember :exec
DELETE FROM scope_member WHERE scope_id=? AND user_id=?
`

type DeleteScopeMemberParams struct {
	ScopeID int
	UserID  string
}

func (q *Queries) DeleteScopeMember(ctx context.Context, arg DeleteScopeMemberParams) error {
	_, err := q.exec(ctx, q.deleteScopeMemberStmt, deleteScopeMember, arg.ScopeID, arg.UserID)
	return err
}

const getScope = `-- name: GetScope :one
SELECT id, name, abbreviation, custom_labels FROM scope
WHERE id = ?
`

func (q *Queries) GetScope(ctx context.Context, id int) (Scope, error) {
	row := q.queryRow(ctx, q.getScopeStmt, getScope, id)
	var i Scope
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Abbreviation,
		&i.CustomLabels,
	)
	return i, err
}

const insertScope = `-- name: InsertScope :execresult
INSERT INTO scope (id, name, abbreviation, custom_labels)
VALUES (?, ?, ?, ?)
`

type InsertScopeParams struct {
	ID           int
	Name         string
	Abbreviation string
	CustomLabels sqltypes.NullRawMessage
}

func (q *Queries) InsertScope(ctx context.Context, arg InsertScopeParams) (sql.Result, error) {
	return q.exec(ctx, q.insertScopeStmt, insertScope,
		arg.ID,
		arg.Name,
		arg.Abbreviation,
		arg.CustomLabels,
	)
}

const listScopeMembers = `-- name: ListScopeMembers :many
SELECT scope_id, user_id, name, owner FROM scope_member
WHERE scope_id = ?
ORDER BY name
`

func (q *Queries) ListScopeMembers(ctx context.Context, scopeID int) ([]ScopeMember, error) {
	rows, err := q.query(ctx, q.listScopeMembersStmt, listScopeMembers, scopeID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ScopeMember{}
	for rows.Next() {
		var i ScopeMember
		if err := rows.Scan(
			&i.ScopeID,
			&i.UserID,
			&i.Name,
			&i.Owner,
		); 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 listScopeMembersMulti = `-- name: ListScopeMembersMulti :many
SELECT scope_id, user_id, name, owner FROM scope_member
WHERE scope_id IN (?, ?, ?, ?, ?, ?)
ORDER BY name
`

type ListScopeMembersMultiParams struct {
	ScopeID   int
	ScopeID_2 int
	ScopeID_3 int
	ScopeID_4 int
	ScopeID_5 int
	ScopeID_6 int
}

func (q *Queries) ListScopeMembersMulti(ctx context.Context, arg ListScopeMembersMultiParams) ([]ScopeMember, error) {
	rows, err := q.query(ctx, q.listScopeMembersMultiStmt, listScopeMembersMulti,
		arg.ScopeID,
		arg.ScopeID_2,
		arg.ScopeID_3,
		arg.ScopeID_4,
		arg.ScopeID_5,
		arg.ScopeID_6,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ScopeMember{}
	for rows.Next() {
		var i ScopeMember
		if err := rows.Scan(
			&i.ScopeID,
			&i.UserID,
			&i.Name,
			&i.Owner,
		); 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 listScopes = `-- name: ListScopes :many
SELECT id, name, abbreviation, custom_labels FROM scope
ORDER BY name
`

func (q *Queries) ListScopes(ctx context.Context) ([]Scope, error) {
	rows, err := q.query(ctx, q.listScopesStmt, listScopes)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Scope{}
	for rows.Next() {
		var i Scope
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Abbreviation,
			&i.CustomLabels,
		); 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 listScopesByUser = `-- name: ListScopesByUser :many
SELECT s.id, s.name, s.abbreviation, s.custom_labels FROM scope_member sm
RIGHT JOIN scope s on s.id = sm.scope_id
WHERE sm.user_id = ?
ORDER BY s.name
`

func (q *Queries) ListScopesByUser(ctx context.Context, userID string) ([]Scope, error) {
	rows, err := q.query(ctx, q.listScopesByUserStmt, listScopesByUser, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Scope{}
	for rows.Next() {
		var i Scope
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Abbreviation,
			&i.CustomLabels,
		); 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 replaceScopeMember = `-- name: ReplaceScopeMember :exec
REPLACE INTO scope_member (scope_id, user_id, name, owner)
VALUES (?, ?, ?, ?)
`

type ReplaceScopeMemberParams struct {
	ScopeID int
	UserID  string
	Name    string
	Owner   bool
}

func (q *Queries) ReplaceScopeMember(ctx context.Context, arg ReplaceScopeMemberParams) error {
	_, err := q.exec(ctx, q.replaceScopeMemberStmt, replaceScopeMember,
		arg.ScopeID,
		arg.UserID,
		arg.Name,
		arg.Owner,
	)
	return err
}

const updateScope = `-- name: UpdateScope :exec
UPDATE scope SET name = ?, abbreviation = ?, custom_labels = ? WHERE id = ?
`

type UpdateScopeParams struct {
	Name         string
	Abbreviation string
	CustomLabels sqltypes.NullRawMessage
	ID           int
}

func (q *Queries) UpdateScope(ctx context.Context, arg UpdateScopeParams) error {
	_, err := q.exec(ctx, q.updateScopeStmt, updateScope,
		arg.Name,
		arg.Abbreviation,
		arg.CustomLabels,
		arg.ID,
	)
	return err
}