// Code generated by goyacc. DO NOT EDIT.

// GENERATED FILE DO NOT EDIT

//line sql-gen.y:24

package parser

import __yyfmt__ "fmt"

//line sql-gen.y:24

import (

"fmt"

"strings"

"go/constant"

"github.com/eandre/sqlparse/coltypes"

"github.com/eandre/sqlparse/lex"

"github.com/eandre/sqlparse/pkg/sql/privilege"

"github.com/eandre/sqlparse/sem/tree"

)

const MaxUint = ^uint(0)

const MaxInt = int(MaxUint >> 1)

func unimplemented(sqllex sqlLexer, feature string) int {

sqllex.(*Scanner).Unimplemented(feature)

return 1

}

func unimplementedWithIssue(sqllex sqlLexer, issue int) int {

sqllex.(*Scanner).UnimplementedWithIssue(issue)

return 1

}

func unimplementedWithIssueDetail(sqllex sqlLexer, issue int, detail string) int {

sqllex.(*Scanner).UnimplementedWithIssueDetail(issue, detail)

return 1

}

//line sql-gen.y:60

type sqlSymUnion struct {

val interface{}

}

func (u *sqlSymUnion) numVal() *tree.NumVal {

return u.val.(*tree.NumVal)

}

func (u *sqlSymUnion) strVal() *tree.StrVal {

}

func (u *sqlSymUnion) auditMode() tree.AuditMode {

return u.val.(tree.AuditMode)

}

func (u *sqlSymUnion) bool() bool {

return u.val.(bool)

}

func (u *sqlSymUnion) strPtr() *string {

return u.val.(*string)

}

func (u *sqlSymUnion) strs() []string {

return u.val.([]string)

}

func (u *sqlSymUnion) newTableWithIdx() *tree.TableNameWithIndex {

tn := u.val.(tree.TableNameWithIndex)

return &tn

}

func (u *sqlSymUnion) tableWithIdx() tree.TableNameWithIndex {

return u.val.(tree.TableNameWithIndex)

}

func (u *sqlSymUnion) newTableWithIdxList() tree.TableNameWithIndexList {

return u.val.(tree.TableNameWithIndexList)

}

func (u *sqlSymUnion) nameList() tree.NameList {

return u.val.(tree.NameList)

}

func (u *sqlSymUnion) unresolvedName() *tree.UnresolvedName {

return u.val.(*tree.UnresolvedName)

}

func (u *sqlSymUnion) functionReference() tree.FunctionReference {

return u.val.(tree.FunctionReference)

}

func (u *sqlSymUnion) tablePatterns() tree.TablePatterns {

return u.val.(tree.TablePatterns)

}

func (u *sqlSymUnion) tableNames() tree.TableNames {

return u.val.(tree.TableNames)

}

func (u *sqlSymUnion) indexFlags() *tree.IndexFlags {

return u.val.(*tree.IndexFlags)

}

func (u *sqlSymUnion) arraySubscript() *tree.ArraySubscript {

return u.val.(*tree.ArraySubscript)

}

func (u *sqlSymUnion) arraySubscripts() tree.ArraySubscripts {

}

func (u *sqlSymUnion) stmt() tree.Statement {

}

func (u *sqlSymUnion) stmts() []tree.Statement {

return u.val.([]tree.Statement)

}

func (u *sqlSymUnion) cte() *tree.CTE {

}

func (u *sqlSymUnion) ctes() []*tree.CTE {

return u.val.([]*tree.CTE)

}

func (u *sqlSymUnion) with() *tree.With {

}

func (u *sqlSymUnion) slct() *tree.Select {

return u.val.(*tree.Select)

}

func (u *sqlSymUnion) selectStmt() tree.SelectStatement {

return u.val.(tree.SelectStatement)

}

func (u *sqlSymUnion) colDef() *tree.ColumnTableDef {

return u.val.(*tree.ColumnTableDef)

}

func (u *sqlSymUnion) constraintDef() tree.ConstraintTableDef {

return u.val.(tree.ConstraintTableDef)

}

func (u *sqlSymUnion) tblDef() tree.TableDef {

return u.val.(tree.TableDef)

}

func (u *sqlSymUnion) tblDefs() tree.TableDefs {

return u.val.(tree.TableDefs)

}

func (u *sqlSymUnion) colQual() tree.NamedColumnQualification {

return u.val.(tree.NamedColumnQualification)

}

func (u *sqlSymUnion) colQualElem() tree.ColumnQualification {

return u.val.(tree.ColumnQualification)

}

