github.com/mitranim/sqlb@v0.7.2/sqlb_err.go

package sqlb

import (
	"fmt"
	"io"
	r "reflect"
)

/*
String typedef that implements `error`. Errors of this type can be defined as
constants.
*/
type ErrStr string

// Implement `error`.
func (self ErrStr) Error() string { return string(self) }

// Implement `fmt.Stringer`.
func (self ErrStr) String() string { return string(self) }

// Marginally more efficient than `fmt.Errorf` due to 1 less indirection.
func errf(src string, arg ...any) ErrStr { return ErrStr(fmt.Sprintf(src, arg...)) }

/*
Used by `StructAssign` to indicate that no fields were provided, and therefore
it was unable to generate valid SQL for an "update set" clause. This can happen
because the input struct was missing or empty, or because all fields were
excluded through the use of `Sparse`. User code should detect this error to
skip the DB request altogether.
*/
var ErrEmptyAssign = error(ErrEmptyExpr{Err{
	`building SQL assignment expression`,
	ErrStr(`assignment must have at least one field`),
}})

/*
All errors generated by this package have this type, usually wrapped into a more
specialized one: `ErrInvalidInput{Err{...}}`.
*/
type Err struct {
	While string
	Cause error
}

var _ = error(Err{})

// Implement the `error` interface.
func (self Err) Error() string { return self.formatSimple(``) }

// Implement a hidden interface in "errors".
func (self Err) Unwrap() error { return self.Cause }

var _ = fmt.Formatter(Err{})

/*
Implement the `fmt.Formatter` interface. Similar to `Err.Error`, but when
formatting `.Cause`, uses `%+v`. By convention used by various libraries, this
may print the cause's stack trace, if any.
*/
func (self Err) Format(out fmt.State, verb rune) { self.format(``, out, verb) }

func (self Err) formatSimple(typ string) string {
	out := make(formatState, 0, 128)
	self.format(typ, &out, 0)
	return out.String()
}

func (self Err) format(typ string, out fmt.State, verb rune) {
	if self == (Err{}) {
		return
	}

	try1(io.WriteString(out, `[sqlb] error`))

	if typ != `` {
		try1(io.WriteString(out, ` `))
		try1(io.WriteString(out, Ident(typ).String()))
	}

	if self.While != `` {
		try1(io.WriteString(out, ` while `))
		try1(io.WriteString(out, self.While))
	}

	cause := self.Cause
	if cause != nil {
		try1(io.WriteString(out, `: `))

		impl, _ := cause.(fmt.Formatter)
		if impl != nil {
			impl.Format(out, verb)
		} else if out.Flag('+') {
			fmt.Fprintf(out, `%+v`, cause)
		} else {
			try1(io.WriteString(out, cause.Error()))
		}
	}
}

// Specialized type for errors reported by some functions.
type ErrInvalidInput struct{ Err }

// Implement the `error` interface.
func (self ErrInvalidInput) Error() string {
	return self.formatSimple(typeNameOf(self))
}

// Implement the `fmt.Formatter` interface.
func (self ErrInvalidInput) Format(out fmt.State, verb rune) {
	self.format(typeNameOf(self), out, verb)
}

// Specialized type for errors reported by some functions.
type ErrMissingArgument struct{ Err }

// Implement the `error` interface.
func (self ErrMissingArgument) Error() string {
	return self.formatSimple(typeNameOf(self))
}

// Implement the `fmt.Formatter` interface.
func (self ErrMissingArgument) Format(out fmt.State, verb rune) {
	self.format(typeNameOf(self), out, verb)
}

// Specialized type for errors reported by some functions.
type ErrUnexpectedParameter struct{ Err }

// Implement the `error` interface.
func (self ErrUnexpectedParameter) Error() string {
	return self.formatSimple(typeNameOf(self))
}

// Implement the `fmt.Formatter` interface.
func (self ErrUnexpectedParameter) Format(out fmt.State, verb rune) {
	self.format(typeNameOf(self), out, verb)
}

// Specialized type for errors reported by some functions.
type ErrUnusedArgument struct{ Err }

// Implement the `error` interface.
func (self ErrUnusedArgument) Error() string {
	return self.formatSimple(typeNameOf(self))
}

// Implement the `fmt.Formatter` interface.
func (self ErrUnusedArgument) Format(out fmt.State, verb rune) {
	self.format(typeNameOf(self), out, verb)
}

// Specialized type for errors reported by some functions.
type ErrOrdinalOutOfBounds struct{ Err }

// Implement the `error` interface.
func (self ErrOrdinalOutOfBounds) Error() string {
	return self.formatSimple(typeNameOf(self))
}

