// Copyright 2015 PingCAP, Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // See the License for the specific language governing permissions and // limitations under the License. package stringutil import ( "bytes" "fmt" "strings" "unicode/utf8" "github.com/pingcap/errors" "github.com/pingcap/parser/mysql" "github.com/pingcap/tidb/util/hack" ) // ErrSyntax indicates that a value does not have the right syntax for the target type. var ErrSyntax = errors.New("invalid syntax") // UnquoteChar decodes the first character or byte in the escaped string // or character literal represented by the string s. // It returns four values: // // 1) value, the decoded Unicode code point or byte value; // 2) multibyte, a boolean indicating whether the decoded character requires a multibyte UTF-8 representation; // 3) tail, the remainder of the string after the character; and // 4) an error that will be nil if the character is syntactically valid. // // The second argument, quote, specifies the type of literal being parsed // and therefore which escaped quote character is permitted. // If set to a single quote, it permits the sequence \' and disallows unescaped '. // If set to a double quote, it permits \" and disallows unescaped ". // If set to zero, it does not permit either escape and allows both quote characters to appear unescaped. // Different with strconv.UnquoteChar, it permits unnecessary backslash. func UnquoteChar(s string, quote byte) (value []byte, tail string, err error) { // easy cases switch c := s[0]; { case c == quote: err = errors.Trace(ErrSyntax) return case c >= utf8.RuneSelf: r, size := utf8.DecodeRuneInString(s) if r == utf8.RuneError { value = append(value, c) return value, s[1:], nil } value = append(value, string(r)...) return value, s[size:], nil case c != '\\': value = append(value, c) return value, s[1:], nil } // hard case: c is backslash if len(s) <= 1 { err = errors.Trace(ErrSyntax) return } c := s[1] s = s[2:] switch c { case 'b': value = append(value, '\b') case 'n': value = append(value, '\n') case 'r': value = append(value, '\r') case 't': value = append(value, '\t') case 'Z': value = append(value, '\032') case '0': value = append(value, '\000') case '_', '%': value = append(value, '\\') value = append(value, c) case '\\': value = append(value, '\\') case '\'', '"': value = append(value, c) default: value = append(value, c) } tail = s return } // Unquote interprets s as a single-quoted, double-quoted, // or backquoted Go string literal, returning the string value // that s quotes. For example: test=`"\"\n"` (hex: 22 5c 22 5c 6e 22) // should be converted to `"\n` (hex: 22 0a). func Unquote(s string) (t string, err error) { n := len(s) if n < 2 { return "", errors.Trace(ErrSyntax) } quote := s[0] if quote != s[n-1] { return "", errors.Trace(ErrSyntax) } s = s[1 : n-1] if quote != '"' && quote != '\'' { return "", errors.Trace(ErrSyntax) } // Avoid allocation. No need to convert if there is no '\' if strings.IndexByte(s, '\\') == -1 && strings.IndexByte(s, quote) == -1 { return s, nil } buf := make([]byte, 0, 3*len(s)/2) // Try to avoid more allocations. for len(s) > 0 { mb, ss, err := UnquoteChar(s, quote) if err != nil { return "", errors.Trace(err) } s = ss buf = append(buf, mb...) } return string(buf), nil } const ( // PatMatch is the enumeration value for per-character match. PatMatch = iota + 1 // PatOne is the enumeration value for '_' match. PatOne // PatAny is the enumeration value for '%' match. PatAny ) // CompilePattern handles escapes and wild cards convert pattern characters and // pattern types. func CompilePattern(pattern string, escape byte) (patChars, patTypes []byte) { var lastAny bool patChars = make([]byte, len(pattern)) patTypes = make([]byte, len(pattern)) patLen := 0 for i := 0; i < len(pattern); i++ { var tp byte var c = pattern[i] switch c { case escape: lastAny = false tp = PatMatch if i < len(pattern)-1 { i++ c = pattern[i] if c == escape || c == '_' || c == '%' { // Valid escape. } else { // Invalid escape, fall back to escape byte. // mysql will treat escape character as the origin value even // the escape sequence is invalid in Go or C. // e.g., \m is invalid in Go, but in MySQL we will get "m" for select '\m'. // Following case is correct just for escape \, not for others like +. // TODO: Add more checks for other escapes. i-- c = escape } } case '_': if lastAny { continue } tp = PatOne case '%': if lastAny { continue } lastAny = true tp = PatAny default: lastAny = false tp = PatMatch } patChars[patLen] = c patTypes[patLen] = tp patLen++ } patChars = patChars[:patLen] patTypes = patTypes[:patLen] return } func matchByte(a, b byte) bool { return a == b // We may reuse below code block when like function go back to case insensitive. /* if a == b { return true } if a >= 'a' && a <= 'z' && a-caseDiff == b { return true } return a >= 'A' && a <= 'Z' && a+caseDiff == b */ } // CompileLike2Regexp convert a like `lhs` to a regular expression func CompileLike2Regexp(str string) string { patChars, patTypes := CompilePattern(str, '\\') var result []byte for i := 0; i < len(patChars); i++ { switch patTypes[i] { case PatMatch: result = append(result, patChars[i]) case PatOne: // .*. == .* if !bytes.HasSuffix(result, []byte{'.', '*'}) { result = append(result, '.') } case PatAny: // ..* == .* if bytes.HasSuffix(result, []byte{'.'}) { result = append(result, '*') continue } // .*.* == .* if !bytes.HasSuffix(result, []byte{'.', '*'}) { result = append(result, '.') result = append(result, '*') } } } return string(result) } // DoMatch matches the string with patChars and patTypes. // The algorithm has linear time complexity. // https://research.swtch.com/glob func DoMatch(str string, patChars, patTypes []byte) bool { var sIdx, pIdx, nextSIdx, nextPIdx int for pIdx < len(patChars) || sIdx < len(str) { if pIdx < len(patChars) { switch patTypes[pIdx] { case PatMatch: if sIdx < len(str) && matchByte(str[sIdx], patChars[pIdx]) { pIdx++ sIdx++ continue } case PatOne: if sIdx < len(str) { pIdx++ sIdx++ continue } case PatAny: // Try to match at sIdx. // If that doesn't work out, // restart at sIdx+1 next. nextPIdx = pIdx nextSIdx = sIdx + 1 pIdx++ continue } } // Mismatch. Maybe restart. if 0 < nextSIdx && nextSIdx <= len(str) { pIdx = nextPIdx sIdx = nextSIdx continue } return false } // Matched all of pattern to all of name. Success. return true } // IsExactMatch return true if no wildcard character func IsExactMatch(patTypes []byte) bool { for _, pt := range patTypes { if pt != PatMatch { return false } } return true } // Copy deep copies a string. func Copy(src string) string { return string(hack.Slice(src)) } // StringerFunc defines string func implement fmt.Stringer. type StringerFunc func() string // String implements fmt.Stringer func (l StringerFunc) String() string { return l() } // MemoizeStr returns memoized version of stringFunc. func MemoizeStr(l func() string) fmt.Stringer { return StringerFunc(func() string { return l() }) } // StringerStr defines a alias to normal string. // implement fmt.Stringer type StringerStr string // String implements fmt.Stringer func (i StringerStr) String() string { return string(i) } // Escape the identifier for pretty-printing. // For instance, the identifier "foo `bar`" will become "`foo “bar```". // The sqlMode controls whether to escape with backquotes (`) or double quotes // (`"`) depending on whether mysql.ModeANSIQuotes is enabled. func Escape(str string, sqlMode mysql.SQLMode) string { var quote string if sqlMode&mysql.ModeANSIQuotes != 0 { quote = `"` } else { quote = "`" } return quote + strings.Replace(str, quote, quote+quote, -1) + quote }