mirror of
https://codeberg.org/forgejo/forgejo.git
synced 2024-12-05 19:52:54 +01:00
cc3910d8c3
Fix #22109 --------- Co-authored-by: silverwind <me@silverwind.io>
177 lines
5.9 KiB
Go
177 lines
5.9 KiB
Go
// Copyright 2021 The Gitea Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package db
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"strconv"
|
|
|
|
"code.gitea.io/gitea/modules/setting"
|
|
)
|
|
|
|
// ResourceIndex represents a resource index which could be used as issue/release and others
|
|
// We can create different tables i.e. issue_index, release_index, etc.
|
|
type ResourceIndex struct {
|
|
GroupID int64 `xorm:"pk"`
|
|
MaxIndex int64 `xorm:"index"`
|
|
}
|
|
|
|
var (
|
|
// ErrResouceOutdated represents an error when request resource outdated
|
|
ErrResouceOutdated = errors.New("resource outdated")
|
|
// ErrGetResourceIndexFailed represents an error when resource index retries 3 times
|
|
ErrGetResourceIndexFailed = errors.New("get resource index failed")
|
|
)
|
|
|
|
// SyncMaxResourceIndex sync the max index with the resource
|
|
func SyncMaxResourceIndex(ctx context.Context, tableName string, groupID, maxIndex int64) (err error) {
|
|
e := GetEngine(ctx)
|
|
|
|
// try to update the max_index and acquire the write-lock for the record
|
|
res, err := e.Exec(fmt.Sprintf("UPDATE %s SET max_index=? WHERE group_id=? AND max_index<?", tableName), maxIndex, groupID, maxIndex)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
affected, err := res.RowsAffected()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if affected == 0 {
|
|
// if nothing is updated, the record might not exist or might be larger, it's safe to try to insert it again and then check whether the record exists
|
|
_, errIns := e.Exec(fmt.Sprintf("INSERT INTO %s (group_id, max_index) VALUES (?, ?)", tableName), groupID, maxIndex)
|
|
var savedIdx int64
|
|
has, err := e.SQL(fmt.Sprintf("SELECT max_index FROM %s WHERE group_id=?", tableName), groupID).Get(&savedIdx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// if the record still doesn't exist, there must be some errors (insert error)
|
|
if !has {
|
|
if errIns == nil {
|
|
return errors.New("impossible error when SyncMaxResourceIndex, insert succeeded but no record is saved")
|
|
}
|
|
return errIns
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func postgresGetNextResourceIndex(ctx context.Context, tableName string, groupID int64) (int64, error) {
|
|
res, err := GetEngine(ctx).Query(fmt.Sprintf("INSERT INTO %s (group_id, max_index) "+
|
|
"VALUES (?,1) ON CONFLICT (group_id) DO UPDATE SET max_index = %s.max_index+1 RETURNING max_index",
|
|
tableName, tableName), groupID)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if len(res) == 0 {
|
|
return 0, ErrGetResourceIndexFailed
|
|
}
|
|
return strconv.ParseInt(string(res[0]["max_index"]), 10, 64)
|
|
}
|
|
|
|
func mysqlGetNextResourceIndex(ctx context.Context, tableName string, groupID int64) (int64, error) {
|
|
if _, err := GetEngine(ctx).Exec(fmt.Sprintf("INSERT INTO %s (group_id, max_index) "+
|
|
"VALUES (?,1) ON DUPLICATE KEY UPDATE max_index = max_index+1",
|
|
tableName), groupID); err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
var idx int64
|
|
_, err := GetEngine(ctx).SQL(fmt.Sprintf("SELECT max_index FROM %s WHERE group_id = ?", tableName), groupID).Get(&idx)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if idx == 0 {
|
|
return 0, errors.New("cannot get the correct index")
|
|
}
|
|
return idx, nil
|
|
}
|
|
|
|
func mssqlGetNextResourceIndex(ctx context.Context, tableName string, groupID int64) (int64, error) {
|
|
if _, err := GetEngine(ctx).Exec(fmt.Sprintf(`
|
|
MERGE INTO %s WITH (HOLDLOCK) AS target
|
|
USING (SELECT %d AS group_id) AS source
|
|
(group_id)
|
|
ON target.group_id = source.group_id
|
|
WHEN MATCHED
|
|
THEN UPDATE
|
|
SET max_index = max_index + 1
|
|
WHEN NOT MATCHED
|
|
THEN INSERT (group_id, max_index)
|
|
VALUES (%d, 1);
|
|
`, tableName, groupID, groupID)); err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
var idx int64
|
|
_, err := GetEngine(ctx).SQL(fmt.Sprintf("SELECT max_index FROM %s WHERE group_id = ?", tableName), groupID).Get(&idx)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if idx == 0 {
|
|
return 0, errors.New("cannot get the correct index")
|
|
}
|
|
return idx, nil
|
|
}
|
|
|
|
// GetNextResourceIndex generates a resource index, it must run in the same transaction where the resource is created
|
|
func GetNextResourceIndex(ctx context.Context, tableName string, groupID int64) (int64, error) {
|
|
switch {
|
|
case setting.Database.Type.IsPostgreSQL():
|
|
return postgresGetNextResourceIndex(ctx, tableName, groupID)
|
|
case setting.Database.Type.IsMySQL():
|
|
return mysqlGetNextResourceIndex(ctx, tableName, groupID)
|
|
case setting.Database.Type.IsMSSQL():
|
|
return mssqlGetNextResourceIndex(ctx, tableName, groupID)
|
|
}
|
|
|
|
e := GetEngine(ctx)
|
|
|
|
// try to update the max_index to next value, and acquire the write-lock for the record
|
|
res, err := e.Exec(fmt.Sprintf("UPDATE %s SET max_index=max_index+1 WHERE group_id=?", tableName), groupID)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
affected, err := res.RowsAffected()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if affected == 0 {
|
|
// this slow path is only for the first time of creating a resource index
|
|
_, errIns := e.Exec(fmt.Sprintf("INSERT INTO %s (group_id, max_index) VALUES (?, 0)", tableName), groupID)
|
|
res, err = e.Exec(fmt.Sprintf("UPDATE %s SET max_index=max_index+1 WHERE group_id=?", tableName), groupID)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
affected, err = res.RowsAffected()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
// if the update still can not update any records, the record must not exist and there must be some errors (insert error)
|
|
if affected == 0 {
|
|
if errIns == nil {
|
|
return 0, errors.New("impossible error when GetNextResourceIndex, insert and update both succeeded but no record is updated")
|
|
}
|
|
return 0, errIns
|
|
}
|
|
}
|
|
|
|
// now, the new index is in database (protected by the transaction and write-lock)
|
|
var newIdx int64
|
|
has, err := e.SQL(fmt.Sprintf("SELECT max_index FROM %s WHERE group_id=?", tableName), groupID).Get(&newIdx)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if !has {
|
|
return 0, errors.New("impossible error when GetNextResourceIndex, upsert succeeded but no record can be selected")
|
|
}
|
|
return newIdx, nil
|
|
}
|
|
|
|
// DeleteResourceIndex delete resource index
|
|
func DeleteResourceIndex(ctx context.Context, tableName string, groupID int64) error {
|
|
_, err := Exec(ctx, fmt.Sprintf("DELETE FROM %s WHERE group_id=?", tableName), groupID)
|
|
return err
|
|
}
|