func (u *sqlSymUnion) colQuals() []tree.NamedColumnQualification {

return u.val.([]tree.NamedColumnQualification)

}

func (u *sqlSymUnion) colType() coltypes.T {

}

func (u *sqlSymUnion) tableRefCols() []tree.ColumnID {

}

func (u *sqlSymUnion) castTargetType() coltypes.CastTargetType {

return u.val.(coltypes.CastTargetType)

}

func (u *sqlSymUnion) colTypes() []coltypes.T {

return u.val.([]coltypes.T)

}

func (u *sqlSymUnion) int64() int64 {

return u.val.(int64)

}

func (u *sqlSymUnion) seqOpt() tree.SequenceOption {

return u.val.(tree.SequenceOption)

}

func (u *sqlSymUnion) seqOpts() []tree.SequenceOption {

return u.val.([]tree.SequenceOption)

}

func (u *sqlSymUnion) expr() tree.Expr {

}

func (u *sqlSymUnion) exprs() tree.Exprs {

return u.val.(tree.Exprs)

}

func (u *sqlSymUnion) selExpr() tree.SelectExpr {

return u.val.(tree.SelectExpr)

}

func (u *sqlSymUnion) selExprs() tree.SelectExprs {

return u.val.(tree.SelectExprs)

}

func (u *sqlSymUnion) retClause() tree.ReturningClause {

return u.val.(tree.ReturningClause)

}

func (u *sqlSymUnion) aliasClause() tree.AliasClause {

return u.val.(tree.AliasClause)

}

func (u *sqlSymUnion) asOfClause() tree.AsOfClause {

return u.val.(tree.AsOfClause)

}

func (u *sqlSymUnion) tblExpr() tree.TableExpr {

return u.val.(tree.TableExpr)

}

func (u *sqlSymUnion) tblExprs() tree.TableExprs {

return u.val.(tree.TableExprs)

}

func (u *sqlSymUnion) from() *tree.From {

return u.val.(*tree.From)

}

func (u *sqlSymUnion) int32s() []int32 {

return u.val.([]int32)

}

func (u *sqlSymUnion) joinCond() tree.JoinCond {

return u.val.(tree.JoinCond)

}

func (u *sqlSymUnion) when() *tree.When {

return u.val.(*tree.When)

}

func (u *sqlSymUnion) whens() []*tree.When {

return u.val.([]*tree.When)

}

func (u *sqlSymUnion) updateExpr() *tree.UpdateExpr {

return u.val.(*tree.UpdateExpr)

}

func (u *sqlSymUnion) updateExprs() tree.UpdateExprs {

return u.val.(tree.UpdateExprs)

}

func (u *sqlSymUnion) limit() *tree.Limit {

return u.val.(*tree.Limit)

}

func (u *sqlSymUnion) targetList() tree.TargetList {

return u.val.(tree.TargetList)

}

func (u *sqlSymUnion) targetListPtr() *tree.TargetList {

return u.val.(*tree.TargetList)

}

func (u *sqlSymUnion) privilegeType() privilege.Kind {

return u.val.(privilege.Kind)

}

func (u *sqlSymUnion) privilegeList() privilege.List {

return u.val.(privilege.List)

}

func (u *sqlSymUnion) onConflict() *tree.OnConflict {

return u.val.(*tree.OnConflict)

}

func (u *sqlSymUnion) orderBy() tree.OrderBy {

return u.val.(tree.OrderBy)

}

func (u *sqlSymUnion) order() *tree.Order {

return u.val.(*tree.Order)

}

func (u *sqlSymUnion) orders() []*tree.Order {

return u.val.([]*tree.Order)

}

func (u *sqlSymUnion) groupBy() tree.GroupBy {

return u.val.(tree.GroupBy)

}

func (u *sqlSymUnion) windowFrame() *tree.WindowFrame {

return u.val.(*tree.WindowFrame)

}

func (u *sqlSymUnion) windowFrameBounds() tree.WindowFrameBounds {

return u.val.(tree.WindowFrameBounds)

}

func (u *sqlSymUnion) windowFrameBound() *tree.WindowFrameBound {

return u.val.(*tree.WindowFrameBound)

}

func (u *sqlSymUnion) distinctOn() tree.DistinctOn {

return u.val.(tree.DistinctOn)

}

func (u *sqlSymUnion) dir() tree.Direction {

return u.val.(tree.Direction)

}

