string

package
v0.3.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 13, 2026 License: MIT Imports: 18 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var BindAscii = helper.Scalar1(func(a value.Value) (value.Value, error) {
	ascii, err := a.ToString()
	if err != nil {
		return nil, err
	}
	if ascii == "" {
		return value.IntValue(0), nil
	}
	return ASCII(ascii)
})
View Source 
var BindByteLength = helper.Scalar1(func(a value.Value) (value.Value, error) {
	v, err := a.ToBytes()
	if err != nil {
		return nil, err
	}
	return BYTE_LENGTH(v)
})
View Source 
var BindCharLength = helper.Scalar1(func(a value.Value) (value.Value, error) {
	v, err := a.ToBytes()
	if err != nil {
		return nil, err
	}
	return CHAR_LENGTH(v)
})
View Source 
var BindChr = helper.Scalar1(func(a value.Value) (value.Value, error) {
	v, err := a.ToInt64()
	if err != nil {
		return nil, err
	}
	return CHR(v)
})
View Source 
var BindCodePointsToBytes = helper.Scalar1(func(a value.Value) (value.Value, error) {
	v, err := a.ToArray()
	if err != nil {
		return nil, err
	}
	return CODE_POINTS_TO_BYTES(v)
})
View Source 
var BindCodePointsToString = helper.Scalar1(func(a value.Value) (value.Value, error) {
	v, err := a.ToArray()
	if err != nil {
		return nil, err
	}
	return CODE_POINTS_TO_STRING(v)
})
View Source 
var BindConcat = helper.ScalarN(func(args ...value.Value) (value.Value, error) {
	if len(args) < 1 {
		return nil, fmt.Errorf("CONCAT: invalid number of arguments: got %d, want at least 1", len(args))
	}
	return CONCAT(args...)
})
View Source 
var BindContainsSubstr = helper.Scalar2(func(a, b value.Value) (value.Value, error) {
	hay, err := a.ToString()
	if err != nil {
		return nil, err
	}
	needle, err := b.ToString()
	if err != nil {
		return nil, err
	}
	return CONTAINS_SUBSTR(hay, needle)
})
View Source 
var BindEndsWith = helper.Scalar2(ENDS_WITH)
View Source 
var BindFormat = helper.ScalarN(func(args ...value.Value) (value.Value, error) {
	if len(args) == 0 {
		return nil, fmt.Errorf("FORMAT: invalid number of arguments: got %d, want at least 1", len(args))
	}
	format, err := args[0].ToString()
	if err != nil {
		return nil, err
	}
	if len(args) > 1 {
		return FORMAT(format, args[1:]...)
	}
	return FORMAT(format)
})
View Source 
var BindFromBase32 = helper.Scalar1(func(a value.Value) (value.Value, error) {
	v, err := a.ToString()
	if err != nil {
		return nil, err
	}
	return FROM_BASE32(v)
})
View Source 
var BindFromBase64 = helper.Scalar1(func(a value.Value) (value.Value, error) {
	v, err := a.ToString()
	if err != nil {
		return nil, err
	}
	return FROM_BASE64(v)
})
View Source 
var BindFromHex = helper.Scalar1(func(a value.Value) (value.Value, error) {
	v, err := a.ToString()
	if err != nil {
		return nil, err
	}
	return FROM_HEX(v)
})
View Source 
var BindInitcap = helper.ScalarN(func(args ...value.Value) (value.Value, error) {
	if len(args) != 1 && len(args) != 2 {
		return nil, fmt.Errorf("INITCAP: invalid number of arguments: got %d, want 1 or 2", len(args))
	}
	var delimiters []rune
	if len(args) == 2 {
		v, err := args[1].ToString()
		if err != nil {
			return nil, err
		}
		delimiters = []rune{}
		for _, vv := range v {
			delimiters = append(delimiters, vv)
		}
	}
	value, err := args[0].ToString()
	if err != nil {
		return nil, err
	}
	return INITCAP(value, delimiters)
})
View Source 
var BindInstr = helper.ScalarN(func(args ...value.Value) (value.Value, error) {
	if len(args) != 2 && len(args) != 3 && len(args) != 4 {
		return nil, fmt.Errorf("INSTR: invalid number of arguments: got %d, want one of 2, 3, 4", len(args))
	}
	var (
		// Per BigQuery docs, position defaults to 1 (start from the
		// first character). The previous default of 0 tripped the
		// `position > 0` guard in INSTR for 2-arg calls.
		position   int64 = 1
		occurrence int64 = 1
	)
	if len(args) >= 3 {
		pos, err := args[2].ToInt64()
		if err != nil {
			return nil, err
		}
		position = pos
	}
	if len(args) == 4 {
		occur, err := args[3].ToInt64()
		if err != nil {
			return nil, err
		}
		occurrence = occur
	}
	return INSTR(args[0], args[1], position, occurrence)
})
View Source 
var BindLeft = helper.Scalar2(func(a, b value.Value) (value.Value, error) {
	length, err := b.ToInt64()
	if err != nil {
		return nil, err
	}
	return LEFT(a, length)
})
View Source 
var BindLength = helper.Scalar1(LENGTH)
View Source 
var BindLike = helper.Scalar2(LIKE)

