summaryrefslogtreecommitdiffstats
path: root/vendor/github.com/pingcap/tidb/parser/scanner.l
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/pingcap/tidb/parser/scanner.l')
-rw-r--r--vendor/github.com/pingcap/tidb/parser/scanner.l1259
1 files changed, 0 insertions, 1259 deletions
diff --git a/vendor/github.com/pingcap/tidb/parser/scanner.l b/vendor/github.com/pingcap/tidb/parser/scanner.l
deleted file mode 100644
index a322b4080e..0000000000
--- a/vendor/github.com/pingcap/tidb/parser/scanner.l
+++ /dev/null
@@ -1,1259 +0,0 @@
-%{
-// 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
-}
generated by cgit v1.2.3 (git 2.39.1) at 2025-03-10 12:12:28 +0000