func (u *sqlSymUnion) alterTableCmd() tree.AlterTableCmd {

return u.val.(tree.AlterTableCmd)

}

func (u *sqlSymUnion) alterTableCmds() tree.AlterTableCmds {

return u.val.(tree.AlterTableCmds)

}

func (u *sqlSymUnion) alterIndexCmd() tree.AlterIndexCmd {

return u.val.(tree.AlterIndexCmd)

}

func (u *sqlSymUnion) alterIndexCmds() tree.AlterIndexCmds {

return u.val.(tree.AlterIndexCmds)

}

func (u *sqlSymUnion) isoLevel() tree.IsolationLevel {

return u.val.(tree.IsolationLevel)

}

func (u *sqlSymUnion) userPriority() tree.UserPriority {

return u.val.(tree.UserPriority)

}

func (u *sqlSymUnion) readWriteMode() tree.ReadWriteMode {

return u.val.(tree.ReadWriteMode)

}

func (u *sqlSymUnion) idxElem() tree.IndexElem {

return u.val.(tree.IndexElem)

}

func (u *sqlSymUnion) idxElems() tree.IndexElemList {

return u.val.(tree.IndexElemList)

}

func (u *sqlSymUnion) dropBehavior() tree.DropBehavior {

return u.val.(tree.DropBehavior)

}

func (u *sqlSymUnion) validationBehavior() tree.ValidationBehavior {

return u.val.(tree.ValidationBehavior)

}

func (u *sqlSymUnion) interleave() *tree.InterleaveDef {

return u.val.(*tree.InterleaveDef)

}

func (u *sqlSymUnion) partitionBy() *tree.PartitionBy {

return u.val.(*tree.PartitionBy)

}

func (u *sqlSymUnion) listPartition() tree.ListPartition {

return u.val.(tree.ListPartition)

}

func (u *sqlSymUnion) listPartitions() []tree.ListPartition {

return u.val.([]tree.ListPartition)

}

func (u *sqlSymUnion) rangePartition() tree.RangePartition {

return u.val.(tree.RangePartition)

}

func (u *sqlSymUnion) rangePartitions() []tree.RangePartition {

return u.val.([]tree.RangePartition)

}

func (u *sqlSymUnion) setZoneConfig() *tree.SetZoneConfig {

return u.val.(*tree.SetZoneConfig)

}

func (u *sqlSymUnion) tuples() []*tree.Tuple {

return u.val.([]*tree.Tuple)

}

func (u *sqlSymUnion) tuple() *tree.Tuple {

return u.val.(*tree.Tuple)

}

func (u *sqlSymUnion) windowDef() *tree.WindowDef {

return u.val.(*tree.WindowDef)

}

func (u *sqlSymUnion) window() tree.Window {

return u.val.(tree.Window)

}

func (u *sqlSymUnion) op() tree.Operator {

return u.val.(tree.Operator)

}

func (u *sqlSymUnion) cmpOp() tree.ComparisonOperator {

return u.val.(tree.ComparisonOperator)

}

func (u *sqlSymUnion) durationField() tree.DurationField {

return u.val.(tree.DurationField)

}

func (u *sqlSymUnion) kvOption() tree.KVOption {

return u.val.(tree.KVOption)

}

func (u *sqlSymUnion) kvOptions() []tree.KVOption {

}

func (u *sqlSymUnion) transactionModes() tree.TransactionModes {

return u.val.(tree.TransactionModes)

}

func (u *sqlSymUnion) referenceAction() tree.ReferenceAction {

return u.val.(tree.ReferenceAction)

}

func (u *sqlSymUnion) referenceActions() tree.ReferenceActions {

return u.val.(tree.ReferenceActions)

}

func (u *sqlSymUnion) scrubOptions() tree.ScrubOptions {

return u.val.(tree.ScrubOptions)

}

func (u *sqlSymUnion) scrubOption() tree.ScrubOption {

return u.val.(tree.ScrubOption)

}

func (u *sqlSymUnion) resolvableFuncRefFromName() tree.ResolvableFunctionReference {

return tree.ResolvableFunctionReference{FunctionReference: u.unresolvedName()}

}

func (u *sqlSymUnion) rowsFromExpr() *tree.RowsFromExpr {

return u.val.(*tree.RowsFromExpr)

}

func newNameFromStr(s string) *tree.Name {

return (*tree.Name)(&s)

}

//line sql-gen.y:567

type sqlSymType struct {

}

const IDENT = lex.IDENT