BindLike: per GoogleSQL three-valued logic, LIKE with a NULL operand returns NULL, not FALSE — Scalar2 propagates that.

View Source 
var BindLower = helper.Scalar1(LOWER)
View Source 
var BindLpad = helper.ScalarN(func(args ...value.Value) (value.Value, error) {
	if len(args) != 2 && len(args) != 3 {
		return nil, fmt.Errorf("LPAD: invalid number of arguments: got %d, want 2 or 3", len(args))
	}
	var pattern value.Value
	if len(args) == 3 {
		pattern = args[2]
	}
	length, err := args[1].ToInt64()
	if err != nil {
		return nil, err
	}
	return LPAD(args[0], length, pattern)
})
View Source 
var BindLtrim = helper.ScalarN(func(args ...value.Value) (value.Value, error) {
	if len(args) != 1 && len(args) != 2 {
		return nil, fmt.Errorf("LTRIM: invalid number of arguments: got %d, want 1 or 2", len(args))
	}
	cutset := ""
	if len(args) == 2 {
		v, err := args[1].ToString()
		if err != nil {
			return nil, err
		}
		cutset = v
	}
	return LTRIM(args[0], cutset)
})
View Source 
var BindNormalize = helper.ScalarN(func(args ...value.Value) (value.Value, error) {
	if len(args) != 1 && len(args) != 2 {
		return nil, fmt.Errorf("NORMALIZE: invalid number of arguments: got %d, want 1 or 2", len(args))
	}
	mode := "NFC"
	if len(args) == 2 {
		v, err := args[1].ToString()
		if err != nil {
			return nil, err
		}
		mode = v
	}
	v, err := args[0].ToString()
	if err != nil {
		return nil, err
	}
	return NORMALIZE(v, mode)
})
View Source 
var BindNormalizeAndCasefold = helper.ScalarN(func(args ...value.Value) (value.Value, error) {
	if len(args) != 1 && len(args) != 2 {
		return nil, fmt.Errorf("NORMALIZE_AND_CASEFOLD: invalid number of arguments: got %d, want 1 or 2", len(args))
	}
	mode := "NFC"
	if len(args) == 2 {
		v, err := args[1].ToString()
		if err != nil {
			return nil, err
		}
		mode = v
	}
	v, err := args[0].ToString()
	if err != nil {
		return nil, err
	}
	return NORMALIZE_AND_CASEFOLD(v, mode)
})
View Source 
var BindRegexpContains = helper.Scalar2(func(a, b value.Value) (value.Value, error) {
	v, err := a.ToString()
	if err != nil {
		return nil, err
	}
	expr, err := b.ToString()
	if err != nil {
		return nil, err
	}
	return REGEXP_CONTAINS(v, expr)
})
View Source 
var BindRegexpExtract = helper.ScalarN(func(args ...value.Value) (value.Value, error) {
	regexp, err := args[1].ToString()
	if err != nil {
		return nil, err
	}
	var pos int64 = 1
	if len(args) > 2 {
		p, err := args[2].ToInt64()
		if err != nil {
			return nil, err
		}
		pos = p
	}
	var occurrence int64 = 1
	if len(args) > 3 {
		o, err := args[3].ToInt64()
		if err != nil {
			return nil, err
		}
		occurrence = o
	}
	return REGEXP_EXTRACT(args[0], regexp, pos, occurrence)
})
View Source 
var BindRegexpExtractAll = helper.Scalar2(func(a, b value.Value) (value.Value, error) {
	expr, err := b.ToString()
	if err != nil {
		return nil, err
	}
	return REGEXP_EXTRACT_ALL(a, expr)
})
View Source 
var BindRegexpInstr = helper.ScalarN(func(args ...value.Value) (value.Value, error) {
	var (
		pos           int64 = 1
		occurrence    int64 = 1
		occurrencePos int64 = 0
	)
	if len(args) > 2 {
		p, err := args[2].ToInt64()
		if err != nil {
			return nil, err
		}
		pos = p
	}
	if len(args) > 3 {
		o, err := args[3].ToInt64()
		if err != nil {
			return nil, err
		}
		occurrence = o
	}
	if len(args) > 4 {
		p, err := args[4].ToInt64()
		if err != nil {
			return nil, err
		}
		occurrencePos = p
	}
	return REGEXP_INSTR(args[0], args[1], pos, occurrence, occurrencePos)
})
View Source 
var BindRepeat = helper.Scalar2(func(a, b value.Value) (value.Value, error) {
	repetitions, err := b.ToInt64()
	if err != nil {
		return nil, err
	}
	return REPEAT(a, repetitions)
})
View Source 
var BindRight = helper.Scalar2(func(a, b value.Value) (value.Value, error) {
	length, err := b.ToInt64()
	if err != nil {
		return nil, err
	}
	return RIGHT(a, length)
})
View Source 
var BindRpad = helper.ScalarN(func(args ...value.Value) (value.Value, error) {
	length, err := args[1].ToInt64()
	if err != nil {
		return nil, err
	}
	var pat value.Value
	if len(args) > 2 {
		pat = args[2]
	}
	return RPAD(args[0], length, pat)
})
View Source 
var BindRtrim = helper.ScalarN(func(args ...value.Value) (value.Value, error) {
	var cutset = ""
	if len(args) > 1 {
		v, err := args[1].ToString()
		if err != nil {
			return nil, err
		}
		cutset = v
	}
	return RTRIM(args[0], cutset)
})
View Source 
var BindSafeConvertBytesToString = helper.Scalar1(func(a value.Value) (value.Value, error) {
	v, err := a.ToBytes()
	if err != nil {
		return nil, err
	}
	return SAFE_CONVERT_BYTES_TO_STRING(v)
})
View Source 
var BindSoundex = helper.Scalar1(func(a value.Value) (value.Value, error) {
	v, err := a.ToString()
	if err != nil {
		return nil, err
	}
	return SOUNDEX(v)
})
View Source 
var BindStartsWith = helper.Scalar2(STARTS_WITH)
View Source 
var BindStrpos = helper.Scalar2(STRPOS)
View Source 
var BindSubstr = helper.ScalarN(func(args ...value.Value) (value.Value, error) {
	if len(args) != 2 && len(args) != 3 {
		return nil, fmt.Errorf("SUBSTR: invalid number of arguments: got %d, want 2 or 3", len(args))
	}
	pos, err := args[1].ToInt64()
	if err != nil {
		return nil, err
	}
	var length *int64
	if len(args) == 3 {
		v, err := args[2].ToInt64()
		if err != nil {
			return nil, err
		}
		length = &v
	}
	return SUBSTR(args[0], pos, length)
})
View Source 
var BindToBase32 = helper.Scalar1(func(a value.Value) (value.Value, error) {
	b, err := a.ToBytes()
	if err != nil {
		return nil, err
	}
	return TO_BASE32(b)
})
View Source 
var BindToBase64 = helper.Scalar1(func(a value.Value) (value.Value, error) {
	b, err := a.ToBytes()
	if err != nil {
		return nil, err
	}
	return TO_BASE64(b)
})
View Source 
var BindToHex = helper.Scalar1(func(a value.Value) (value.Value, error) {
	b, err := a.ToBytes()
	if err != nil {
		return nil, err
	}
	return TO_HEX(b)
})
View Source 
var BindTranslate = helper.Scalar3(TRANSLATE)
View Source 
var BindTrim = helper.ScalarN(func(args ...value.Value) (value.Value, error) {
	if len(args) != 1 && len(args) != 2 {
		return nil, fmt.Errorf("TRIM: invalid number of arguments: got %d, want 1 or 2", len(args))
	}
	if len(args) == 2 {
		return TRIM(args[0], args[1])
	}
	return TRIM(args[0], nil)
})
View Source 
var BindUnicode = helper.Scalar1(func(a value.Value) (value.Value, error) {
	v, err := a.ToString()
	if err != nil {
		return nil, err
	}
	return UNICODE(v)
})
View Source 
var BindUpper = helper.Scalar1(UPPER)

