forgejo-federation/vendor/github.com/pingcap/tidb/parser/scanner.l
Thomas Boerger b6a95a8cb3 Integrate public as bindata optionally (#293)
* Dropped unused codekit config

* Integrated dynamic and static bindata for public

* Ignore public bindata

* Add a general generate make task

* Integrated flexible public assets into web command

* Updated vendoring, added all missiong govendor deps

* Made the linter happy with the bindata and dynamic code

* Moved public bindata definition to modules directory

* Ignoring the new bindata path now

* Updated to the new public modules import path

* Updated public bindata command and drop the new prefix
2016-11-30 00:26:36 +08:00

1259 lines
29 KiB
Text

%{
// Copyright 2013 The ql Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSES/QL-LICENSE file.
// 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 parser
import (
"fmt"
"math"
"strconv"
"strings"
"unicode"
"github.com/pingcap/tidb/ast"
"github.com/pingcap/tidb/mysql"
"github.com/pingcap/tidb/util/charset"
"github.com/pingcap/tidb/util/stringutil"
)
type lexer struct {
c int
col int
errs []error
expr ast.ExprNode
i int
inj int
lcol int
line int
list []ast.StmtNode
ncol int
nline int
sc int
src string
val []byte
ungetBuf []byte
root bool
prepare bool
stmtStartPos int
stringLit []byte
// record token's offset of the input
tokenEndOffset int
tokenStartOffset int
// Charset information
charset string
collation string
}
// NewLexer builds a new lexer.
func NewLexer(src string) (l *lexer) {
l = &lexer{
src: src,
nline: 1,
ncol: 0,
}
l.next()
return
}
func (l *lexer) Errors() []error {
return l.errs
}
func (l *lexer) Stmts() []ast.StmtNode {
return l.list
}
func (l *lexer) Expr() ast.ExprNode {
return l.expr
}
func (l *lexer) Inj() int {
return l.inj
}
func (l *lexer) SetInj(inj int) {
l.inj = inj
}
func (l *lexer) SetPrepare() {
l.prepare = true
}
func (l *lexer) IsPrepare() bool {
return l.prepare
}
func (l *lexer) Root() bool {
return l.root
}
func (l *lexer) SetRoot(root bool) {
l.root = root
}
func (l *lexer) SetCharsetInfo(charset, collation string) {
l.charset = charset
l.collation = collation
}
func (l *lexer) GetCharsetInfo() (string, string) {
return l.charset, l.collation
}
// The select statement is not at the end of the whole statement, if the last
// field text was set from its offset to the end of the src string, update
// the last field text.
func (l *lexer) SetLastSelectFieldText(st *ast.SelectStmt, lastEnd int) {
lastField := st.Fields.Fields[len(st.Fields.Fields)-1]
if lastField.Offset + len(lastField.Text()) >= len(l.src)-1 {
lastField.SetText(l.src[lastField.Offset:lastEnd])
}
}
func (l *lexer) startOffset(offset int) int {
offset--
for unicode.IsSpace(rune(l.src[offset])) {
offset++
}
return offset
}
func (l *lexer) endOffset(offset int) int {
offset--
for offset > 0 && unicode.IsSpace(rune(l.src[offset-1])) {
offset--
}
return offset
}
func (l *lexer) unget(b byte) {
l.ungetBuf = append(l.ungetBuf, b)
l.i--
l.ncol--
l.tokenEndOffset--
}
func (l *lexer) next() int {
if un := len(l.ungetBuf); un > 0 {
nc := l.ungetBuf[0]
l.ungetBuf = l.ungetBuf[1:]
l.c = int(nc)
return l.c
}
if l.c != 0 {
l.val = append(l.val, byte(l.c))
}
l.c = 0
if l.i < len(l.src) {
l.c = int(l.src[l.i])
l.i++
}
switch l.c {
case '\n':
l.lcol = l.ncol
l.nline++
l.ncol = 0
default:
l.ncol++
}
l.tokenEndOffset++
return l.c
}
func (l *lexer) err0(ln, c int, arg interface{}) {
var argStr string
if arg != nil {
argStr = fmt.Sprintf(" %v", arg)
}
err := fmt.Errorf("line %d column %d near \"%s\"%s", ln, c, l.val, argStr)
l.errs = append(l.errs, err)
}
func (l *lexer) err(arg interface{}) {
l.err0(l.line, l.col, arg)
}
func (l *lexer) errf(format string, args ...interface{}) {
s := fmt.Sprintf(format, args...)
l.err0(l.line, l.col, s)
}
func (l *lexer) Error(s string) {
// Notice: ignore origin error info.
l.err(nil)
}
func (l *lexer) stmtText() string {
endPos := l.i
if l.src[l.i-1] == '\n' {
endPos = l.i-1 // trim new line
}
if l.src[l.stmtStartPos] == '\n' {
l.stmtStartPos++
}
text := l.src[l.stmtStartPos:endPos]
l.stmtStartPos = l.i
return text
}
func (l *lexer) Lex(lval *yySymType) (r int) {
defer func() {
lval.line, lval.col, lval.offset = l.line, l.col, l.tokenStartOffset
l.tokenStartOffset = l.tokenEndOffset
}()
const (
INITIAL = iota
S1
S2
S3
S4
)
if n := l.inj; n != 0 {
l.inj = 0
return n
}
c0, c := 0, l.c
%}
int_lit {decimal_lit}|{octal_lit}
decimal_lit [1-9][0-9]*
octal_lit 0[0-7]*
hex_lit 0[xX][0-9a-fA-F]+|[xX]"'"[0-9a-fA-F]+"'"
bit_lit 0[bB][01]+|[bB]"'"[01]+"'"
float_lit {D}"."{D}?{E}?|{D}{E}|"."{D}{E}?
D [0-9]+
E [eE][-+]?[0-9]+
imaginary_ilit {D}i
imaginary_lit {float_lit}i
a [aA]
b [bB]
c [cC]
d [dD]
e [eE]
f [fF]
g [gG]
h [hH]
i [iI]
j [jJ]
k [kK]
l [lL]
m [mM]
n [nN]
o [oO]
p [pP]
q [qQ]
r [rR]
s [sS]
t [tT]
u [uU]
v [vV]
w [wW]
x [xX]
y [yY]
z [zZ]
abs {a}{b}{s}
add {a}{d}{d}
adddate {a}{d}{d}{d}{a}{t}{e}
admin {a}{d}{m}{i}{n}
after {a}{f}{t}{e}{r}
all {a}{l}{l}
alter {a}{l}{t}{e}{r}
and {a}{n}{d}
any {a}{n}{y}
as {a}{s}
asc {a}{s}{c}
auto_increment {a}{u}{t}{o}_{i}{n}{c}{r}{e}{m}{e}{n}{t}
avg {a}{v}{g}
avg_row_length {a}{v}{g}_{r}{o}{w}_{l}{e}{n}{g}{t}{h}
begin {b}{e}{g}{i}{n}
between {b}{e}{t}{w}{e}{e}{n}
both {b}{o}{t}{h}
btree {b}{t}{r}{e}{e}
by {b}{y}
case {c}{a}{s}{e}
cast {c}{a}{s}{t}
character {c}{h}{a}{r}{a}{c}{t}{e}{r}
charset {c}{h}{a}{r}{s}{e}{t}
check {c}{h}{e}{c}{k}
checksum {c}{h}{e}{c}{k}{s}{u}{m}
coalesce {c}{o}{a}{l}{e}{s}{c}{e}
collate {c}{o}{l}{l}{a}{t}{e}
collation {c}{o}{l}{l}{a}{t}{i}{o}{n}
column {c}{o}{l}{u}{m}{n}
columns {c}{o}{l}{u}{m}{n}{s}
comment {c}{o}{m}{m}{e}{n}{t}
commit {c}{o}{m}{m}{i}{t}
committed {c}{o}{m}{m}{i}{t}{t}{e}{d}
compact {c}{o}{m}{p}{a}{c}{t}
compressed {c}{o}{m}{p}{r}{e}{s}{s}{e}{d}
compression {c}{o}{m}{p}{r}{e}{s}{s}{i}{o}{n}
concat {c}{o}{n}{c}{a}{t}
concat_ws {c}{o}{n}{c}{a}{t}_{w}{s}
connection {c}{o}{n}{n}{e}{c}{t}{i}{o}{n}
connection_id {c}{o}{n}{n}{e}{c}{t}{i}{o}{n}_{i}{d}
constraint {c}{o}{n}{s}{t}{r}{a}{i}{n}{t}
convert {c}{o}{n}{v}{e}{r}{t}
count {c}{o}{u}{n}{t}
create {c}{r}{e}{a}{t}{e}
cross {c}{r}{o}{s}{s}
curdate {c}{u}{r}{d}{a}{t}{e}
current_date {c}{u}{r}{r}{e}{n}{t}_{d}{a}{t}{e}
curtime {c}{u}{r}{t}{i}{m}{e}
current_time {c}{u}{r}{r}{e}{n}{t}_{t}{i}{m}{e}
current_user {c}{u}{r}{r}{e}{n}{t}_{u}{s}{e}{r}
database {d}{a}{t}{a}{b}{a}{s}{e}
databases {d}{a}{t}{a}{b}{a}{s}{e}{s}
date_add {d}{a}{t}{e}_{a}{d}{d}
date_sub {d}{a}{t}{e}_{s}{u}{b}
day {d}{a}{y}
dayname {d}{a}{y}{n}{a}{m}{e}
dayofweek {d}{a}{y}{o}{f}{w}{e}{e}{k}
dayofmonth {d}{a}{y}{o}{f}{m}{o}{n}{t}{h}
dayofyear {d}{a}{y}{o}{f}{y}{e}{a}{r}
ddl {d}{d}{l}
deallocate {d}{e}{a}{l}{l}{o}{c}{a}{t}{e}
default {d}{e}{f}{a}{u}{l}{t}
delayed {d}{e}{l}{a}{y}{e}{d}
delay_key_write {d}{e}{l}{a}{y}_{k}{e}{y}_{w}{r}{i}{t}{e}
delete {d}{e}{l}{e}{t}{e}
drop {d}{r}{o}{p}
desc {d}{e}{s}{c}
describe {d}{e}{s}{c}{r}{i}{b}{e}
distinct {d}{i}{s}{t}{i}{n}{c}{t}
div {d}{i}{v}
do {d}{o}
dual {d}{u}{a}{l}
duplicate {d}{u}{p}{l}{i}{c}{a}{t}{e}
dynamic {d}{y}{n}{a}{m}{i}{c}
else {e}{l}{s}{e}
end {e}{n}{d}
engine {e}{n}{g}{i}{n}{e}
engines {e}{n}{g}{i}{n}{e}{s}
escape {e}{s}{c}{a}{p}{e}
execute {e}{x}{e}{c}{u}{t}{e}
exists {e}{x}{i}{s}{t}{s}
explain {e}{x}{p}{l}{a}{i}{n}
extract {e}{x}{t}{r}{a}{c}{t}
fields {f}{i}{e}{l}{d}{s}
first {f}{i}{r}{s}{t}
fixed {f}{i}{x}{e}{d}
for {f}{o}{r}
foreign {f}{o}{r}{e}{i}{g}{n}
found_rows {f}{o}{u}{n}{d}_{r}{o}{w}{s}
from {f}{r}{o}{m}
full {f}{u}{l}{l}
fulltext {f}{u}{l}{l}{t}{e}{x}{t}
global {g}{l}{o}{b}{a}{l}
grant {g}{r}{a}{n}{t}
grants {g}{r}{a}{n}{t}{s}
group {g}{r}{o}{u}{p}
group_concat {g}{r}{o}{u}{p}_{c}{o}{n}{c}{a}{t}
hash {h}{a}{s}{h}
having {h}{a}{v}{i}{n}{g}
high_priority {h}{i}{g}{h}_{p}{r}{i}{o}{r}{i}{t}{y}
hour {h}{o}{u}{r}
identified {i}{d}{e}{n}{t}{i}{f}{i}{e}{d}
if {i}{f}
ifnull {i}{f}{n}{u}{l}{l}
ignore {i}{g}{n}{o}{r}{e}
in {i}{n}
index {i}{n}{d}{e}{x}
inner {i}{n}{n}{e}{r}
insert {i}{n}{s}{e}{r}{t}
interval {i}{n}{t}{e}{r}{v}{a}{l}
into {i}{n}{t}{o}
is {i}{s}
isolation {i}{s}{o}{l}{a}{t}{i}{o}{n}
join {j}{o}{i}{n}
key {k}{e}{y}
key_block_size {k}{e}{y}_{b}{l}{o}{c}{k}_{s}{i}{z}{e}
leading {l}{e}{a}{d}{i}{n}{g}
left {l}{e}{f}{t}
length {l}{e}{n}{g}{t}{h}
level {l}{e}{v}{e}{l}
like {l}{i}{k}{e}
limit {l}{i}{m}{i}{t}
local {l}{o}{c}{a}{l}
locate {l}{o}{c}{a}{t}{e}
lock {l}{o}{c}{k}
lower {l}{o}{w}{e}{r}
low_priority {l}{o}{w}_{p}{r}{i}{o}{r}{i}{t}{y}
max_rows {m}{a}{x}_{r}{o}{w}{s}
microsecond {m}{i}{c}{r}{o}{s}{e}{c}{o}{n}{d}
minute {m}{i}{n}{u}{t}{e}
min_rows {m}{i}{n}_{r}{o}{w}{s}
mod {m}{o}{d}
mode {m}{o}{d}{e}
month {m}{o}{n}{t}{h}
names {n}{a}{m}{e}{s}
national {n}{a}{t}{i}{o}{n}{a}{l}
not {n}{o}{t}
offset {o}{f}{f}{s}{e}{t}
on {o}{n}
only {o}{n}{l}{y}
option {o}{p}{t}{i}{o}{n}
or {o}{r}
order {o}{r}{d}{e}{r}
outer {o}{u}{t}{e}{r}
password {p}{a}{s}{s}{w}{o}{r}{d}
pow {p}{o}{w}
power {p}{o}{w}{e}{r}
prepare {p}{r}{e}{p}{a}{r}{e}
primary {p}{r}{i}{m}{a}{r}{y}
procedure {p}{r}{o}{c}{e}{d}{u}{r}{e}
quarter {q}{u}{a}{r}{t}{e}{r}
quick {q}{u}{i}{c}{k}
rand {r}{a}{n}{d}
read {r}{e}{a}{d}
repeat {r}{e}{p}{e}{a}{t}
repeatable {r}{e}{p}{e}{a}{t}{a}{b}{l}{e}
references {r}{e}{f}{e}{r}{e}{n}{c}{e}{s}
regexp {r}{e}{g}{e}{x}{p}
replace {r}{e}{p}{l}{a}{c}{e}
redundant {r}{e}{d}{u}{n}{d}{a}{n}{t}
right {r}{i}{g}{h}{t}
rlike {r}{l}{i}{k}{e}
rollback {r}{o}{l}{l}{b}{a}{c}{k}
row {r}{o}{w}
row_format {r}{o}{w}_{f}{o}{r}{m}{a}{t}
schema {s}{c}{h}{e}{m}{a}
schemas {s}{c}{h}{e}{m}{a}{s}
second {s}{e}{c}{o}{n}{d}
select {s}{e}{l}{e}{c}{t}
serializable {s}{e}{r}{i}{a}{l}{i}{z}{a}{b}{l}{e}
session {s}{e}{s}{s}{i}{o}{n}
set {s}{e}{t}
share {s}{h}{a}{r}{e}
show {s}{h}{o}{w}
some {s}{o}{m}{e}
start {s}{t}{a}{r}{t}
status {s}{t}{a}{t}{u}{s}
subdate {s}{u}{b}{d}{a}{t}{e}
strcmp {s}{t}{r}{c}{m}{p}
substr {s}{u}{b}{s}{t}{r}
substring {s}{u}{b}{s}{t}{r}{i}{n}{g}
substring_index {s}{u}{b}{s}{t}{r}{i}{n}{g}_{i}{n}{d}{e}{x}
sum {s}{u}{m}
sysdate {s}{y}{s}{d}{a}{t}{e}
table {t}{a}{b}{l}{e}
tables {t}{a}{b}{l}{e}{s}
then {t}{h}{e}{n}
to {t}{o}
trailing {t}{r}{a}{i}{l}{i}{n}{g}
transaction {t}{r}{a}{n}{s}{a}{c}{t}{i}{o}{n}
triggers {t}{r}{i}{g}{g}{e}{r}{s}
trim {t}{r}{i}{m}
truncate {t}{r}{u}{n}{c}{a}{t}{e}
max {m}{a}{x}
min {m}{i}{n}
uncommitted {u}{n}{c}{o}{m}{m}{i}{t}{t}{e}{d}
unknown {u}{n}{k}{n}{o}{w}{n}
union {u}{n}{i}{o}{n}
unique {u}{n}{i}{q}{u}{e}
unlock {u}{n}{l}{o}{c}{k}
nullif {n}{u}{l}{l}{i}{f}
update {u}{p}{d}{a}{t}{e}
upper {u}{p}{p}{e}{r}
value {v}{a}{l}{u}{e}
values {v}{a}{l}{u}{e}{s}
variables {v}{a}{r}{i}{a}{b}{l}{e}{s}
version {v}{e}{r}{s}{i}{o}{n}
warnings {w}{a}{r}{n}{i}{n}{g}{s}
week {w}{e}{e}{k}
weekday {w}{e}{e}{k}{d}{a}{y}
weekofyear {w}{e}{e}{k}{o}{f}{y}{e}{a}{r}
where {w}{h}{e}{r}{e}
when {w}{h}{e}{n}
write {w}{r}{i}{t}{e}
xor {x}{o}{r}
yearweek {y}{e}{a}{r}{w}{e}{e}{k}
null {n}{u}{l}{l}
false {f}{a}{l}{s}{e}
true {t}{r}{u}{e}
calc_found_rows {s}{q}{l}_{c}{a}{l}{c}_{f}{o}{u}{n}{d}_{r}{o}{w}{s}
current_ts {c}{u}{r}{r}{e}{n}{t}_{t}{i}{m}{e}{s}{t}{a}{m}{p}
localtime {l}{o}{c}{a}{l}{t}{i}{m}{e}
localts {l}{o}{c}{a}{l}{t}{i}{m}{e}{s}{t}{a}{m}{p}
now {n}{o}{w}
bit {b}{i}{t}
tiny {t}{i}{n}{y}
tinyint {t}{i}{n}{y}{i}{n}{t}
smallint {s}{m}{a}{l}{l}{i}{n}{t}
mediumint {m}{e}{d}{i}{u}{m}{i}{n}{t}
int {i}{n}{t}
integer {i}{n}{t}{e}{g}{e}{r}
bigint {b}{i}{g}{i}{n}{t}
real {r}{e}{a}{l}
double {d}{o}{u}{b}{l}{e}
float {f}{l}{o}{a}{t}
decimal {d}{e}{c}{i}{m}{a}{l}
numeric {n}{u}{m}{e}{r}{i}{c}
date {d}{a}{t}{e}
time {t}{i}{m}{e}
timestamp {t}{i}{m}{e}{s}{t}{a}{m}{p}
datetime {d}{a}{t}{e}{t}{i}{m}{e}
year {y}{e}{a}{r}
char {c}{h}{a}{r}
varchar {v}{a}{r}{c}{h}{a}{r}
binary {b}{i}{n}{a}{r}{y}
varbinary {v}{a}{r}{b}{i}{n}{a}{r}{y}
tinyblob {t}{i}{n}{y}{b}{l}{o}{b}
blob {b}{l}{o}{b}
mediumblob {m}{e}{d}{i}{u}{m}{b}{l}{o}{b}
longblob {l}{o}{n}{g}{b}{l}{o}{b}
tinytext {t}{i}{n}{y}{t}{e}{x}{t}
text {t}{e}{x}{t}
mediumtext {m}{e}{d}{i}{u}{m}{t}{e}{x}{t}
longtext {l}{o}{n}{g}{t}{e}{x}{t}
enum {e}{n}{u}{m}
precision {p}{r}{e}{c}{i}{s}{i}{o}{n}
signed {s}{i}{g}{n}{e}{d}
unsigned {u}{n}{s}{i}{g}{n}{e}{d}
zerofill {z}{e}{r}{o}{f}{i}{l}{l}
bigrat {b}{i}{g}{r}{a}{t}
bool {b}{o}{o}{l}
boolean {b}{o}{o}{l}{e}{a}{n}
byte {b}{y}{t}{e}
duration {d}{u}{r}{a}{t}{i}{o}{n}
rune {r}{u}{n}{e}
string {s}{t}{r}{i}{n}{g}
use {u}{s}{e}
user {u}{s}{e}{r}
using {u}{s}{i}{n}{g}
idchar0 [a-zA-Z_]
idchars {idchar0}|[0-9$] // See: https://dev.mysql.com/doc/refman/5.7/en/identifiers.html
ident {idchar0}{idchars}*
user_var "@"{ident}
sys_var "@@"(({global}".")|({session}".")|{local}".")?{ident}
second_microsecond {s}{e}{c}{o}{n}{d}_{m}{i}{c}{r}{o}{s}{e}{c}{o}{n}{d}
minute_microsecond {m}{i}{n}{u}{t}{e}_{m}{i}{c}{r}{o}{s}{e}{c}{o}{n}{d}
minute_second {m}{i}{n}{u}{t}{e}_{s}{e}{c}{o}{n}{d}
hour_microsecond {h}{o}{u}{r}_{m}{i}{c}{r}{o}{s}{e}{c}{o}{n}{d}
hour_second {h}{o}{u}{r}_{s}{e}{c}{o}{n}{d}
hour_minute {h}{o}{u}{r}_{m}{i}{n}{u}{t}{e}
day_microsecond {d}{a}{y}_{m}{i}{c}{r}{o}{s}{e}{c}{o}{n}{d}
day_second {d}{a}{y}_{s}{e}{c}{o}{n}{d}
day_minute {d}{a}{y}_{m}{i}{n}{u}{t}{e}
day_hour {d}{a}{y}_{h}{o}{u}{r}
year_month {y}{e}{a}{r}_{m}{o}{n}{t}{h}
%yyc c
%yyn c = l.next()
%yyt l.sc
%x S1 S2 S3 S4
%%
l.val = l.val[:0]
c0, l.line, l.col = l.c, l.nline, l.ncol
<*>\0 return 0
[ \t\n\r]+
#.*
\/\/.*
\/\*([^*]|\*+[^*/])*\*+\/
-- l.sc = S3
<S3>[ \t]+.* {l.sc = 0}
<S3>[^ \t] {
l.sc = 0
l.c = '-'
n := len(l.val)
l.unget(l.val[n-1])
return '-'
}
{int_lit} return l.int(lval)
{float_lit} return l.float(lval)
{hex_lit} return l.hex(lval)
{bit_lit} return l.bit(lval)
\" l.sc = S1
' l.sc = S2
` l.sc = S4
<S1>[^\"\\]* l.stringLit = append(l.stringLit, l.val...)
<S1>\\. l.stringLit = append(l.stringLit, l.val...)
<S1>\"\" l.stringLit = append(l.stringLit, '"')
<S1>\" l.stringLit = append(l.stringLit, '"')
l.sc = 0
return l.str(lval, "\"")
<S2>[^'\\]* l.stringLit = append(l.stringLit, l.val...)
<S2>\\. l.stringLit = append(l.stringLit, l.val...)
<S2>'' l.stringLit = append(l.stringLit, '\'')
<S2>' l.stringLit = append(l.stringLit, '\'')
l.sc = 0
return l.str(lval, "'")
<S4>[^`]* l.stringLit = append(l.stringLit, l.val...)
<S4>`` l.stringLit = append(l.stringLit, '`')
<S4>` l.sc = 0
lval.item = string(l.stringLit)
l.stringLit = l.stringLit[0:0]
return identifier
"&&" return andand
"&^" return andnot
"<<" return lsh
"<=" return le
"=" return eq
">=" return ge
"!=" return neq
"<>" return neq
"||" return oror
">>" return rsh
"<=>" return nulleq
"@" return at
"?" return placeholder
{abs} lval.item = string(l.val)
return abs
{add} return add
{adddate} lval.item = string(l.val)
return addDate
{admin} lval.item = string(l.val)
return admin
{after} lval.item = string(l.val)
return after
{all} return all
{alter} return alter
{and} return and
{any} lval.item = string(l.val)
return any
{asc} return asc
{as} return as
{auto_increment} lval.item = string(l.val)
return autoIncrement
{avg} lval.item = string(l.val)
return avg
{avg_row_length} lval.item = string(l.val)
return avgRowLength
{begin} lval.item = string(l.val)
return begin
{between} return between
{both} return both
{btree} lval.item = string(l.val)
return btree
{by} return by
{case} return caseKwd
{cast} lval.item = string(l.val)
return cast
{character} return character
{charset} lval.item = string(l.val)
return charsetKwd
{check} return check
{checksum} lval.item = string(l.val)
return checksum
{coalesce} lval.item = string(l.val)
return coalesce
{collate} return collate
{collation} lval.item = string(l.val)
return collation
{column} return column
{columns} lval.item = string(l.val)
return columns
{comment} lval.item = string(l.val)
return comment
{commit} lval.item = string(l.val)
return commit
{committed} lval.item = string(l.val)
return committed
{compact} lval.item = string(l.val)
return compact
{compressed} lval.item = string(l.val)
return compressed
{compression} lval.item = string(l.val)
return compression
{concat} lval.item = string(l.val)
return concat
{concat_ws} lval.item = string(l.val)
return concatWs
{connection} lval.item = string(l.val)
return connection
{connection_id} lval.item = string(l.val)
return connectionID
{constraint} return constraint
{convert} lval.item = string(l.val)
return convert
{count} lval.item = string(l.val)
return count
{create} return create
{cross} return cross
{curdate} lval.item = string(l.val)
return curDate
{current_date} lval.item = string(l.val)
return currentDate
{curtime} lval.item = string(l.val)
return curTime
{current_time} lval.item = string(l.val)
return currentTime
{current_user} lval.item = string(l.val)
return currentUser
{database} lval.item = string(l.val)
return database
{databases} return databases
{date_add} lval.item = string(l.val)
return dateAdd
{date_sub} lval.item = string(l.val)
return dateSub
{day} lval.item = string(l.val)
return day
{dayname} lval.item = string(l.val)
return dayname
{dayofweek} lval.item = string(l.val)
return dayofweek
{dayofmonth} lval.item = string(l.val)
return dayofmonth
{dayofyear} lval.item = string(l.val)
return dayofyear
{day_hour} lval.item = string(l.val)
return dayHour
{day_microsecond} lval.item = string(l.val)
return dayMicrosecond
{day_minute} lval.item = string(l.val)
return dayMinute
{day_second} lval.item = string(l.val)
return daySecond
{ddl} return ddl
{deallocate} lval.item = string(l.val)
return deallocate
{default} return defaultKwd
{delayed} return delayed
{delay_key_write} lval.item = string(l.val)
return delayKeyWrite
{delete} return deleteKwd
{desc} return desc
{describe} return describe
{drop} return drop
{distinct} return distinct
{div} return div
{do} lval.item = string(l.val)
return do
{dual} return dual
{duplicate} lval.item = string(l.val)
return duplicate
{dynamic} lval.item = string(l.val)
return dynamic
{else} return elseKwd
{end} lval.item = string(l.val)
return end
{engine} lval.item = string(l.val)
return engine
{engines} lval.item = string(l.val)
return engines
{execute} lval.item = string(l.val)
return execute
{enum} return enum
{escape} lval.item = string(l.val)
return escape
{exists} return exists
{explain} return explain
{extract} lval.item = string(l.val)
return extract
{fields} lval.item = string(l.val)
return fields
{first} lval.item = string(l.val)
return first
{fixed} lval.item = string(l.val)
return fixed
{for} return forKwd
{foreign} return foreign
{found_rows} lval.item = string(l.val)
return foundRows
{from} return from
{full} lval.item = string(l.val)
return full
{fulltext} return fulltext
{grant} return grant
{grants} lval.item = string(l.val)
return grants
{group} return group
{group_concat} lval.item = string(l.val)
return groupConcat
{hash} lval.item = string(l.val)
return hash
{having} return having
{high_priority} return highPriority
{hour} lval.item = string(l.val)
return hour
{hour_microsecond} lval.item = string(l.val)
return hourMicrosecond
{hour_minute} lval.item = string(l.val)
return hourMinute
{hour_second} lval.item = string(l.val)
return hourSecond
{identified} lval.item = string(l.val)
return identified
{if} lval.item = string(l.val)
return ifKwd
{ifnull} lval.item = string(l.val)
return ifNull
{ignore} return ignore
{index} return index
{inner} return inner
{insert} return insert
{interval} return interval
{into} return into
{in} return in
{is} return is
{isolation} lval.item = string(l.val)
return isolation
{join} return join
{key} return key
{key_block_size} lval.item = string(l.val)
return keyBlockSize
{leading} return leading
{left} lval.item = string(l.val)
return left
{length} lval.item = string(l.val)
return length
{level} lval.item = string(l.val)
return level
{like} return like
{limit} return limit
{local} lval.item = string(l.val)
return local
{locate} lval.item = string(l.val)
return locate
{lock} return lock
{lower} lval.item = string(l.val)
return lower
{low_priority} return lowPriority
{max} lval.item = string(l.val)
return max
{max_rows} lval.item = string(l.val)
return maxRows
{microsecond} lval.item = string(l.val)
return microsecond
{min} lval.item = string(l.val)
return min
{minute} lval.item = string(l.val)
return minute
{minute_microsecond} lval.item = string(l.val)
return minuteMicrosecond
{minute_second} lval.item = string(l.val)
return minuteSecond
{min_rows} lval.item = string(l.val)
return minRows
{mod} return mod
{mode} lval.item = string(l.val)
return mode
{month} lval.item = string(l.val)
return month
{names} lval.item = string(l.val)
return names
{national} lval.item = string(l.val)
return national
{not} return not
{offset} lval.item = string(l.val)
return offset
{on} return on
{only} lval.item = string(l.val)
return only
{option} return option
{order} return order
{or} return or
{outer} return outer
{password} lval.item = string(l.val)
return password
{pow} lval.item = string(l.val)
return pow
{power} lval.item = string(l.val)
return power
{prepare} lval.item = string(l.val)
return prepare
{primary} return primary
{procedure} return procedure
{quarter} lval.item = string(l.val)
return quarter
{quick} lval.item = string(l.val)
return quick
redundant lval.item = string(l.val)
return redundant
{right} return right
{rollback} lval.item = string(l.val)
return rollback
{row} lval.item = string(l.val)
return row
{row_format} lval.item = string(l.val)
return rowFormat
{schema} lval.item = string(l.val)
return schema
{schemas} return schemas
{serializable} lval.item = string(l.val)
return serializable
{session} lval.item = string(l.val)
return session
{some} lval.item = string(l.val)
return some
{start} lval.item = string(l.val)
return start
{status} lval.item = string(l.val)
return status
{global} lval.item = string(l.val)
return global
{rand} lval.item = string(l.val)
return rand
{read} return read
{repeat} lval.item = string(l.val)
return repeat
{repeatable} lval.item = string(l.val)
return repeatable
{regexp} return regexpKwd
{replace} lval.item = string(l.val)
return replace
{references} return references
{rlike} return rlike
{sys_var} lval.item = string(l.val)
return sysVar
{user_var} lval.item = string(l.val)
return userVar
{second} lval.item = string(l.val)
return second
{second_microsecond} lval.item= string(l.val)
return secondMicrosecond
{select} return selectKwd
{set} return set
{share} return share
{show} return show
{subdate} lval.item = string(l.val)
return subDate
{strcmp} lval.item = string(l.val)
return strcmp
{substr} lval.item = string(l.val)
return substring
{substring} lval.item = string(l.val)
return substring
{substring_index} lval.item = string(l.val)
return substringIndex
{sum} lval.item = string(l.val)
return sum
{sysdate} lval.item = string(l.val)
return sysDate
{table} return tableKwd
{tables} lval.item = string(l.val)
return tables
{then} return then
{to} return to
{trailing} return trailing
{transaction} lval.item = string(l.val)
return transaction
{triggers} lval.item = string(l.val)
return triggers
{trim} lval.item = string(l.val)
return trim
{truncate} lval.item = string(l.val)
return truncate
{uncommitted} lval.item = string(l.val)
return uncommitted
{union} return union
{unique} return unique
{unknown} lval.item = string(l.val)
return unknown
{nullif} lval.item = string(l.val)
return nullIf
{unlock} return unlock
{update} return update
{upper} lval.item = string(l.val)
return upper
{use} return use
{user} lval.item = string(l.val)
return user
{using} return using
{value} lval.item = string(l.val)
return value
{values} return values
{variables} lval.item = string(l.val)
return variables
{version} lval.item = string(l.val)
return version
{warnings} lval.item = string(l.val)
return warnings
{week} lval.item = string(l.val)
return week
{weekday} lval.item = string(l.val)
return weekday
{weekofyear} lval.item = string(l.val)
return weekofyear
{when} return when
{where} return where
{write} return write
{xor} return xor
{yearweek} lval.item = string(l.val)
return yearweek
{year_month} lval.item = string(l.val)
return yearMonth
{signed} lval.item = string(l.val)
return signed
{unsigned} return unsigned
{zerofill} return zerofill
{null} lval.item = nil
return null
{false} return falseKwd
{true} return trueKwd
{calc_found_rows} lval.item = string(l.val)
return calcFoundRows
{current_ts} lval.item = string(l.val)
return currentTs
{localtime} return localTime
{localts} return localTs
{now} lval.item = string(l.val)
return now
{bit} lval.item = string(l.val)
return bitType
{tiny} lval.item = string(l.val)
return tinyIntType
{tinyint} lval.item = string(l.val)
return tinyIntType
{smallint} lval.item = string(l.val)
return smallIntType
{mediumint} lval.item = string(l.val)
return mediumIntType
{bigint} lval.item = string(l.val)
return bigIntType
{decimal} lval.item = string(l.val)
return decimalType
{numeric} lval.item = string(l.val)
return numericType
{float} lval.item = string(l.val)
return floatType
{double} lval.item = string(l.val)
return doubleType
{precision} lval.item = string(l.val)
return precisionType
{real} lval.item = string(l.val)
return realType
{date} lval.item = string(l.val)
return dateType
{time} lval.item = string(l.val)
return timeType
{timestamp} lval.item = string(l.val)
return timestampType
{datetime} lval.item = string(l.val)
return datetimeType
{year} lval.item = string(l.val)
return yearType
{char} lval.item = string(l.val)
return charType
{varchar} lval.item = string(l.val)
return varcharType
{binary} lval.item = string(l.val)
return binaryType
{varbinary} lval.item = string(l.val)
return varbinaryType
{tinyblob} lval.item = string(l.val)
return tinyblobType
{blob} lval.item = string(l.val)
return blobType
{mediumblob} lval.item = string(l.val)
return mediumblobType
{longblob} lval.item = string(l.val)
return longblobType
{tinytext} lval.item = string(l.val)
return tinytextType
{mediumtext} lval.item = string(l.val)
return mediumtextType
{text} lval.item = string(l.val)
return textType
{longtext} lval.item = string(l.val)
return longtextType
{bool} lval.item = string(l.val)
return boolType
{boolean} lval.item = string(l.val)
return booleanType
{byte} lval.item = string(l.val)
return byteType
{int} lval.item = string(l.val)
return intType
{integer} lval.item = string(l.val)
return integerType
{ident} lval.item = string(l.val)
return l.handleIdent(lval)
. return c0
%%
return int(unicode.ReplacementChar)
}
func (l *lexer) npos() (line, col int) {
if line, col = l.nline, l.ncol; col == 0 {
line--
col = l.lcol+1
}
return
}
func (l *lexer) str(lval *yySymType, pref string) int {
l.sc = 0
// TODO: performance issue.
s := string(l.stringLit)
l.stringLit = l.stringLit[0:0]
if pref == "'" {
s = strings.Replace(s, "\\'", "'", -1)
s = strings.TrimSuffix(s, "'") + "\""
pref = "\""
}
v := stringutil.RemoveUselessBackslash(pref+s)
v, err := strconv.Unquote(v)
if err != nil {
v = strings.TrimSuffix(s, pref)
}
lval.item = v
return stringLit
}
func (l *lexer) trimIdent(idt string) string {
idt = strings.TrimPrefix(idt, "`")
idt = strings.TrimSuffix(idt, "`")
return idt
}
func (l *lexer) int(lval *yySymType) int {
n, err := strconv.ParseUint(string(l.val), 0, 64)
if err != nil {
l.errf("integer literal: %v", err)
return int(unicode.ReplacementChar)
}
switch {
case n < math.MaxInt64:
lval.item = int64(n)
default:
lval.item = uint64(n)
}
return intLit
}
func (l *lexer) float(lval *yySymType) int {
n, err := strconv.ParseFloat(string(l.val), 64)
if err != nil {
l.errf("float literal: %v", err)
return int(unicode.ReplacementChar)
}
lval.item = float64(n)
return floatLit
}
// https://dev.mysql.com/doc/refman/5.7/en/hexadecimal-literals.html
func (l *lexer) hex(lval *yySymType) int {
s := string(l.val)
h, err := mysql.ParseHex(s)
if err != nil {
l.errf("hexadecimal literal: %v", err)
return int(unicode.ReplacementChar)
}
lval.item = h
return hexLit
}
// https://dev.mysql.com/doc/refman/5.7/en/bit-type.html
func (l *lexer) bit(lval *yySymType) int {
s := string(l.val)
b, err := mysql.ParseBit(s, -1)
if err != nil {
l.errf("bit literal: %v", err)
return int(unicode.ReplacementChar)
}
lval.item = b
return bitLit
}
func (l *lexer) handleIdent(lval *yySymType) int {
s := lval.item.(string)
// A character string literal may have an optional character set introducer and COLLATE clause:
// [_charset_name]'string' [COLLATE collation_name]
// See: https://dev.mysql.com/doc/refman/5.7/en/charset-literal.html
if !strings.HasPrefix(s, "_") {
return identifier
}
cs, _, err := charset.GetCharsetInfo(s[1:])
if err != nil {
return identifier
}
lval.item = cs
return underscoreCS
}