const SCONST = lex.SCONST

const BCONST = lex.BCONST

const BITCONST = lex.BITCONST

const ICONST = lex.ICONST

const FCONST = lex.FCONST

const PLACEHOLDER = lex.PLACEHOLDER

const TYPECAST = lex.TYPECAST

const TYPEANNOTATE = lex.TYPEANNOTATE

const DOT_DOT = lex.DOT_DOT

const LESS_EQUALS = lex.LESS_EQUALS

const GREATER_EQUALS = lex.GREATER_EQUALS

const NOT_EQUALS = lex.NOT_EQUALS

const NOT_REGMATCH = lex.NOT_REGMATCH

const REGIMATCH = lex.REGIMATCH

const NOT_REGIMATCH = lex.NOT_REGIMATCH

const ERROR = lex.ERROR

const ABORT = lex.ABORT

const ACTION = lex.ACTION

const ADD = lex.ADD

const ADMIN = lex.ADMIN

const AGGREGATE = lex.AGGREGATE

const ALL = lex.ALL

const ALTER = lex.ALTER

const ANALYSE = lex.ANALYSE

const ANALYZE = lex.ANALYZE

const AND = lex.AND

const ANY = lex.ANY

const ANNOTATE_TYPE = lex.ANNOTATE_TYPE

const ARRAY = lex.ARRAY

const AS = lex.AS

const ASC = lex.ASC

const ASYMMETRIC = lex.ASYMMETRIC

const AT = lex.AT

const BACKUP = lex.BACKUP

const BEGIN = lex.BEGIN

const BETWEEN = lex.BETWEEN

const BIGINT = lex.BIGINT

const BIGSERIAL = lex.BIGSERIAL

const BIT = lex.BIT

const BLOB = lex.BLOB

const BOOL = lex.BOOL

const BOOLEAN = lex.BOOLEAN

const BOTH = lex.BOTH

const BY = lex.BY

const BYTEA = lex.BYTEA

const BYTES = lex.BYTES

const CACHE = lex.CACHE

const CANCEL = lex.CANCEL

const CASCADE = lex.CASCADE

const CASE = lex.CASE

const CAST = lex.CAST

const CHANGEFEED = lex.CHANGEFEED

const CHAR = lex.CHAR

const CHARACTER = lex.CHARACTER

const CHARACTERISTICS = lex.CHARACTERISTICS

const CHECK = lex.CHECK

const CLUSTER = lex.CLUSTER

const COALESCE = lex.COALESCE

const COLLATE = lex.COLLATE

const COLLATION = lex.COLLATION

const COLUMN = lex.COLUMN

const COLUMNS = lex.COLUMNS

const COMMENT = lex.COMMENT

const COMMIT = lex.COMMIT

const COMMITTED = lex.COMMITTED

const COMPACT = lex.COMPACT

const CONCAT = lex.CONCAT

const CONFIGURATION = lex.CONFIGURATION

const CONFIGURATIONS = lex.CONFIGURATIONS

const CONFIGURE = lex.CONFIGURE

const CONFLICT = lex.CONFLICT

const CONSTRAINT = lex.CONSTRAINT

const CONSTRAINTS = lex.CONSTRAINTS

const CONTAINS = lex.CONTAINS

const CONVERSION = lex.CONVERSION

const COPY = lex.COPY

const COVERING = lex.COVERING

const CREATE = lex.CREATE

const CROSS = lex.CROSS

const CUBE = lex.CUBE

const CURRENT = lex.CURRENT

const CURRENT_CATALOG = lex.CURRENT_CATALOG

const CURRENT_DATE = lex.CURRENT_DATE

const CURRENT_SCHEMA = lex.CURRENT_SCHEMA

const CURRENT_ROLE = lex.CURRENT_ROLE

const CURRENT_TIME = lex.CURRENT_TIME

const CURRENT_TIMESTAMP = lex.CURRENT_TIMESTAMP

const CURRENT_USER = lex.CURRENT_USER

const CYCLE = lex.CYCLE

const DATA = lex.DATA

const DATABASE = lex.DATABASE

const DATABASES = lex.DATABASES

const DATE = lex.DATE

const DAY = lex.DAY

const DEC = lex.DEC

const DECIMAL = lex.DECIMAL

const DEFAULT = lex.DEFAULT

const DEALLOCATE = lex.DEALLOCATE

const DEFERRABLE = lex.DEFERRABLE

const DEFERRED = lex.DEFERRED

const DELETE = lex.DELETE