Functions

func ASCII 

func ASCII(v string) (value.Value, error)

func BYTE_LENGTH 

func BYTE_LENGTH(v []byte) (value.Value, error)

func BindCollate 

func BindCollate(args ...value.Value) (value.Value, error)

func BindEditDistance 

func BindEditDistance(args ...value.Value) (value.Value, error)

func BindSplit 

func BindSplit(args ...value.Value) (value.Value, error)

func BindToCodePoints 

func BindToCodePoints(args ...value.Value) (value.Value, error)

func CHAR_LENGTH 

func CHAR_LENGTH(v []byte) (value.Value, error)

func CHR 

func CHR(v int64) (value.Value, error)

func CODE_POINTS_TO_BYTES 

func CODE_POINTS_TO_BYTES(v *value.ArrayValue) (value.Value, error)

func CODE_POINTS_TO_STRING 

func CODE_POINTS_TO_STRING(v *value.ArrayValue) (value.Value, error)

func COLLATE 

func COLLATE(v, spec string) (value.Value, error)

func CONCAT 

func CONCAT(args ...value.Value) (value.Value, error)

func CONTAINS_SUBSTR 

func CONTAINS_SUBSTR(haystack, needle string) (value.Value, error)

CONTAINS_SUBSTR is the BigQuery substring search. Per BQ docs the match is case-insensitive, NFKC-normalised. We approximate via strings.EqualFold-style ASCII case folding, which covers the overwhelming majority of real call sites; full NFKC normalisation is a follow-up.

