snapshot of https://github.com/mattermost/mattermost.git (master, 2026-09-16; blobs > 131072B omitted)

server/channels/store/sqlstore/utils.go

@@ -0,0 +1,252 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package sqlstore
+
+import (
+	"database/sql"
+	"errors"
+	"fmt"
+	"io"
+	"maps"
+	"net/url"
+	"strconv"
+	"strings"
+	"unicode"
+
+	"github.com/wiggin77/merror"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/mlog"
+)
+
+// defaultMaxInsertParams is a conservative threshold (76% of PostgreSQL's
+// 65,535 parameter limit) used to chunk bulk INSERT statements so they never
+// overflow the wire-protocol's 16-bit parameter counter.
+const defaultMaxInsertParams = 50_000
+
+// chunkSlice splits items into sub-slices sized so that each chunk uses at most
+// maxParams query parameters (columnsPerRow params per item). When the input
+// already fits in one chunk the original slice is returned with zero allocation
+// overhead.
+func chunkSlice[T any](items []T, columnsPerRow int, maxParams int) [][]T {
+	if columnsPerRow <= 0 {
+		panic(fmt.Sprintf("chunkSlice: columnsPerRow must be > 0, got %d", columnsPerRow))
+	}
+	if maxParams <= 0 {
+		panic(fmt.Sprintf("chunkSlice: maxParams must be > 0, got %d", maxParams))
+	}
+	if columnsPerRow > maxParams {
+		panic(fmt.Sprintf("chunkSlice: columnsPerRow (%d) must be <= maxParams (%d)", columnsPerRow, maxParams))
+	}
+	if len(items) == 0 {
+		return nil
+	}
+	chunkSize := maxParams / columnsPerRow
+	if len(items) <= chunkSize {
+		return [][]T{items}
+	}
+	var chunks [][]T
+	for i := 0; i < len(items); i += chunkSize {
+		end := min(i+chunkSize, len(items))
+		chunks = append(chunks, items[i:end])
+	}
+	return chunks
+}
+
+var escapeLikeSearchChar = []string{
+	"%",
+	"_",
+}
+
+func sanitizeSearchTerm(term string, escapeChar string) string {
+	term = strings.Replace(term, escapeChar, "", -1)
+
+	for _, c := range escapeLikeSearchChar {
+		term = strings.Replace(term, c, escapeChar+c, -1)
+	}
+
+	return term
+}
+
+// Converts a list of strings into a list of query parameters and a named parameter map that can
+// be used as part of a SQL query.
+func MapStringsToQueryParams(list []string, paramPrefix string) (string, map[string]any) {
+	var keys strings.Builder
+	params := make(map[string]any, len(list))
+	for i, entry := range list {
+		if keys.Len() > 0 {
+			keys.WriteString(",")
+		}
+
+		key := paramPrefix + strconv.Itoa(i)
+		keys.WriteString(":" + key)
+		params[key] = entry
+	}
+
+	return "(" + keys.String() + ")", params
+}
+
+// finalizeTransactionX ensures a transaction is closed after use, rolling back if not already committed.
+func finalizeTransactionX(transaction *sqlxTxWrapper, perr *error) {
+	// Rollback returns sql.ErrTxDone if the transaction was already closed.
+	if err := transaction.Rollback(); err != nil && !errors.Is(err, sql.ErrTxDone) {
+		*perr = merror.Append(*perr, err)
+	}
+}
+
+func deferClose(c io.Closer, perr *error) {
+	err := c.Close()
+	*perr = merror.Append(*perr, err)
+}
+
+// removeNonAlphaNumericUnquotedTerms removes all unquoted words that only contain
+// non-alphanumeric chars from given line
+func removeNonAlphaNumericUnquotedTerms(line, separator string) string {
+	words := strings.Split(line, separator)
+	filteredResult := make([]string, 0, len(words))
+
+	for _, w := range words {
+		if isQuotedWord(w) || containsAlphaNumericChar(w) {
+			filteredResult = append(filteredResult, strings.TrimSpace(w))
+		}
+	}
+	return strings.Join(filteredResult, separator)
+}
+
+// containsAlphaNumericChar returns true in case any letter or digit is present, false otherwise
+func containsAlphaNumericChar(s string) bool {
+	for _, r := range s {
+		if unicode.IsLetter(r) || unicode.IsDigit(r) {
+			return true
+		}
+	}
+	return false
+}
+
+// isQuotedWord return true if the input string is quoted, false otherwise. Ex :-
+//
+//	"quoted string"  -  will return true
+//	unquoted string  -  will return false
+func isQuotedWord(s string) bool {
+	if len(s) < 2 {
+		return false
+	}
+
+	return s[0] == '"' && s[len(s)-1] == '"'
+}
+
+func constructArrayArgs(ids []string) (string, []any) {
+	var placeholder strings.Builder
+	values := make([]any, 0, len(ids))
+	for _, entry := range ids {
+		if placeholder.Len() > 0 {
+			placeholder.WriteString(",")
+		}
+
+		placeholder.WriteString("?")
+		values = append(values, entry)
+	}
+
+	return "(" + placeholder.String() + ")", values
+}
+
+func wrapBinaryParamStringMap(ok bool, props model.StringMap) model.StringMap {
+	if props == nil {
+		props = make(model.StringMap)
+	}
+	props[model.BinaryParamKey] = strconv.FormatBool(ok)
+	return props
+}
+
+// morphWriter is a target to pass to the logger instance of morph.
+// For now, everything is just logged at a debug level. If we need to log
+// errors/warnings from the library also, that needs to be seen later.
+type morphWriter struct{}
+
+func (l *morphWriter) Write(in []byte) (int, error) {
+	mlog.Debug(strings.TrimSpace(string(in)))
+	return len(in), nil
+}
+
+func DSNHasBinaryParam(dsn string) (bool, error) {
+	url, err := url.Parse(dsn)
+	if err != nil {
+		return false, err
+	}
+	return url.Query().Get("binary_parameters") == "yes", nil
+}
+
+// AppendBinaryFlag updates the byte slice to work using binary_parameters=yes.
+func AppendBinaryFlag(buf []byte) []byte {
+	return append([]byte{0x01}, buf...)
+}
+
+const maxTokenSize = 50
+
+// trimInput limits the string to a max size to prevent clogging up disk space
+// while logging
+func trimInput(input string) string {
+	if len(input) > maxTokenSize {
+		input = input[:maxTokenSize] + "..."
+	}
+	return input
+}
+
+// rowScanner is the minimal interface needed to iterate over SQL result rows.
+type rowScanner interface {
+	Next() bool
+	Scan(dest ...any) error
+	Err() error
+}
+
+// neutralizeNonWordHyphens replaces any '-' that isn't flanked by a word
+// rune (letter or digit) on both sides with a space, so malformed hyphen
+// usage (leading/trailing/standalone/repeated) can't reach to_tsquery, while
+// compound words like "t-shirt" are preserved.
+func neutralizeNonWordHyphens(s string) string {
+	if !strings.ContainsRune(s, '-') {
+		return s
+	}
+	runes := []rune(s)
+	for i, r := range runes {
+		if r != '-' {
+			continue
+		}
+		hasLeft := i > 0 && isWordRune(runes[i-1])
+		hasRight := i < len(runes)-1 && isWordRune(runes[i+1])
+		if !hasLeft || !hasRight {
+			runes[i] = ' '
+		}
+	}
+	return string(runes)
+}
+
+// isWordRune reports whether r can be part of a word for hyphen-flanking
+// purposes. Combining marks (e.g. a decomposed accent) count too, since they
+// attach to the preceding base letter rather than acting as a boundary.
+func isWordRune(r rune) bool {
+	return unicode.IsLetter(r) || unicode.IsDigit(r) || unicode.IsMark(r)
+}
+
+// scanRowsIntoMap scans SQL rows into a map, using a provided scanner function to extract key-value pairs
+func scanRowsIntoMap[K comparable, V any](rows rowScanner, scanner func(rows rowScanner) (K, V, error), defaults map[K]V) (map[K]V, error) {
+	results := make(map[K]V, len(defaults))
+
+	// Initialize with default values if provided
+	maps.Copy(results, defaults)
+
+	for rows.Next() {
+		key, value, err := scanner(rows)
+		if err != nil {
+			return nil, err
+		}
+		results[key] = value
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("error while iterating rows: %w", err)
+	}
+
+	return results, nil
+}