const DESC = lex.DESC

const DISCARD = lex.DISCARD

const DISTINCT = lex.DISTINCT

const DO = lex.DO

const DOMAIN = lex.DOMAIN

const DOUBLE = lex.DOUBLE

const DROP = lex.DROP

const ELSE = lex.ELSE

const ENCODING = lex.ENCODING

const END = lex.END

const ENUM = lex.ENUM

const ESCAPE = lex.ESCAPE

const EXCEPT = lex.EXCEPT

const EXISTS = lex.EXISTS

const EXECUTE = lex.EXECUTE

const EXPERIMENTAL = lex.EXPERIMENTAL

const EXPERIMENTAL_FINGERPRINTS = lex.EXPERIMENTAL_FINGERPRINTS

const EXPERIMENTAL_REPLICA = lex.EXPERIMENTAL_REPLICA

const EXPERIMENTAL_AUDIT = lex.EXPERIMENTAL_AUDIT

const EXPLAIN = lex.EXPLAIN

const EXPORT = lex.EXPORT

const EXTENSION = lex.EXTENSION

const EXTRACT = lex.EXTRACT

const EXTRACT_DURATION = lex.EXTRACT_DURATION

const FALSE = lex.FALSE

const FAMILY = lex.FAMILY

const FETCH = lex.FETCH

const FETCHVAL = lex.FETCHVAL

const FETCHTEXT = lex.FETCHTEXT

const FETCHVAL_PATH = lex.FETCHVAL_PATH

const FETCHTEXT_PATH = lex.FETCHTEXT_PATH

const FILES = lex.FILES

const FILTER = lex.FILTER

const FIRST = lex.FIRST

const FLOAT = lex.FLOAT

const FLOAT4 = lex.FLOAT4

const FLOAT8 = lex.FLOAT8

const FLOORDIV = lex.FLOORDIV

const FOLLOWING = lex.FOLLOWING

const FOR = lex.FOR

const FORCE_INDEX = lex.FORCE_INDEX

const FOREIGN = lex.FOREIGN

const FROM = lex.FROM

const FULL = lex.FULL

const FUNCTION = lex.FUNCTION

const GLOBAL = lex.GLOBAL

const GRANT = lex.GRANT

const GRANTS = lex.GRANTS

const GREATEST = lex.GREATEST

const GROUP = lex.GROUP

const GROUPING = lex.GROUPING

const GROUPS = lex.GROUPS

const HAVING = lex.HAVING

const HIGH = lex.HIGH

const HISTOGRAM = lex.HISTOGRAM

const HOUR = lex.HOUR

const IMMEDIATE = lex.IMMEDIATE

const IMPORT = lex.IMPORT

const INCREMENT = lex.INCREMENT

const INCREMENTAL = lex.INCREMENTAL

const IF = lex.IF

const IFERROR = lex.IFERROR

const IFNULL = lex.IFNULL

const ILIKE = lex.ILIKE

const IN = lex.IN

const ISERROR = lex.ISERROR

const INET = lex.INET

const INET_CONTAINED_BY_OR_EQUALS = lex.INET_CONTAINED_BY_OR_EQUALS

const INET_CONTAINS_OR_CONTAINED_BY = lex.INET_CONTAINS_OR_CONTAINED_BY

const INET_CONTAINS_OR_EQUALS = lex.INET_CONTAINS_OR_EQUALS

const INDEX = lex.INDEX

const INDEXES = lex.INDEXES

const INJECT = lex.INJECT

const INTERLEAVE = lex.INTERLEAVE

const INITIALLY = lex.INITIALLY

const INNER = lex.INNER

const INSERT = lex.INSERT

const INT = lex.INT

const INT2VECTOR = lex.INT2VECTOR

const INT2 = lex.INT2

const INT4 = lex.INT4

const INT8 = lex.INT8

const INT64 = lex.INT64

const INTEGER = lex.INTEGER

const INTERSECT = lex.INTERSECT

const INTERVAL = lex.INTERVAL

const INTO = lex.INTO

const INVERTED = lex.INVERTED

const IS = lex.IS

const ISNULL = lex.ISNULL

const ISOLATION = lex.ISOLATION

const JOB = lex.JOB

const JOBS = lex.JOBS

const JOIN = lex.JOIN

const JSON = lex.JSON

const JSONB = lex.JSONB

const JSON_SOME_EXISTS = lex.JSON_SOME_EXISTS

const JSON_ALL_EXISTS = lex.JSON_ALL_EXISTS

