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

internal/pgstreambroker/pgx_helpers.go

@@ -0,0 +1,149 @@
+//go:build !appengine
+
+package pgstreambroker
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"encoding/json"
+	"strconv"
+
+	"github.com/centrifugal/centrifugo/v6/internal/convert"
+)
+
+// byteArena is a chunked arena allocator for byte data. It copies incoming
+// slices into a contiguous buffer and hands back sub-slices (or strings via
+// unsafe conversion). When the current chunk is full a new one is allocated;
+// old chunks stay alive via the slices/strings already referencing them.
+//
+// Copied from internal/pgmapbroker/pgx_helpers.go. Both packages need this
+// for zero-allocation row scanning. A future refactor could extract these
+// helpers into a shared internal package; for now they're duplicated to
+// keep the packages independent.
+type byteArena struct {
+	buf []byte
+}
+
+// copyBytes copies src into the arena and returns a sub-slice of the arena buffer.
+func (a *byteArena) copyBytes(src []byte) []byte {
+	n := len(src)
+	if n == 0 {
+		return nil
+	}
+	if cap(a.buf)-len(a.buf) < n {
+		newCap := 2 * cap(a.buf)
+		if newCap < n {
+			newCap = n
+		}
+		if newCap < 4096 {
+			newCap = 4096
+		}
+		a.buf = make([]byte, 0, newCap)
+	}
+	start := len(a.buf)
+	a.buf = append(a.buf, src...)
+	return a.buf[start : start+n : start+n]
+}
+
+// copyString copies src into the arena and returns a string backed by arena memory.
+func (a *byteArena) copyString(src []byte) string {
+	if len(src) == 0 {
+		return ""
+	}
+	b := a.copyBytes(src)
+	return convert.BytesToString(b)
+}
+
+// pgTextFormat is the pgx text wire format code.
+const pgTextFormat int16 = 0
+
+// pgRawInt64 parses a pgx int8 value as int64.
+func pgRawInt64(b []byte, format int16) int64 {
+	if b == nil {
+		return 0
+	}
+	if format == pgTextFormat {
+		v, _ := strconv.ParseInt(convert.BytesToString(b), 10, 64)
+		return v
+	}
+	return int64(binary.BigEndian.Uint64(b))
+}
+
+// pgRawUint64 parses a pgx int8 value as uint64.
+func pgRawUint64(b []byte, format int16) uint64 {
+	if b == nil {
+		return 0
+	}
+	if format == pgTextFormat {
+		v, _ := strconv.ParseUint(convert.BytesToString(b), 10, 64)
+		return v
+	}
+	return binary.BigEndian.Uint64(b)
+}
+
+// pgRawInt16 parses a pgx int2 (SMALLINT) value as int16.
+// Handles both binary wire format (2-byte big-endian) and text (decimal string).
+func pgRawInt16(b []byte, format int16) int16 {
+	if b == nil {
+		return 0
+	}
+	if format == pgTextFormat {
+		v, _ := strconv.ParseInt(convert.BytesToString(b), 10, 16)
+		return int16(v)
+	}
+	return int16(binary.BigEndian.Uint16(b))
+}
+
+// pgRawString copies a pgx text value into the arena and returns the resulting
+// string. TEXT/VARCHAR have identical representation in both binary and text wire
+// formats, so no format parameter is needed. Returns "" for nil input.
+func pgRawString(a *byteArena, b []byte) string {
+	if b == nil {
+		return ""
+	}
+	return a.copyString(b)
+}
+
+// pgRawBytes copies a pgx BYTEA value into the arena.
+func pgRawBytes(a *byteArena, b []byte, format int16) []byte {
+	if b == nil {
+		return nil
+	}
+	if format == pgTextFormat && len(b) >= 2 && b[0] == '\\' && b[1] == 'x' {
+		decoded := make([]byte, hex.DecodedLen(len(b)-2))
+		n, err := hex.Decode(decoded, b[2:])
+		if err != nil {
+			return a.copyBytes(b) // fallback: copy as-is
+		}
+		return a.copyBytes(decoded[:n])
+	}
+	return a.copyBytes(b)
+}
+
+// pgRawJSONBBytes extracts the JSON body from a pgx JSONB value into the arena.
+func pgRawJSONBBytes(a *byteArena, b []byte, format int16) []byte {
+	if b == nil {
+		return nil
+	}
+	if format != pgTextFormat && len(b) > 1 {
+		return a.copyBytes(b[1:]) // strip version byte
+	}
+	return a.copyBytes(b)
+}
+
+// pgColFormats holds per-column wire format codes extracted from pgx rows.
+type pgColFormats []int16
+
+// pgRawJSONBMap parses a JSONB value into a map[string]string.
+func pgRawJSONBMap(b []byte) map[string]string {
+	if len(b) == 0 {
+		return nil
+	}
+	data := b
+	if len(b) > 1 && b[0] != '{' && b[0] != '[' && b[0] != 'n' {
+		data = b[1:] // skip version byte
+	}
+	var m map[string]string
+	_ = json.Unmarshal(data, &m)
+	return m
+}