Returns NULL if either operand is NULL. Returns BOOL otherwise.

func EDIT_DISTANCE 

func EDIT_DISTANCE(a, b string) (value.Value, error)

EDIT_DISTANCE computes the Levenshtein distance between two strings. Counted in Unicode code points, matching BigQuery's default (byte_semantics => FALSE). The optional max_distance / byte_semantics named arguments are not yet wired through the analyzer; they are follow-ups.

func ENDS_WITH 

func ENDS_WITH(val, ends value.Value) (value.Value, error)

func FORMAT 

func FORMAT(format string, args ...value.Value) (value.Value, error)

func FROM_BASE32 

func FROM_BASE32(v string) (value.Value, error)

func FROM_BASE64 

func FROM_BASE64(v string) (value.Value, error)

func FROM_HEX 

func FROM_HEX(v string) (value.Value, error)

func INITCAP 

func INITCAP(val string, delimiters []rune) (value.Value, error)

func INSTR 

func INSTR(source, search value.Value, position, occurrence int64) (value.Value, error)

func LEFT 

func LEFT(v value.Value, length int64) (value.Value, error)

func LENGTH 

func LENGTH(v value.Value) (value.Value, error)

func LIKE 

func LIKE(a, b value.Value) (value.Value, error)

func LOWER 

func LOWER(v value.Value) (value.Value, error)

func LPAD 

