if err != nil {
			m.Errors = append(m.Errors, fmt.Sprintf("%s: %v (cpuCount)", byHostName, err.Error()))
		} else {
			m.Aggregated.CPU.CPUCount = cpuCount
		}

		loadStat, err := load.Avg()
		if err != nil {
			m.Errors = append(m.Errors, fmt.Sprintf("%s: %v (loadStat)", byHostName, err.Error()))
		} else {
			m.Aggregated.CPU.LoadStat = loadStat
		}
	}
	if types.Contains(madmin.MetricsRPC) {

errors.plugin_file_is_not_found={0} is not found.
errors.failed_to_install_plugin=Failed to install {0}.
errors.failed_to_find_plugins=Could not find available plugins.
errors.failed_to_process_sso_request=Failed to process a request: {0}

errors.property_required={0} is required.
errors.property_type_integer={0} must be an integer.
errors.property_type_long={0} must be a long.
errors.property_type_float={0} must be a float.

errors.plugin_file_is_not_found={0} is not found.
errors.failed_to_install_plugin=Failed to install {0}.
errors.failed_to_find_plugins=Could not find available plugins.
errors.failed_to_process_sso_request=Failed to process a request: {0}

errors.property_required={0} is required.
errors.property_type_integer={0} must be an integer.
errors.property_type_long={0} must be a long.
errors.property_type_float={0} must be a float.

		slog.String("sql", sql),
	}

	if rows != -1 {
		fields = append(fields, slog.Int64("rows", rows))
	}

	switch {
	case err != nil && (!l.IgnoreRecordNotFoundError || !errors.Is(err, ErrRecordNotFound)):
		fields = append(fields, slog.String("error", err.Error()))
		l.log(ctx, slog.LevelError, "SQL executed", slog.Attr{
			Key:   "trace",
			Value: slog.GroupValue(fields...),
		})

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package store

import (
	"context"
	"errors"
	"sync"
	"time"
)

// ErrBatchFull indicates that the batch is full
var ErrBatchFull = errors.New("batch is full")

const defaultCommitTimeout = 30 * time.Second

// Batch represents an ordered batch
type Batch[I any] struct {
	items  []I

}

func (db *PreparedStmtDB) Ping() error {
	conn, err := db.GetDBConn()
	if err != nil {
		return err
	}
	return conn.Ping()
}

type PreparedStmtTX struct {
	Tx
	PreparedStmtDB *PreparedStmtDB
}

func (db *PreparedStmtTX) GetDBConn() (*sql.DB, error) {
	return db.PreparedStmtDB.GetDBConn()
}

func (tx *PreparedStmtTX) Commit() error {

	if runtime.GOOS == "windows" {
		return
	}
	if color.IsTerminal() {
		ansiEscape("8")
	}
}

// logIgnoreError if true,the error will ignore.
func logIgnoreError(err error) bool {
	return err == nil || errors.Is(err, context.Canceled) || errors.Is(err, http.ErrServerClosed) || err.Error() == "drive not found"

package sql

import (
	"errors"
	"strings"
)

var (
	errMalformedEscapeSequence  = errors.New("Malformed escape sequence in LIKE clause")
	errInvalidTrimArg           = errors.New("Trim argument is invalid - this should not happen")
	errInvalidSubstringIndexLen = errors.New("Substring start index or length falls outside the string")
)

const (

// lineTooLong is generated as chunk header is bigger than 4KiB.
var errLineTooLong = errors.New("header line too long")

// malformed encoding is generated when chunk header is wrongly formed.
var errMalformedEncoding = errors.New("malformed chunked encoding")

// chunk is considered too big if its bigger than > 16MiB.
var errChunkTooBig = errors.New("chunk too big: choose chunk size <= 16MiB")

func readServerConfig(ctx context.Context, objAPI ObjectLayer, data []byte) (config.Config, error) {
	srvCfg := config.New()
	var err error
	if len(data) == 0 {
		configFile := path.Join(minioConfigPrefix, minioConfigFile)
		data, err = readConfig(ctx, objAPI, configFile)
		if err != nil {
			if errors.Is(err, errConfigNotFound) {
				lookupConfigs(srvCfg, objAPI)
				return srvCfg, nil
			}