beggin/blog-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 统一sql命名、函数命名

Browse Source
This commit is contained in:
21 Guns
2026-08-02 12:02:04 +08:00
parent d39342ce5f
commit 0e674e9d56
68 changed files with 1985 additions and 1720 deletions
Download Patch File Download Diff File Expand all files Collapse all files

392
internal/db/sqlc/sys_roles.sql.go
View File

@@ -9,76 +9,76 @@ import (
"context"
)
const countSysRoles = `-- name: CountSysRoles :one
const countRoles = `-- name: CountRoles :one
SELECT COUNT(*)
FROM sys_roles
`
func (q *Queries) CountSysRoles(ctx context.Context) (int64, error) {
row := q.db.QueryRow(ctx, countSysRoles)
func (q *Queries) CountRoles(ctx context.Context) (int64, error) {
row := q.db.QueryRow(ctx, countRoles)
var count int64
err := row.Scan(&count)
return count, err
}
const createSysRole = `-- name: CreateSysRole :exec
const createRole = `-- name: CreateRole :exec
INSERT INTO sys_roles (name, code, status)
VALUES ($1, $2, $3)
`
type CreateSysRoleParams struct {
type CreateRoleParams struct {
Name string `json:"name"`
Code string `json:"code"`
Status int16 `json:"status"`
}
func (q *Queries) CreateSysRole(ctx context.Context, arg CreateSysRoleParams) error {
_, err := q.db.Exec(ctx, createSysRole, arg.Name, arg.Code, arg.Status)
func (q *Queries) CreateRole(ctx context.Context, arg CreateRoleParams) error {
_, err := q.db.Exec(ctx, createRole, arg.Name, arg.Code, arg.Status)
return err
}
type CreateSysRolePermissionParams struct {
type CreateRolePermissionParams struct {
RoleID int32 `json:"role_id"`
PermissionID int32 `json:"permission_id"`
}
const deleteSysRole = `-- name: DeleteSysRole :execrows
const deleteRole = `-- name: DeleteRole :execrows
DELETE
FROM sys_roles
WHERE id = $1
`
func (q *Queries) DeleteSysRole(ctx context.Context, id int32) (int64, error) {
result, err := q.db.Exec(ctx, deleteSysRole, id)
func (q *Queries) DeleteRole(ctx context.Context, id int32) (int64, error) {
result, err := q.db.Exec(ctx, deleteRole, id)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const deleteSysRolePermissionByPermissionID = `-- name: DeleteSysRolePermissionByPermissionID :exec
const deleteRolePermissionByPermissionID = `-- name: DeleteRolePermissionByPermissionID :exec
DELETE
FROM sys_role_permission
WHERE permission_id = $1
`
func (q *Queries) DeleteSysRolePermissionByPermissionID(ctx context.Context, permissionID int32) error {
_, err := q.db.Exec(ctx, deleteSysRolePermissionByPermissionID, permissionID)
func (q *Queries) DeleteRolePermissionByPermissionID(ctx context.Context, permissionID int32) error {
_, err := q.db.Exec(ctx, deleteRolePermissionByPermissionID, permissionID)
return err
}
const deleteSysRolePermissionByRoleID = `-- name: DeleteSysRolePermissionByRoleID :exec
const deleteRolePermissionsByRoleID = `-- name: DeleteRolePermissionsByRoleID :exec
DELETE
FROM sys_role_permission
WHERE role_id = $1
`
func (q *Queries) DeleteSysRolePermissionByRoleID(ctx context.Context, roleID int32) error {
_, err := q.db.Exec(ctx, deleteSysRolePermissionByRoleID, roleID)
func (q *Queries) DeleteRolePermissionsByRoleID(ctx context.Context, roleID int32) error {
_, err := q.db.Exec(ctx, deleteRolePermissionsByRoleID, roleID)
return err
}
const deleteSysRolePermissionByType = `-- name: DeleteSysRolePermissionByType :exec
const deleteRolePermissionsByType = `-- name: DeleteRolePermissionsByType :exec
DELETE
FROM sys_role_permission rp USING sys_permissions p
WHERE rp.permission_id = p.id
@@ -86,28 +86,28 @@ WHERE rp.permission_id = p.id
AND p."type" = $2
`
type DeleteSysRolePermissionByTypeParams struct {
type DeleteRolePermissionsByTypeParams struct {
RoleID int32 `json:"role_id"`
Type int16 `json:"type"`
}
func (q *Queries) DeleteSysRolePermissionByType(ctx context.Context, arg DeleteSysRolePermissionByTypeParams) error {
_, err := q.db.Exec(ctx, deleteSysRolePermissionByType, arg.RoleID, arg.Type)
func (q *Queries) DeleteRolePermissionsByType(ctx context.Context, arg DeleteRolePermissionsByTypeParams) error {
_, err := q.db.Exec(ctx, deleteRolePermissionsByType, arg.RoleID, arg.Type)
return err
}
const deleteSysUserRoleByRoleID = `-- name: DeleteSysUserRoleByRoleID :exec
const deleteUserRoleByRoleID = `-- name: DeleteUserRoleByRoleID :exec
DELETE
FROM sys_user_role
WHERE role_id = $1
`
func (q *Queries) DeleteSysUserRoleByRoleID(ctx context.Context, roleID int32) error {
_, err := q.db.Exec(ctx, deleteSysUserRoleByRoleID, roleID)
func (q *Queries) DeleteUserRoleByRoleID(ctx context.Context, roleID int32) error {
_, err := q.db.Exec(ctx, deleteUserRoleByRoleID, roleID)
return err
}
const existsSysRoleCode = `-- name: ExistsSysRoleCode :one
const existsRoleCode = `-- name: ExistsRoleCode :one
SELECT EXISTS(SELECT 1
FROM sys_roles
WHERE code = $1
@@ -117,143 +117,26 @@ SELECT EXISTS(SELECT 1
))
`
type ExistsSysRoleCodeParams struct {
type ExistsRoleCodeParams struct {
Code string `json:"code"`
ID *int32 `json:"id"`
}
func (q *Queries) ExistsSysRoleCode(ctx context.Context, arg ExistsSysRoleCodeParams) (bool, error) {
row := q.db.QueryRow(ctx, existsSysRoleCode, arg.Code, arg.ID)
func (q *Queries) ExistsRoleCode(ctx context.Context, arg ExistsRoleCodeParams) (bool, error) {
row := q.db.QueryRow(ctx, existsRoleCode, arg.Code, arg.ID)
var exists bool
err := row.Scan(&exists)
return exists, err
}
const getAllSysRoles = `-- name: GetAllSysRoles :many
SELECT id, name, code, status, created_at, updated_at
from sys_roles
`
func (q *Queries) GetAllSysRoles(ctx context.Context) ([]SysRole, error) {
rows, err := q.db.Query(ctx, getAllSysRoles)
if err != nil {
return nil, err
}
defer rows.Close()
items := []SysRole{}
for rows.Next() {
var i SysRole
if err := rows.Scan(
&i.ID,
&i.Name,
&i.Code,
&i.Status,
&i.CreatedAt,
&i.UpdatedAt,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const getSysPermissionIdsByApiIDs = `-- name: GetSysPermissionIdsByApiIDs :many
SELECT permission_id
FROM sys_api_permission
WHERE api_id = ANY ($1::int[])
`
func (q *Queries) GetSysPermissionIdsByApiIDs(ctx context.Context, dollar_1 []int32) ([]int32, error) {
rows, err := q.db.Query(ctx, getSysPermissionIdsByApiIDs, dollar_1)
if err != nil {
return nil, err
}
defer rows.Close()
items := []int32{}
for rows.Next() {
var permission_id int32
if err := rows.Scan(&permission_id); err != nil {
return nil, err
}
items = append(items, permission_id)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const getSysPermissionIdsByMenuIDs = `-- name: GetSysPermissionIdsByMenuIDs :many
SELECT permission_id
FROM sys_menu_permission
WHERE menu_id = ANY ($1::int[])
`
func (q *Queries) GetSysPermissionIdsByMenuIDs(ctx context.Context, dollar_1 []int32) ([]int32, error) {
rows, err := q.db.Query(ctx, getSysPermissionIdsByMenuIDs, dollar_1)
if err != nil {
return nil, err
}
defer rows.Close()
items := []int32{}
for rows.Next() {
var permission_id int32
if err := rows.Scan(&permission_id); err != nil {
return nil, err
}
items = append(items, permission_id)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const getSysRoleApis = `-- name: GetSysRoleApis :many
SELECT a.id, a."name"
FROM sys_role_permission rp
JOIN sys_api_permission ap ON ap.permission_id = rp.permission_id
JOIN sys_apis a ON a.id = ap.api_id
WHERE rp.role_id = $1
`
type GetSysRoleApisRow struct {
ID int32 `json:"id"`
Name string `json:"name"`
}
func (q *Queries) GetSysRoleApis(ctx context.Context, roleID int32) ([]GetSysRoleApisRow, error) {
rows, err := q.db.Query(ctx, getSysRoleApis, roleID)
if err != nil {
return nil, err
}
defer rows.Close()
items := []GetSysRoleApisRow{}
for rows.Next() {
var i GetSysRoleApisRow
if err := rows.Scan(&i.ID, &i.Name); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const getSysRoleByID = `-- name: GetSysRoleByID :one
const getRoleByID = `-- name: GetRoleByID :one
SELECT id, name, code, status, created_at, updated_at
FROM sys_roles
WHERE id = $1
`
func (q *Queries) GetSysRoleByID(ctx context.Context, id int32) (SysRole, error) {
row := q.db.QueryRow(ctx, getSysRoleByID, id)
func (q *Queries) GetRoleByID(ctx context.Context, id int32) (SysRole, error) {
row := q.db.QueryRow(ctx, getRoleByID, id)
var i SysRole
err := row.Scan(
&i.ID,
@@ -266,53 +149,13 @@ func (q *Queries) GetSysRoleByID(ctx context.Context, id int32) (SysRole, error)
return i, err
}
const getSysRoleMenus = `-- name: GetSysRoleMenus :many
SELECT m.id, m.name
FROM sys_role_permission rp
JOIN sys_menu_permission mp ON mp.permission_id = rp.permission_id
JOIN sys_menus m ON m.id = mp.menu_id
WHERE rp.role_id = $1
`
type GetSysRoleMenusRow struct {
ID int32 `json:"id"`
Name string `json:"name"`
}
func (q *Queries) GetSysRoleMenus(ctx context.Context, roleID int32) ([]GetSysRoleMenusRow, error) {
rows, err := q.db.Query(ctx, getSysRoleMenus, roleID)
if err != nil {
return nil, err
}
defer rows.Close()
items := []GetSysRoleMenusRow{}
for rows.Next() {
var i GetSysRoleMenusRow
if err := rows.Scan(&i.ID, &i.Name); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listSysRoles = `-- name: ListSysRoles :many
const listAllRoles = `-- name: ListAllRoles :many
SELECT id, name, code, status, created_at, updated_at
FROM sys_roles
ORDER BY id
LIMIT $1 OFFSET $2
from sys_roles
`
type ListSysRolesParams struct {
Limit int32 `json:"limit"`
Offset int32 `json:"offset"`
}
func (q *Queries) ListSysRoles(ctx context.Context, arg ListSysRolesParams) ([]SysRole, error) {
rows, err := q.db.Query(ctx, listSysRoles, arg.Limit, arg.Offset)
func (q *Queries) ListAllRoles(ctx context.Context) ([]SysRole, error) {
rows, err := q.db.Query(ctx, listAllRoles)
if err != nil {
return nil, err
}
@@ -338,21 +181,178 @@ func (q *Queries) ListSysRoles(ctx context.Context, arg ListSysRolesParams) ([]S
return items, nil
}
const updateSysRole = `-- name: UpdateSysRole :execrows
const listPermissionIDsByApiIDs = `-- name: ListPermissionIDsByApiIDs :many
SELECT permission_id
FROM sys_api_permission
WHERE api_id = ANY ($1::int[])
`
func (q *Queries) ListPermissionIDsByApiIDs(ctx context.Context, dollar_1 []int32) ([]int32, error) {
rows, err := q.db.Query(ctx, listPermissionIDsByApiIDs, dollar_1)
if err != nil {
return nil, err
}
defer rows.Close()
items := []int32{}
for rows.Next() {
var permission_id int32
if err := rows.Scan(&permission_id); err != nil {
return nil, err
}
items = append(items, permission_id)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listPermissionIDsByMenuIDs = `-- name: ListPermissionIDsByMenuIDs :many
SELECT permission_id
FROM sys_menu_permission
WHERE menu_id = ANY ($1::int[])
`
func (q *Queries) ListPermissionIDsByMenuIDs(ctx context.Context, dollar_1 []int32) ([]int32, error) {
rows, err := q.db.Query(ctx, listPermissionIDsByMenuIDs, dollar_1)
if err != nil {
return nil, err
}
defer rows.Close()
items := []int32{}
for rows.Next() {
var permission_id int32
if err := rows.Scan(&permission_id); err != nil {
return nil, err
}
items = append(items, permission_id)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listRoleApis = `-- name: ListRoleApis :many
SELECT a.id, a."name"
FROM sys_role_permission rp
JOIN sys_api_permission ap ON ap.permission_id = rp.permission_id
JOIN sys_apis a ON a.id = ap.api_id
WHERE rp.role_id = $1
`
type ListRoleApisRow struct {
ID int32 `json:"id"`
Name string `json:"name"`
}
func (q *Queries) ListRoleApis(ctx context.Context, roleID int32) ([]ListRoleApisRow, error) {
rows, err := q.db.Query(ctx, listRoleApis, roleID)
if err != nil {
return nil, err
}
defer rows.Close()
items := []ListRoleApisRow{}
for rows.Next() {
var i ListRoleApisRow
if err := rows.Scan(&i.ID, &i.Name); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listRoleMenus = `-- name: ListRoleMenus :many
SELECT m.id, m.name
FROM sys_role_permission rp
JOIN sys_menu_permission mp ON mp.permission_id = rp.permission_id
JOIN sys_menus m ON m.id = mp.menu_id
WHERE rp.role_id = $1
`
type ListRoleMenusRow struct {
ID int32 `json:"id"`
Name string `json:"name"`
}
func (q *Queries) ListRoleMenus(ctx context.Context, roleID int32) ([]ListRoleMenusRow, error) {
rows, err := q.db.Query(ctx, listRoleMenus, roleID)
if err != nil {
return nil, err
}
defer rows.Close()
items := []ListRoleMenusRow{}
for rows.Next() {
var i ListRoleMenusRow
if err := rows.Scan(&i.ID, &i.Name); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listRoles = `-- name: ListRoles :many
SELECT id, name, code, status, created_at, updated_at
FROM sys_roles
ORDER BY id
LIMIT $1 OFFSET $2
`
type ListRolesParams struct {
Limit int32 `json:"limit"`
Offset int32 `json:"offset"`
}
func (q *Queries) ListRoles(ctx context.Context, arg ListRolesParams) ([]SysRole, error) {
rows, err := q.db.Query(ctx, listRoles, arg.Limit, arg.Offset)
if err != nil {
return nil, err
}
defer rows.Close()
items := []SysRole{}
for rows.Next() {
var i SysRole
if err := rows.Scan(
&i.ID,
&i.Name,
&i.Code,
&i.Status,
&i.CreatedAt,
&i.UpdatedAt,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const updateRole = `-- name: UpdateRole :execrows
UPDATE sys_roles
SET name = coalesce($1, name),
status = coalesce($2, status)
WHERE id = $3
`
type UpdateSysRoleParams struct {
type UpdateRoleParams struct {
Name *string `json:"name"`
Status *int16 `json:"status"`
ID int32 `json:"id"`
}
func (q *Queries) UpdateSysRole(ctx context.Context, arg UpdateSysRoleParams) (int64, error) {
result, err := q.db.Exec(ctx, updateSysRole, arg.Name, arg.Status, arg.ID)
func (q *Queries) UpdateRole(ctx context.Context, arg UpdateRoleParams) (int64, error) {
result, err := q.db.Exec(ctx, updateRole, arg.Name, arg.Status, arg.ID)
if err != nil {
return 0, err
}