func LPAD(originalValue value.Value, returnLength int64, pattern value.Value) (value.Value, error)

func LTRIM 

func LTRIM(v value.Value, cutset string) (value.Value, error)

LTRIM trims characters from the left. cutset == "" means: strip the full Unicode whitespace class for STRING (ASCII whitespace for BYTES).

func NORMALIZE 

func NORMALIZE(v, mode string) (value.Value, error)

func NORMALIZE_AND_CASEFOLD 

func NORMALIZE_AND_CASEFOLD(v, mode string) (value.Value, error)

func REGEXP_CONTAINS 

func REGEXP_CONTAINS(val, expr string) (value.Value, error)

func REGEXP_EXTRACT 

func REGEXP_EXTRACT(val value.Value, expr string, position, occurrence int64) (value.Value, error)

func REGEXP_EXTRACT_ALL 

func REGEXP_EXTRACT_ALL(val value.Value, expr string) (value.Value, error)

func REGEXP_INSTR 

func REGEXP_INSTR(sourceValue, exprValue value.Value, position, occurrence, occurrencePos int64) (value.Value, error)

func REGEXP_REPLACE 

func REGEXP_REPLACE(val, exprValue, replacementValue value.Value) (value.Value, error)

func REPEAT 

func REPEAT(originalValue value.Value, repetitions int64) (value.Value, error)

func REPLACE 

func REPLACE(originalValue, fromValue, toValue value.Value) (value.Value, error)

func REVERSE 

func REVERSE(val value.Value) (value.Value, error)
func RIGHT(val value.Value, length int64) (value.Value, error)

func RPAD 

func RPAD(originalValue value.Value, returnLength int64, pattern value.Value) (value.Value, error)

func RTRIM 

func RTRIM(val value.Value, cutset string) (value.Value, error)

RTRIM trims characters from the right. cutset == "" means: strip the full Unicode whitespace class for STRING (ASCII whitespace for BYTES).

func SAFE_CONVERT_BYTES_TO_STRING 

func SAFE_CONVERT_BYTES_TO_STRING(val []byte) (value.Value, error)

func SOUNDEX 

func SOUNDEX(val string) (value.Value, error)

func SPLIT 

func SPLIT(val, delimValue value.Value) (value.Value, error)

func STARTS_WITH 

func STARTS_WITH(val, starts value.Value) (value.Value, error)

func STRPOS 

func STRPOS(val, search value.Value) (value.Value, error)

func SUBSTR 

func SUBSTR(val value.Value, pos int64, length *int64) (value.Value, error)

func TO_BASE32 

func TO_BASE32(v []byte) (value.Value, error)

func TO_BASE64 

func TO_BASE64(v []byte) (value.Value, error)

func TO_CODE_POINTS 

func TO_CODE_POINTS(v value.Value) (value.Value, error)

func TO_HEX 

func TO_HEX(v []byte) (value.Value, error)

func TRANSLATE 

func TRANSLATE(expr, source, target value.Value) (value.Value, error)

func TRIM 

func TRIM(v, cutsetV value.Value) (value.Value, error)

func UNICODE 

func UNICODE(v string) (value.Value, error)

func UPPER 

func UPPER(v value.Value) (value.Value, error)

Types

type FormatContext 

type FormatContext struct {
	// contains filtered or unexported fields
}

type FormatFlag 

type FormatFlag int
const (
	FormatFlagNone  FormatFlag = 0
	FormatFlagMinus FormatFlag = 1
	FormatFlagPlus  FormatFlag = 2
	FormatFlagSpace FormatFlag = 3
	FormatFlagSharp FormatFlag = 4
	FormatFlagZero  FormatFlag = 5
	FormatFlagQuote FormatFlag = 6
)

type FormatInfo 

type FormatInfo struct {
	// contains filtered or unexported fields
}

type FormatParam 

type FormatParam struct {
	// contains filtered or unexported fields
}

type FormatPrecision 

type FormatPrecision struct {
	// contains filtered or unexported fields
}

type FormatWidth 

type FormatWidth struct {
	// contains filtered or unexported fields
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.