const KEY = lex.KEY

const KEYS = lex.KEYS

const KV = lex.KV

const LANGUAGE = lex.LANGUAGE

const LATERAL = lex.LATERAL

const LC_CTYPE = lex.LC_CTYPE

const LC_COLLATE = lex.LC_COLLATE

const LEADING = lex.LEADING

const LEASE = lex.LEASE

const LEAST = lex.LEAST

const LEFT = lex.LEFT

const LESS = lex.LESS

const LEVEL = lex.LEVEL

const LIKE = lex.LIKE

const LIMIT = lex.LIMIT

const LIST = lex.LIST

const LOCAL = lex.LOCAL

const LOCALTIME = lex.LOCALTIME

const LOCALTIMESTAMP = lex.LOCALTIMESTAMP

const LOW = lex.LOW

const LSHIFT = lex.LSHIFT

const MATCH = lex.MATCH

const MATERIALIZED = lex.MATERIALIZED

const MINVALUE = lex.MINVALUE

const MAXVALUE = lex.MAXVALUE

const MINUTE = lex.MINUTE

const MONTH = lex.MONTH

const NAN = lex.NAN

const NAME = lex.NAME

const NAMES = lex.NAMES

const NATURAL = lex.NATURAL

const NEXT = lex.NEXT

const NO = lex.NO

const NO_INDEX_JOIN = lex.NO_INDEX_JOIN

const NORMAL = lex.NORMAL

const NOT = lex.NOT

const NOTHING = lex.NOTHING

const NOTNULL = lex.NOTNULL

const NULL = lex.NULL

const NULLIF = lex.NULLIF

const NUMERIC = lex.NUMERIC

const OF = lex.OF

const OFF = lex.OFF

const OFFSET = lex.OFFSET

const OID = lex.OID

const OIDS = lex.OIDS

const OIDVECTOR = lex.OIDVECTOR

const ON = lex.ON

const ONLY = lex.ONLY

const OPTION = lex.OPTION

const OPTIONS = lex.OPTIONS

const OR = lex.OR

const ORDER = lex.ORDER

const ORDINALITY = lex.ORDINALITY

const OUT = lex.OUT

const OUTER = lex.OUTER

const OVER = lex.OVER

const OVERLAPS = lex.OVERLAPS

const OVERLAY = lex.OVERLAY

const OWNED = lex.OWNED

const OPERATOR = lex.OPERATOR

const PARENT = lex.PARENT

const PARTIAL = lex.PARTIAL

const PARTITION = lex.PARTITION

const PASSWORD = lex.PASSWORD

const PAUSE = lex.PAUSE

const PHYSICAL = lex.PHYSICAL

const PLACING = lex.PLACING

const PLANS = lex.PLANS

const POSITION = lex.POSITION

const PRECEDING = lex.PRECEDING

const PRECISION = lex.PRECISION

const PREPARE = lex.PREPARE

const PRIMARY = lex.PRIMARY

const PRIORITY = lex.PRIORITY

const PROCEDURAL = lex.PROCEDURAL

const PUBLICATION = lex.PUBLICATION

const QUERIES = lex.QUERIES

const QUERY = lex.QUERY

const RANGE = lex.RANGE

const RANGES = lex.RANGES

const READ = lex.READ

const REAL = lex.REAL

const RECURSIVE = lex.RECURSIVE

const REF = lex.REF

const REFERENCES = lex.REFERENCES

const REGCLASS = lex.REGCLASS

const REGPROC = lex.REGPROC

const REGPROCEDURE = lex.REGPROCEDURE

const REGNAMESPACE = lex.REGNAMESPACE

const REGTYPE = lex.REGTYPE

const REMOVE_PATH = lex.REMOVE_PATH

const RENAME = lex.RENAME

const REPEATABLE = lex.REPEATABLE

const REPLACE = lex.REPLACE

const RELEASE = lex.RELEASE

const RESET = lex.RESET

const RESTORE = lex.RESTORE

const RESTRICT = lex.RESTRICT

const RESUME = lex.RESUME

const RETURNING = lex.RETURNING

const REVOKE = lex.REVOKE

const RIGHT = lex.RIGHT

const ROLE = lex.ROLE

const ROLES = lex.ROLES

const ROLLBACK = lex.ROLLBACK

const ROLLUP = lex.ROLLUP

const ROW = lex.ROW

const ROWS = lex.ROWS

const RSHIFT = lex.RSHIFT

