}

type badConfigErr struct {
	Err error
}

// Error - return the error message
func (bce badConfigErr) Error() string {
	return bce.Err.Error()
}

// Unwrap the error to its underlying error.
func (bce badConfigErr) Unwrap() error {
	return bce.Err
}

type setConfigResult struct {
	Cfg                     config.Config

}

func (er erasureObjects) getMultipartSHADir(bucket, object string) string {
	return getSHA256Hash([]byte(pathJoin(bucket, object)))
}

// checkUploadIDExists - verify if a given uploadID exists and is valid.
func (er erasureObjects) checkUploadIDExists(ctx context.Context, bucket, object, uploadID string, write bool) (fi FileInfo, metArr []FileInfo, err error) {
	defer func() {
		if errors.Is(err, errFileNotFound) {

}

// UnmarshalXML - decodes XML data.
func (p *Prefix) UnmarshalXML(d *xml.Decoder, start xml.StartElement) (err error) {
	var s string
	if err = d.DecodeElement(&s, &start); err != nil {
		return err
	}
	*p = Prefix{string: s, set: true}
	return nil
}

// MarshalXML - decodes XML data.
func (p Prefix) MarshalXML(e *xml.Encoder, startElement xml.StartElement) error {
	if !p.set {

type ErrInvalidBucketName Error

func (e ErrInvalidBucketName) Error() string {
	return e.Bucket + " invalid bucket name error: " + e.Err.Error()
}

func (e Error) Error() string {
	return "dns related error: " + e.Err.Error()
}

// ErrBucketConflict for buckets that already exist
type ErrBucketConflict Error

func (e ErrBucketConflict) Error() string {

package clause

type Returning struct {
	Columns []Column
}

// Name where clause name
func (returning Returning) Name() string {
	return "RETURNING"
}

// Build build where clause
func (returning Returning) Build(builder Builder) {
	if len(returning.Columns) > 0 {
		for idx, column := range returning.Columns {
			if idx > 0 {
				builder.WriteByte(',')
			}

			builder.WriteQuoted(column)
		}
	} else {

		t.Errorf("Failure to decrease timeout appropriately")
	}
}

func TestDynamicTimeoutConcurrent(t *testing.T) {
	// Race test.
	timeout := newDynamicTimeout(time.Second, time.Millisecond)
	var wg sync.WaitGroup
	for i := 0; i < runtime.GOMAXPROCS(0); i++ {
		wg.Add(1)
		rng := rand.New(rand.NewSource(int64(i)))
		go func() {
			defer wg.Done()
			for i := 0; i < 100; i++ {
				for j := 0; j < 100; j++ {

type fileInfoNames struct{}

func (f *fileInfoNames) Name() string {
	return "tmp"
}

func (f *fileInfoNames) Size() int64 {
	return 0
}

func (f *fileInfoNames) Mode() fs.FileMode {
	return 0777
}

func (f *fileInfoNames) ModTime() time.Time {
	return time.Time{}
}

func (f *fileInfoNames) IsDir() bool {
	return false
}

func (f *fileInfoNames) Sys() any {
	return nil

	LockingOptionsNoWait     = "NOWAIT"
)

type Locking struct {
	Strength string
	Table    Table
	Options  string
}

// Name where clause name
func (locking Locking) Name() string {
	return "FOR"
}

// Build build where clause
func (locking Locking) Build(builder Builder) {
	builder.WriteString(locking.Strength)
	if locking.Table.Name != "" {
		builder.WriteString(" OF ")

		}
		result[s[2]] = s[9]
	}

	if err := scanner.Err(); err != nil {
		return nil, err
	}

	return result, nil
}

func getDiskUUIDMap() (map[string]string, error) {
	result := make(map[string]string)
	err := filepath.Walk("/dev/disk/by-uuid/",
		func(path string, info os.FileInfo, err error) error {
			if err != nil {
				return err
			}
			realPath, err := filepath.EvalSymlinks(path)

	return encrypted, nil
}

type (
	objectMetaEncryptFn func(baseKey string, data []byte) []byte
	objectMetaDecryptFn func(baseKey string, data []byte) ([]byte, error)
)

// metadataEncrypter returns a function that will read data from input,
// encrypt it using the provided key and return the result.
// 0 sized inputs are passed through.
func metadataEncrypter(key crypto.ObjectKey) objectMetaEncryptFn {