// Implement the `fmt.Formatter` interface.
func (self ErrOrdinalOutOfBounds) Format(out fmt.State, verb rune) {
	self.format(typeNameOf(self), out, verb)
}

// Specialized type for errors reported by some functions.
type ErrUnknownField struct{ Err }

// Implement the `error` interface.
func (self ErrUnknownField) Error() string {
	return self.formatSimple(typeNameOf(self))
}

// Implement the `fmt.Formatter` interface.
func (self ErrUnknownField) Format(out fmt.State, verb rune) {
	self.format(typeNameOf(self), out, verb)
}

// Specialized type for errors reported by some functions.
type ErrInternal struct{ Err }

// Implement the `error` interface.
func (self ErrInternal) Error() string {
	return self.formatSimple(typeNameOf(self))
}

// Implement the `fmt.Formatter` interface.
func (self ErrInternal) Format(out fmt.State, verb rune) {
	self.format(typeNameOf(self), out, verb)
}

// Specialized type for errors reported by some functions.
type ErrUnexpectedEOF struct{ Err }

// Implement the `error` interface.
func (self ErrUnexpectedEOF) Error() string {
	return self.formatSimple(typeNameOf(self))
}

// Implement the `fmt.Formatter` interface.
func (self ErrUnexpectedEOF) Format(out fmt.State, verb rune) {
	self.format(typeNameOf(self), out, verb)
}

// Specialized type for errors reported by some functions.
type ErrEmptyExpr struct{ Err }

// Implement the `error` interface.
func (self ErrEmptyExpr) Error() string {
	return self.formatSimple(typeNameOf(self))
}

// Implement the `fmt.Formatter` interface.
func (self ErrEmptyExpr) Format(out fmt.State, verb rune) {
	self.format(typeNameOf(self), out, verb)
}

func errOrdinal(err error) error {
	if err == nil {
		return nil
	}
	return ErrInternal{Err{`parsing ordinal parameter`, err}}
}

func errNamed(err error) error {
	if err == nil {
		return nil
	}
	return ErrInternal{Err{`parsing named parameter`, err}}
}

func errMissingOrdinal(val OrdinalParam) ErrMissingArgument {
	return ErrMissingArgument{Err{
		`building SQL expression`,
		errf(`missing ordinal argument %q (index %v)`, val, val.Index()),
	}}
}

func errMissingNamed(val NamedParam) ErrMissingArgument {
	return ErrMissingArgument{Err{
		`building SQL expression`,
		errf(`missing named argument %q (key %q)`, val, val.Key()),
	}}
}

func errUnusedOrdinal(val OrdinalParam) ErrUnusedArgument {
	return ErrUnusedArgument{Err{
		`building SQL expression`,
		errf(`unused ordinal argument %q (index %v)`, val, val.Index()),
	}}
}

func errUnusedNamed(val NamedParam) ErrUnusedArgument {
	return ErrUnusedArgument{Err{
		`building SQL expression`,
		errf(`unused named argument %q (key %q)`, val, val.Key()),
	}}
}

func errExpectedX(desc, while string, val any) ErrInvalidInput {
	return ErrInvalidInput{Err{
		while,
		errf(`expected %v, found %v`, desc, val),
	}}
}

func errExpectedSlice(while string, val any) ErrInvalidInput {
	return errExpectedX(`slice`, while, val)
}

func errExpectedStruct(while string, val any) ErrInvalidInput {
	return errExpectedX(`struct`, while, val)
}

func errUnexpectedArgs(desc, input any) ErrInvalidInput {
	return ErrInvalidInput{Err{
		`building SQL expression`,
		errf(`%v expected no arguments, got %#v`, desc, input),
	}}
}

func errMissingArgs(desc any) ErrInvalidInput {
	return ErrInvalidInput{Err{
		`building SQL expression`,
		errf(`%v expected arguments, got none`, desc),
	}}
}

func errUnknownField(while, jsonPath, typeName string) ErrUnknownField {
	return ErrUnknownField{Err{
		while,
		errf(`no DB path corresponding to JSON path %q in type %v`, jsonPath, typeName),
	}}
}

func errUnsupportedType(while string, typ r.Type) ErrInvalidInput {
	return ErrInvalidInput{Err{
		while,
		errf(`unsupported type %q of kind %q`, typ, typ.Kind()),
	}}
}

func errInvalidOrd(src string) ErrInvalidInput {
	return ErrInvalidInput{Err{
		`parsing ordering expression`,
		errf(
			`%q is not a valid ordering string; expected formatSimple: "<ident> (asc|desc)? (nulls (?:first|last))?"`,
			src,
		),
	}}
}