const RULE = lex.RULE

const SAVEPOINT = lex.SAVEPOINT

const SCATTER = lex.SCATTER

const SCHEMA = lex.SCHEMA

const SCHEMAS = lex.SCHEMAS

const SCRUB = lex.SCRUB

const SEARCH = lex.SEARCH

const SECOND = lex.SECOND

const SELECT = lex.SELECT

const SEQUENCE = lex.SEQUENCE

const SEQUENCES = lex.SEQUENCES

const SERIAL = lex.SERIAL

const SERIAL2 = lex.SERIAL2

const SERIAL4 = lex.SERIAL4

const SERIAL8 = lex.SERIAL8

const SERIALIZABLE = lex.SERIALIZABLE

const SERVER = lex.SERVER

const SESSION = lex.SESSION

const SESSIONS = lex.SESSIONS

const SESSION_USER = lex.SESSION_USER

const SET = lex.SET

const SETTING = lex.SETTING

const SETTINGS = lex.SETTINGS

const SHOW = lex.SHOW

const SIMILAR = lex.SIMILAR

const SIMPLE = lex.SIMPLE

const SMALLINT = lex.SMALLINT

const SMALLSERIAL = lex.SMALLSERIAL

const SNAPSHOT = lex.SNAPSHOT

const SOME = lex.SOME

const SPLIT = lex.SPLIT

const SQL = lex.SQL

const START = lex.START

const STATISTICS = lex.STATISTICS

const STATUS = lex.STATUS

const STDIN = lex.STDIN

const STRICT = lex.STRICT

const STRING = lex.STRING

const STORE = lex.STORE

const STORED = lex.STORED

const STORING = lex.STORING

const SUBSTRING = lex.SUBSTRING

const SYMMETRIC = lex.SYMMETRIC

const SYNTAX = lex.SYNTAX

const SYSTEM = lex.SYSTEM

const SUBSCRIPTION = lex.SUBSCRIPTION

const TABLE = lex.TABLE

const TABLES = lex.TABLES

const TEMP = lex.TEMP

const TEMPLATE = lex.TEMPLATE

const TEMPORARY = lex.TEMPORARY

const TESTING_RANGES = lex.TESTING_RANGES

const EXPERIMENTAL_RANGES = lex.EXPERIMENTAL_RANGES

const TESTING_RELOCATE = lex.TESTING_RELOCATE

const EXPERIMENTAL_RELOCATE = lex.EXPERIMENTAL_RELOCATE

const TEXT = lex.TEXT

const THEN = lex.THEN

const TIME = lex.TIME

const TIMETZ = lex.TIMETZ

const TIMESTAMP = lex.TIMESTAMP

const TIMESTAMPTZ = lex.TIMESTAMPTZ

const TO = lex.TO

const TRAILING = lex.TRAILING

const TRACE = lex.TRACE

const TRANSACTION = lex.TRANSACTION

const TREAT = lex.TREAT

const TRIGGER = lex.TRIGGER

const TRIM = lex.TRIM

const TRUE = lex.TRUE

const TRUNCATE = lex.TRUNCATE

const TRUSTED = lex.TRUSTED

const TYPE = lex.TYPE

const TRACING = lex.TRACING

const UNBOUNDED = lex.UNBOUNDED

const UNCOMMITTED = lex.UNCOMMITTED

const UNION = lex.UNION

const UNIQUE = lex.UNIQUE

const UNKNOWN = lex.UNKNOWN

const UNLOGGED = lex.UNLOGGED

const UPDATE = lex.UPDATE

const UPSERT = lex.UPSERT

const USE = lex.USE

const USER = lex.USER

const USERS = lex.USERS

const USING = lex.USING

const UUID = lex.UUID

const VALID = lex.VALID

const VALIDATE = lex.VALIDATE

const VALUE = lex.VALUE

const VALUES = lex.VALUES

const VARBIT = lex.VARBIT

const VARCHAR = lex.VARCHAR

const VARIADIC = lex.VARIADIC

const VIEW = lex.VIEW

const VARYING = lex.VARYING

const VIRTUAL = lex.VIRTUAL

const WHEN = lex.WHEN

const WHERE = lex.WHERE

const WINDOW = lex.WINDOW

const WITH = lex.WITH

const WITHIN = lex.WITHIN

const WITHOUT = lex.WITHOUT

const WORK = lex.WORK

const WRITE = lex.WRITE

const YEAR = lex.YEAR

const ZONE = lex.ZONE

