You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 

329 lines
8.3 KiB

// 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
}