157 lines
5.9 KiB
Go
157 lines
5.9 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"pageswiki/internal/db"
|
|
|
|
"github.com/jackc/pgx/v5/pgconn"
|
|
)
|
|
|
|
type storeSQLBackend uint8
|
|
|
|
const (
|
|
storeSQLite storeSQLBackend = iota
|
|
storePostgreSQL
|
|
)
|
|
|
|
var ErrPostgreSQLComponentNotReady = errors.New("PostgreSQL component dependencies are not ported")
|
|
|
|
type namespaceValidationError string
|
|
|
|
func (e namespaceValidationError) Error() string { return string(e) }
|
|
|
|
// SQL placeholders are generated while composing owned queries. Do not rebind
|
|
// arbitrary SQL strings or translate SQLite syntax at the driver boundary.
|
|
func (s *Store) sqlParam(n int) string {
|
|
if s.sqlBackend == storePostgreSQL {
|
|
return fmt.Sprintf("$%d", n)
|
|
}
|
|
return "?"
|
|
}
|
|
func (s *Store) sqlValues(n int) string {
|
|
parts := make([]string, n)
|
|
for i := range parts {
|
|
parts[i] = s.sqlParam(i + 1)
|
|
}
|
|
return strings.Join(parts, ",")
|
|
}
|
|
func (s *Store) sqlHasDot(expression string) string {
|
|
if s.sqlBackend == storePostgreSQL {
|
|
return "strpos(" + expression + ", '.') > 0"
|
|
}
|
|
return "instr(" + expression + ", '.') > 0"
|
|
}
|
|
|
|
// Owned expressions only. C/BINARY ordering makes '%' and '_' literal and
|
|
// keeps segment ranges case-sensitive, independent of database locale.
|
|
func (s *Store) pathScopeSQL(parent, child string) string {
|
|
if s.sqlBackend == storeSQLite {
|
|
return cityPathScopeSQL(parent, child)
|
|
}
|
|
return `(` + parent + `!='' AND (` + child + ` COLLATE "C" = ` + parent + ` OR (` + child + ` COLLATE "C" >= rtrim(` + parent + `,'/')||'/' AND ` + child + ` COLLATE "C" < rtrim(` + parent + `,'/')||'0')))`
|
|
}
|
|
|
|
func (s *Store) pathOverlapSQL(left, right string) string {
|
|
return `(` + s.pathScopeSQL(left, right) + ` OR ` + s.pathScopeSQL(right, left) + `)`
|
|
}
|
|
|
|
// Both operands are owned SQL expressions/literals, never request input.
|
|
func (s *Store) sqlStringPosition(expression, literal string) string {
|
|
if s.sqlBackend == storePostgreSQL {
|
|
return "strpos(" + expression + ", '" + literal + "')"
|
|
}
|
|
return "instr(" + expression + ", '" + literal + "')"
|
|
}
|
|
|
|
func (s *Store) sqlError(operation string, err error) error {
|
|
if s.sqlBackend != storePostgreSQL || err == nil {
|
|
return err
|
|
}
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return sql.ErrNoRows
|
|
}
|
|
if errors.Is(err, context.Canceled) {
|
|
return context.Canceled
|
|
}
|
|
if errors.Is(err, context.DeadlineExceeded) {
|
|
return context.DeadlineExceeded
|
|
}
|
|
var already *db.PostgreSQLError
|
|
if errors.As(err, &already) {
|
|
return err
|
|
}
|
|
var validation namespaceValidationError
|
|
for _, sentinel := range []error{ErrEventWorker, ErrEventClaim, ErrEventQueueFull, ErrEventCompletionLog, ErrEventJobFilter, ErrPeriodicalConflict, ErrPeriodicalDisabled, ErrEmbeddedAssetUnavailable, ErrContactUIDConflict, ErrContactSyncToken, ErrTaskNoteExists, ErrTaskCaptureMissing, ErrNotificationInput, ErrTaskInvalid, ErrTaskConflict, ErrTaskDeleted, ErrTaskHasChildren, ErrTaskWorking, ErrTaskDAVLimit, ErrTaskDAVIdentity, ErrTaskDAVRelocated, ErrTaskDAVCollectionExists, ErrDocumentHashMismatch, ErrObjectListBudget} {
|
|
if errors.Is(err, sentinel) {
|
|
return sentinel
|
|
}
|
|
}
|
|
for _, sentinel := range []error{ErrBackendFeatureUnavailable, ErrCLIPending, ErrCLISlowDown, ErrCLIExpired, ErrCLILimit, ErrReadOnly,
|
|
ErrGovernanceInvalid, ErrGovernanceConflict, ErrGovernanceCeiling, ErrGovernanceConfirm,
|
|
ErrLocalityAccessAlias, ErrLocalityAccessEnforcing, ErrPublicationImpact, ErrNavigationBudget, ErrApprovalTransition,
|
|
ErrManifestCapability, ErrPeriodicalInvalid, ErrContactPhone, ErrRevisionCursor, ErrRevisionConflict, ErrInvalidRevisionLanguage, ErrPageNotFound, ErrRevisionDomainRequired, ErrDocumentStoreRequired} {
|
|
if errors.Is(err, sentinel) {
|
|
return sentinel
|
|
}
|
|
}
|
|
if errors.As(err, &validation) || errors.Is(err, ErrPostgreSQLComponentNotReady) || errors.Is(err, ErrAccessDenied) {
|
|
return err
|
|
}
|
|
for _, sentinel := range []error{ErrPathNotFound, ErrPathConflict, ErrPathSnapshotChanged, ErrPathMutationTooLarge, ErrCityChanged, ErrCityMapBudget, ErrCityNameAmbiguous, ErrAssetConflict, ErrAssetNotFound, ErrActivityOutboxInput, ErrBrowserNavigationLimit} {
|
|
if errors.Is(err, sentinel) {
|
|
return sentinel
|
|
}
|
|
}
|
|
safe := &db.PostgreSQLError{Operation: operation}
|
|
var pg *pgconn.PgError
|
|
if errors.As(err, &pg) {
|
|
safe.SQLState = pg.Code
|
|
return safe
|
|
}
|
|
// Driver encoding and Scan errors can also contain private values. Only
|
|
// explicitly marked, constant validation messages escape this boundary.
|
|
return safe
|
|
}
|
|
|
|
// namespaceWrite serializes topology validation with its mutation, including
|
|
// callers in different processes. All future Domain writers must use this key.
|
|
// Payload/filesystem I/O must remain outside this small transaction.
|
|
func (s *Store) namespaceWrite(ctx context.Context, fn func(context.Context, *sql.Tx) error) error {
|
|
return s.administrativeWrite(ctx, `UPDATE domains SET uuid=uuid WHERE 0`, fn)
|
|
}
|
|
|
|
// SQLite's database-wide writer lock can be reserved using an owned table.
|
|
// Authentication-only legacy fixtures have groups but no domains. PostgreSQL
|
|
// always uses the same topology/administration advisory key, regardless of table.
|
|
func (s *Store) groupWrite(ctx context.Context, fn func(context.Context, *sql.Tx) error) error {
|
|
return s.administrativeWrite(ctx, `UPDATE groups SET uuid=uuid WHERE 0`, fn)
|
|
}
|
|
|
|
func (s *Store) administrativeWrite(ctx context.Context, sqliteReservation string, fn func(context.Context, *sql.Tx) error) error {
|
|
ctx, cancel := context.WithTimeout(ctx, 15*time.Second)
|
|
defer cancel()
|
|
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted})
|
|
if err != nil {
|
|
return s.sqlError("namespace begin", err)
|
|
}
|
|
defer tx.Rollback()
|
|
if s.sqlBackend == storePostgreSQL {
|
|
_, err = tx.ExecContext(ctx, `SELECT pg_advisory_xact_lock(1885431653, 1853058931)`)
|
|
} else {
|
|
_, err = tx.ExecContext(ctx, sqliteReservation)
|
|
}
|
|
if err != nil {
|
|
return s.sqlError("namespace lock", err)
|
|
}
|
|
if err := fn(ctx, tx); err != nil {
|
|
return s.sqlError("namespace update", err)
|
|
}
|
|
return s.sqlError("namespace commit", tx.Commit())
|
|
}
|