const NOT_LA = lex.NOT_LA

const WITH_LA = lex.WITH_LA

const AS_LA = lex.AS_LA

const CONTAINED_BY = lex.CONTAINED_BY

const POSTFIXOP = lex.POSTFIXOP

const UMINUS = lex.UMINUS

const HELPTOKEN = lex.HELPTOKEN

var sqlToknames = [...]string{

"$end",

"error",

"$unk",

"IDENT",

"SCONST",

"BCONST",

"BITCONST",

"ICONST",

"FCONST",

"PLACEHOLDER",

"TYPECAST",

"TYPEANNOTATE",

"DOT_DOT",

"LESS_EQUALS",

"GREATER_EQUALS",

"NOT_EQUALS",

"NOT_REGMATCH",

"REGIMATCH",

"NOT_REGIMATCH",

"ERROR",

"ABORT",

"ACTION",

"ADD",

"ADMIN",

"AGGREGATE",

"ALL",

"ALTER",

"ANALYSE",

"ANALYZE",

"AND",

"ANY",

"ANNOTATE_TYPE",

"ARRAY",

"AS",

"ASC",

"ASYMMETRIC",

"AT",

"BACKUP",

"BEGIN",

"BETWEEN",

"BIGINT",

"BIGSERIAL",

"BIT",

"BLOB",

"BOOL",

"BOOLEAN",

"BOTH",

"BY",

"BYTEA",

"BYTES",

"CACHE",

"CANCEL",

"CASCADE",

"CASE",

"CAST",

"CHANGEFEED",

"CHAR",

"CHARACTER",

"CHARACTERISTICS",

"CHECK",

"CLUSTER",

"COALESCE",

"COLLATE",

"COLLATION",

"COLUMN",

"COLUMNS",

"COMMENT",

"COMMIT",

"COMMITTED",

"COMPACT",

"CONCAT",

"CONFIGURATION",

"CONFIGURATIONS",

"CONFIGURE",

"CONFLICT",

"CONSTRAINT",

"CONSTRAINTS",

"CONTAINS",

"CONVERSION",

"COPY",

"COVERING",

"CREATE",

"CROSS",

"CUBE",

"CURRENT",

"CURRENT_CATALOG",

"CURRENT_DATE",

"CURRENT_SCHEMA",

"CURRENT_ROLE",

"CURRENT_TIME",

"CURRENT_TIMESTAMP",

"CURRENT_USER",

"CYCLE",

"DATA",

"DATABASE",

"DATABASES",

"DATE",

"DAY",

"DEC",

"DECIMAL",

"DEFAULT",

"DEALLOCATE",

"DEFERRABLE",

"DEFERRED",

"DELETE",

"DESC",

"DISCARD",

"DISTINCT",

"DO",

"DOMAIN",

"DOUBLE",

"DROP",

"ELSE",

"ENCODING",

"END",

"ENUM",

"ESCAPE",

"EXCEPT",

"EXISTS",

"EXECUTE",

"EXPERIMENTAL",

"EXPERIMENTAL_FINGERPRINTS",

"EXPERIMENTAL_REPLICA",

"EXPERIMENTAL_AUDIT",

"EXPLAIN",

"EXPORT",

"EXTENSION",

"EXTRACT",

"EXTRACT_DURATION",

"FALSE",

"FAMILY",

"FETCH",

"FETCHVAL",

"FETCHTEXT",

"FETCHVAL_PATH",

"FETCHTEXT_PATH",

"FILES",

"FILTER",

"FIRST",

"FLOAT",

"FLOAT4",

"FLOAT8",

"FLOORDIV",

"FOLLOWING",

"FOR",

"FORCE_INDEX",

"FOREIGN",

"FROM",

"FULL",

"FUNCTION",

"GLOBAL",

"GRANT",

"GRANTS",

"GREATEST",

"GROUP",

"GROUPING",

"GROUPS",

"HAVING",

"HIGH",

"HISTOGRAM",

"HOUR",

"IMMEDIATE",

"IMPORT",

"INCREMENT",

"INCREMENTAL",

"IF",

"IFERROR",

"IFNULL",

"ILIKE",

"IN",

"ISERROR",

"INET",

"INET_CONTAINED_BY_OR_EQUALS",

"INET_CONTAINS_OR_CONTAINED_BY",

"INET_CONTAINS_OR_EQUALS",

"INDEX",

"INDEXES",

"INJECT",

"INTERLEAVE",

"INITIALLY",

"INNER",